notion2hast 0.1.1

package/dist/lib/block.js

@@ -0,0 +1,555 @@
+import { h } from 'hastscript';
+import { classnames } from 'hast-util-classnames';
+import { mergeProps } from './props.js';
+export function isBlock(o) {
+    if (o.object === 'block' && typeof o.type === 'string') {
+        return true;
+    }
+    return false;
+}
+export class BlockItem {
+    constructor(client, opts) {
+        this.client = client;
+        this.opts = opts;
+        this.blocks = [];
+        this.next_cursor = null;
+        this.blocksLen = 0;
+        this.idx = 0;
+    }
+    async init() {
+        let res = await this.client.listBlockChildren({
+            block_id: this.opts.block_id
+        });
+        this.blocks = res.results || [];
+        this.next_cursor = res.next_cursor;
+        this.blocksLen = this.blocks.length;
+        this.idx = 0;
+    }
+    async block() {
+        if (this.idx >= this.blocksLen) {
+            if (this.next_cursor) {
+                let res = await this.client.listBlockChildren({
+                    block_id: this.opts.block_id,
+                    start_cursor: this.next_cursor || undefined
+                });
+                this.blocks = res.results || [];
+                this.next_cursor = res.next_cursor;
+                this.blocksLen = this.blocks.length;
+                this.idx = 0;
+            }
+            else {
+                return null;
+            }
+        }
+        if (this.blocksLen === 0) {
+            return null;
+        }
+        const ret = this.blocks[this.idx];
+        this.idx++;
+        if (isBlock(ret)) {
+            return ret;
+        }
+        return null;
+    }
+}
+export class BlockToHastBuilder {
+    constructor(blockType, opts) {
+        this.propertiesMap = {};
+        this.blockType = blockType;
+        this.defaultClassname = opts.defaultClassname || false;
+        this.propertiesMap = { ...(opts.propertiesMap || {}) };
+    }
+    props(key) {
+        const ret = { ...(this.propertiesMap[key] || {}) };
+        if (this.defaultClassname) {
+            if (typeof ret.className === 'undefined') {
+                ret.className = key;
+            }
+        }
+        return ret;
+    }
+}
+export class BlockParagraphToHast extends BlockToHastBuilder {
+    constructor(opts = {}) {
+        super('paragraph', opts);
+    }
+    outerTag() {
+        return { name: null };
+    }
+    async build({ block, nest, richTextToHast, colorProps }) {
+        if (this.blockType === block.type) {
+            return [
+                h('p', mergeProps(this.props('paragraph'), colorProps.props(block[block.type].color)), ...(await richTextToHast.build(block[block.type].rich_text)), ...nest)
+            ];
+        }
+        return [];
+    }
+    isBreak(_prevType) {
+        return true;
+    }
+}
+export class BlockHeading1ToHast extends BlockToHastBuilder {
+    constructor(opts = {}) {
+        super('heading_1', opts);
+    }
+    outerTag() {
+        return { name: null };
+    }
+    async build({ block, nest, richTextToHast, colorProps }) {
+        if (this.blockType === block.type) {
+            return [
+                h('h1', mergeProps(this.props('heading-1'), colorProps.props(block[block.type].color)), ...(await richTextToHast.build(block[block.type].rich_text)), ...nest)
+            ];
+        }
+        return [];
+    }
+    isBreak(_prevType) {
+        return true;
+    }
+}
+export class BlockHeading2ToHast extends BlockToHastBuilder {
+    constructor(opts = {}) {
+        super('heading_2', opts);
+    }
+    outerTag() {
+        return { name: null };
+    }
+    async build({ block, nest, richTextToHast, colorProps }) {
+        if (this.blockType === block.type) {
+            return [
+                h('h2', mergeProps(this.props('heading-2'), colorProps.props(block[block.type].color)), ...(await richTextToHast.build(block[block.type].rich_text)), ...nest)
+            ];
+        }
+        return [];
+    }
+    isBreak(_prevType) {
+        return true;
+    }
+}
+export class BlockHeading3ToHast extends BlockToHastBuilder {
+    constructor(opts = {}) {
+        super('heading_3', opts);
+    }
+    outerTag() {
+        return { name: null };
+    }
+    async build({ block, nest, richTextToHast, colorProps }) {
+        if (this.blockType === block.type) {
+            return [
+                h('h3', mergeProps(this.props('heading-3'), colorProps.props(block[block.type].color)), ...(await richTextToHast.build(block[block.type].rich_text)), ...nest)
+            ];
+        }
+        return [];
+    }
+    isBreak(_prevType) {
+        return true;
+    }
+}
+export class BlockCodeToHast extends BlockToHastBuilder {
+    constructor(opts = {}) {
+        super('code', opts);
+    }
+    outerTag() {
+        return { name: null };
+    }
+    async build({ block, nest, richTextToHast }) {
+        if (this.blockType === block.type) {
+            const lang = block[block.type].language || '';
+            const codeCode = h('code', this.props('code-code'), ...(await richTextToHast.build(block[block.type].rich_text)));
+            classnames(codeCode, lang);
+            const caption = await richTextToHast.build(block[block.type].caption);
+            const codeCaptin = caption.length > 0
+                ? h('figcaption', this.props('code-caption'), ...caption)
+                : null;
+            return [
+                h('figure', this.props('code'), h('pre', this.props('code-pre'), codeCode), codeCaptin, ...nest)
+            ];
+        }
+        return [];
+    }
+    isBreak(_prevType) {
+        return true;
+    }
+}
+export class BlockCalloutToHast extends BlockToHastBuilder {
+    constructor(opts = {}) {
+        super('callout', opts);
+    }
+    outerTag() {
+        return { name: null };
+    }
+    async build({ block, nest, richTextToHast, colorProps }) {
+        if (this.blockType === block.type) {
+            const iconSrc = block[block.type].icon;
+            let icon = '';
+            if (iconSrc?.type === 'emoji') {
+                icon = h('div', this.props('callout-icon-emoji'), iconSrc.emoji);
+            }
+            else if (iconSrc?.type === 'external') {
+                icon = h('div', this.props('callout-icon-image'), h('img', { src: iconSrc.external.url }));
+            }
+            else if (iconSrc?.type === 'file') {
+                icon = h('div', this.props('callout-icon-image'), h('img', { src: iconSrc.file.url }));
+            }
+            return [
+                h('div', mergeProps(this.props('callout'), colorProps.props(block[block.type].color)), icon, h('div', this.props('callout-paragraph'), h('p', {}, ...(await richTextToHast.build(block[block.type].rich_text)))), ...nest)
+            ];
+        }
+        return [];
+    }
+    isBreak(_prevType) {
+        return true;
+    }
+}
+export class BlockDividerToHast extends BlockToHastBuilder {
+    constructor(opts = {}) {
+        super('divider', opts);
+    }
+    outerTag() {
+        return { name: null };
+    }
+    async build({ block, nest }) {
+        if (this.blockType === block.type) {
+            return [h('hr', this.props('divider'), ...nest)];
+        }
+        return [];
+    }
+    isBreak(_prevType) {
+        return true;
+    }
+}
+export class BlockColumnListToHast extends BlockToHastBuilder {
+    constructor(opts = {}) {
+        super('column_list', opts);
+    }
+    outerTag() {
+        return { name: null };
+    }
+    async build({ block, nest, richTextToHast }) {
+        if (this.blockType === block.type) {
+            return [h('div', this.props('column-list'), ...nest)];
+        }
+        return [];
+    }
+    isBreak(_prevType) {
+        return true;
+    }
+}
+export class BlockColumnToHast extends BlockToHastBuilder {
+    constructor(opts = {}) {
+        super('column', opts);
+    }
+    outerTag() {
+        return { name: null };
+    }
+    async build({ block, nest, richTextToHast }) {
+        if (this.blockType === block.type) {
+            return [h('div', this.props('column'), ...nest)];
+        }
+        return [];
+    }
+    isBreak(_prevType) {
+        return true;
+    }
+}
+export class BlockBulletedListItemToHast extends BlockToHastBuilder {
+    constructor(opts = {}) {
+        super('bulleted_list_item', opts);
+    }
+    outerTag() {
+        return { name: 'ul', properties: this.props('bulleted-list') };
+    }
+    async build({ block, nest, richTextToHast, colorProps }) {
+        if (this.blockType === block.type) {
+            return [
+                h('li', mergeProps(this.props('bulleted-list-item'), colorProps.props(block[block.type].color)), ...(await richTextToHast.build(block[block.type].rich_text)), ...nest)
+            ];
+        }
+        return [];
+    }
+    isBreak(prevType) {
+        if (this.blockType === prevType) {
+            return false;
+        }
+        return true;
+    }
+}
+export class BlockNumberedListItemToHast extends BlockToHastBuilder {
+    constructor(opts = {}) {
+        super('numbered_list_item', opts);
+    }
+    outerTag() {
+        return { name: 'ol', properties: this.props('numbered-list') };
+    }
+    async build({ block, nest, richTextToHast, colorProps }) {
+        if (this.blockType === block.type) {
+            return [
+                h('li', mergeProps(this.props('numbered-list-item'), colorProps.props(block[block.type].color)), ...(await richTextToHast.build(block[block.type].rich_text)), ...nest)
+            ];
+        }
+        return [];
+    }
+    isBreak(prevType) {
+        if (this.blockType === prevType) {
+            return false;
+        }
+        return true;
+    }
+}
+export class BlockQuoteToHast extends BlockToHastBuilder {
+    constructor(opts = {}) {
+        super('quote', opts);
+    }
+    outerTag() {
+        return { name: null };
+    }
+    async build({ block, nest, richTextToHast, colorProps }) {
+        if (this.blockType === block.type) {
+            return [
+                h('blockquote', mergeProps(this.props('quote'), colorProps.props(block[block.type].color)), ...(await richTextToHast.build(block[block.type].rich_text)), ...nest)
+            ];
+        }
+        return [];
+    }
+    isBreak(_prevType) {
+        return true;
+    }
+}
+export class BlockTodoToHast extends BlockToHastBuilder {
+    constructor(opts = {}) {
+        super('to_do', opts);
+    }
+    outerTag() {
+        return { name: null };
+    }
+    async build({ block, nest, richTextToHast, colorProps }) {
+        if (this.blockType === block.type) {
+            const todo = block[block.type];
+            return [
+                h('div', mergeProps(this.props('todo'), colorProps.props(todo.color)), h('div', this.props(todo.checked ? 'todo-checked' : 'todo-not-checked')), h('div', this.props('todo-text'), ...(await richTextToHast.build(todo.rich_text))), ...nest)
+            ];
+        }
+        return [];
+    }
+    isBreak(_prevType) {
+        return true;
+    }
+}
+export class BlockToggleToHast extends BlockToHastBuilder {
+    constructor(opts = {}) {
+        super('toggle', opts);
+    }
+    outerTag() {
+        return { name: null };
+    }
+    async build({ block, nest, richTextToHast, colorProps }) {
+        if (this.blockType === block.type) {
+            return [
+                h('details', mergeProps(this.props('toggle'), colorProps.props(block[block.type].color)), h('summary', this.props('toggle-summary'), ...(await richTextToHast.build(block[block.type].rich_text))), ...nest)
+            ];
+        }
+        return [];
+    }
+    isBreak(_prevType) {
+        return true;
+    }
+}
+export class BlockTableToHast extends BlockToHastBuilder {
+    constructor(opts = {}) {
+        super('table', opts);
+    }
+    outerTag() {
+        return { name: null };
+    }
+    async build({ block, nest, richTextToHast }) {
+        if (this.blockType === block.type) {
+            return [h('table', this.props('table'), ...nest)];
+        }
+        return [];
+    }
+    isBreak(_prevType) {
+        return true;
+    }
+}
+export class BlockTableRowToHast extends BlockToHastBuilder {
+    constructor(opts = {}) {
+        super('table_row', opts);
+    }
+    outerTag() {
+        return { name: null };
+    }
+    async build({ block, nest, parent, index, richTextToHast }) {
+        if (this.blockType === block.type) {
+            let has_column_header = false;
+            let has_row_header = false;
+            if (parent && parent.type === 'table') {
+                has_column_header = parent.table.has_column_header;
+                has_row_header = parent.table.has_row_header;
+            }
+            const cells = [];
+            let colIdx = 0;
+            for (const cell of block[block.type].cells) {
+                let tagName = 'td';
+                let properties = this.props('table-row-cell');
+                if ((has_column_header && index === 0) ||
+                    (has_row_header && colIdx === 0)) {
+                    // index がテーブル行と一致している前提
+                    tagName = 'th';
+                }
+                if (tagName === 'th') {
+                    properties = this.props('table-row-header');
+                    if (index === 0 && colIdx === 0) {
+                        properties = Object.assign({}, properties, this.props('table-row-header-top-left'));
+                    }
+                    else if (index === 0) {
+                        properties = Object.assign({}, properties, this.props('table-row-header-top'));
+                    }
+                    else if (colIdx === 0) {
+                        properties = Object.assign({}, properties, this.props('table-row-header-left'));
+                    }
+                }
+                cells.push(h(tagName, properties, ...(await richTextToHast.build(cell))));
+                colIdx++;
+            }
+            return [h('tr', this.props('table-row'), ...cells, ...nest)];
+        }
+        return [];
+    }
+    isBreak(_prevType) {
+        return true;
+    }
+}
+export class BlockBookmarkToHast extends BlockToHastBuilder {
+    constructor(opts = {}) {
+        super('bookmark', opts);
+    }
+    outerTag() {
+        return { name: null };
+    }
+    async build({ block, nest, richTextToHast }) {
+        if (this.blockType === block.type) {
+            const caption = await richTextToHast.build(block[block.type].caption);
+            const bookmarkCaption = caption.length > 0
+                ? h('figcaption', this.props('bookmark-caption'), ...caption)
+                : null;
+            return [
+                h('figure', this.props('bookmark'), h('a', Object.assign({}, this.props('bookmark-link'), {
+                    href: block[block.type].url
+                }), block[block.type].url), bookmarkCaption, ...nest)
+            ];
+        }
+        return [];
+    }
+    isBreak(_prevType) {
+        return true;
+    }
+}
+export class BlockImageToHast extends BlockToHastBuilder {
+    constructor(opts = {}) {
+        super('image', opts);
+    }
+    outerTag() {
+        return { name: null };
+    }
+    async build({ block, nest, richTextToHast }) {
+        if (this.blockType === block.type) {
+            const image = block[block.type];
+            let src = image.type === 'external' ? image.external.url : image.file.url;
+            const children = [
+                h('img', Object.assign({}, this.props('image-img'), { src }))
+            ];
+            const caption = await richTextToHast.build(image.caption);
+            if (caption.length > 0) {
+                children.push(h('figcaption', this.props('image-caption'), ...caption));
+            }
+            return [h('figure', this.props('image'), ...children, ...nest)];
+        }
+        return [];
+    }
+    isBreak(_prevType) {
+        return true;
+    }
+}
+export class SurroundElement {
+    constructor(initType, opts = {}) {
+        this.prevType = '';
+        this.children = [];
+        this.blockToHastBuilders = {};
+        this.prevType = initType;
+        const buildersOpts = opts.blockToHastBuilderOpts || {};
+        if (typeof buildersOpts.defaultClassname === 'undefined') {
+            buildersOpts.defaultClassname = opts.defaultClassName;
+        }
+        this.blockToHastBuilders = Object.assign({}, this.defaultBlockToHastBuilders(buildersOpts), opts.blockToHastBuilders || {});
+    }
+    defaultBlockToHastBuilders(opts) {
+        return {
+            paragraph: new BlockParagraphToHast(opts),
+            heading_1: new BlockHeading1ToHast(opts),
+            heading_2: new BlockHeading2ToHast(opts),
+            heading_3: new BlockHeading3ToHast(opts),
+            code: new BlockCodeToHast(opts),
+            callout: new BlockCalloutToHast(opts),
+            divider: new BlockDividerToHast(opts),
+            column_list: new BlockColumnListToHast(opts),
+            column: new BlockColumnToHast(opts),
+            bulleted_list_item: new BlockBulletedListItemToHast(opts),
+            numbered_list_item: new BlockNumberedListItemToHast(opts),
+            quote: new BlockQuoteToHast(opts),
+            to_do: new BlockTodoToHast(opts),
+            toggle: new BlockToggleToHast(opts),
+            table: new BlockTableToHast(opts),
+            table_row: new BlockTableRowToHast(opts),
+            bookmark: new BlockBookmarkToHast(opts),
+            image: new BlockImageToHast(opts)
+        };
+    }
+    builder(blockType) {
+        if (blockType) {
+            return this.blockToHastBuilders[blockType];
+        }
+        return undefined;
+    }
+    async append({ block, nest, parent, index, richTextToHast, colorProps }) {
+        const builder = this.builder(block.type);
+        if (builder) {
+            this.children.push(...(await builder.build({
+                block,
+                nest,
+                parent,
+                index,
+                richTextToHast,
+                colorProps
+            })));
+        }
+        this.prevType = block.type;
+        return;
+    }
+    nest(contet) {
+        this.children.push(contet);
+    }
+    outerTag() {
+        const builder = this.builder(this.prevType);
+        if (builder) {
+            return builder.outerTag();
+        }
+        return null;
+    }
+    content() {
+        return this.children;
+    }
+    isBreak(cur) {
+        if (this.prevType === '') {
+            return false;
+        }
+        const builder = this.builder(this.prevType);
+        if (builder) {
+            return builder.isBreak(cur);
+        }
+        return true;
+    }
+    reset() {
+        this.prevType = '';
+        this.children = [];
+    }
+}

package/dist/lib/client.d.ts

@@ -0,0 +1,4 @@
+import { Client as NotionClient } from '@notionhq/client';
+export declare abstract class Client {
+    abstract listBlockChildren(...args: Parameters<NotionClient['blocks']['children']['list']>): Promise<ReturnType<NotionClient['blocks']['children']['list']>>;
+}

package/dist/lib/client.js

@@ -0,0 +1,2 @@
+export class Client {
+}

package/dist/lib/color.d.ts

@@ -0,0 +1,8 @@
+import { HProperties } from 'hastscript/lib/core';
+import { ColorPropsOpts } from './types';
+export declare class ColorProps {
+    private defaultColorPropertiesMap;
+    private colorPropertiesMap;
+    constructor(opts: ColorPropsOpts);
+    props(color: string): HProperties;
+}

package/dist/lib/color.js

@@ -0,0 +1,33 @@
+// https://optemization.com/notion-color-guide
+const colorPropertiesMap = {
+    gray: { style: 'color:#9B9A97' },
+    brown: { style: 'color:#64473A' },
+    orange: { style: 'color:#D9730D' },
+    yellow: { style: 'color:#DFAB01' },
+    green: { style: 'color:#0F7B6C' },
+    blue: { style: 'color:#0B6E99' },
+    purple: { style: 'color:#6940A5' },
+    pink: { style: 'color:#AD1A72' },
+    red: { style: 'color:#E03E3E' },
+    gray_background: { style: 'background-color:#EBECED' },
+    brown_background: { style: 'background-color:#E9E5E3' },
+    orange_background: { style: 'background-color:#FAEBDD' },
+    yellow_background: { style: 'background-color:#FBF3DB' },
+    green_background: { style: 'background-color:#DDEDEA' },
+    blue_background: { style: 'background-color:#DDEBF1' },
+    purple_background: { style: 'background-color:#EAE4F2' },
+    pink_background: { style: 'background-color:#F4DFEB' },
+    red_background: { style: 'background-color:#FBE4E4' }
+};
+export class ColorProps {
+    constructor(opts) {
+        this.colorPropertiesMap = {};
+        Object.assign(this.colorPropertiesMap, this.defaultColorPropertiesMap(), opts.colorPropertiesMap || {});
+    }
+    defaultColorPropertiesMap() {
+        return colorPropertiesMap;
+    }
+    props(color) {
+        return { ...(this.colorPropertiesMap[color] || {}) };
+    }
+}

package/dist/lib/notion2hast.d.ts

@@ -0,0 +1,4 @@
+import { Node } from 'hastscript/lib/core';
+import { ToHastOpts } from './types.js';
+import { Client } from './client.js';
+export declare function blockToHast(client: Client, opts: ToHastOpts, depth?: number): Promise<Node>;

package/dist/lib/notion2hast.js

@@ -0,0 +1,49 @@
+import { h } from 'hastscript';
+import { BlockItem, SurroundElement } from './block.js';
+import { RichTextToHast } from './richtext.js';
+import { ColorProps } from './color.js';
+export async function blockToHast(client, opts, depth = 0) {
+    const colorProps = new ColorProps({
+        ...opts.colorPropsOpts
+    });
+    const richTextToHast = new RichTextToHast(opts.richTexttoHastOpts || {}, colorProps);
+    const children = [];
+    //const ite = blockItem(client, opts)
+    const ite = new BlockItem(client, opts);
+    await ite.init();
+    let index = 0;
+    let i = await ite.block();
+    const surround = new SurroundElement('', opts.blocktoHastOpts || {});
+    while (i !== null) {
+        while (i !== null && !surround.isBreak(i.type)) {
+            const nest = [];
+            if (i.has_children) {
+                const a = await blockToHast(client, Object.assign({}, opts, { block_id: i.id, parent: i }), depth + 1);
+                // surround.nest(a)
+                nest.push(a);
+            }
+            await surround.append({
+                block: i,
+                nest,
+                parent: opts.parent,
+                index,
+                richTextToHast,
+                colorProps
+            });
+            index++;
+            i = await ite.block();
+        }
+        const tag = surround.outerTag();
+        if (tag && tag.name) {
+            children.push(h(tag.name, tag.properties || {}, ...surround.content()));
+        }
+        else {
+            children.push(h(null, ...surround.content()));
+        }
+        surround.reset();
+    }
+    if (depth === 0) {
+        return h(null, ...children);
+    }
+    return children;
+}

package/dist/lib/props.d.ts

@@ -0,0 +1,2 @@
+import { HProperties } from 'hastscript/lib/core';
+export declare function mergeProps(p: HProperties, { className, style, ...others }: HProperties): HProperties;

package/dist/lib/props.js

@@ -0,0 +1,30 @@
+import { classnames } from 'hast-util-classnames';
+export function mergeProps(p, { className, style, ...others }) {
+    const ret = { ...p };
+    // className(class) をマージ.
+    Object.assign(ret, others);
+    if (typeof className === 'string' || Array.isArray(className)) {
+        if (typeof p.className === 'string' || Array.isArray(p.className)) {
+            const c = classnames(p.className, className);
+            if (Array.isArray(c)) {
+                ret.className = c;
+            }
+        }
+        else {
+            ret.className = className;
+        }
+    }
+    // style をマージ、単純な文字列の連結.
+    // ダメそうだったら以下を検討.
+    // https://www.npmjs.com/package/style-to-object
+    // https://www.npmjs.com/package/to-style
+    if (typeof style === 'string') {
+        let ps = `${p.style || ''}`.trimEnd();
+        let dlm = '';
+        if (ps && !ps.endsWith(';')) {
+            dlm = ';';
+        }
+        ret.style = `${ps}${dlm}${style}`;
+    }
+    return ret;
+}