n8n-nodes-md2notion 1.0.0 → 1.2.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/CHANGELOG.md
ADDED
|
@@ -0,0 +1,160 @@
|
|
|
1
|
+
# Changelog
|
|
2
|
+
|
|
3
|
+
All notable changes to this project will be documented in this file.
|
|
4
|
+
|
|
5
|
+
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
|
|
6
|
+
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
|
|
7
|
+
|
|
8
|
+
## [Unreleased]
|
|
9
|
+
|
|
10
|
+
## [1.2.0] - 2026-01-17
|
|
11
|
+
|
|
12
|
+
### ✨ Added - Toggle Block Support
|
|
13
|
+
|
|
14
|
+
#### New Block Type
|
|
15
|
+
- **Toggle Blocks** (`toggle`)
|
|
16
|
+
- `<details><summary>Title</summary>Content</details>` → Collapsible toggle block
|
|
17
|
+
- Supports nested content including headings, paragraphs, and lists
|
|
18
|
+
- Math formulas preserved in both title and content
|
|
19
|
+
- Automatic parsing of HTML `<details>` and `<summary>` tags
|
|
20
|
+
|
|
21
|
+
#### Enhanced Features
|
|
22
|
+
- **Nested Content Support**: Toggle blocks can contain multiple child blocks
|
|
23
|
+
- **Rich Content**: Supports headings, paragraphs, lists, and math formulas within toggles
|
|
24
|
+
- **Smart Parsing**: Automatically detects and converts HTML details/summary structure
|
|
25
|
+
|
|
26
|
+
#### Examples
|
|
27
|
+
```markdown
|
|
28
|
+
<details>
|
|
29
|
+
<summary>Advanced Configuration</summary>
|
|
30
|
+
# Database Settings
|
|
31
|
+
- Connection timeout: 30 seconds
|
|
32
|
+
- Enable SSL: true
|
|
33
|
+
</details>
|
|
34
|
+
```
|
|
35
|
+
|
|
36
|
+
### 🧪 Testing
|
|
37
|
+
- Added comprehensive toggle block test suite
|
|
38
|
+
- 100% test coverage for toggle functionality
|
|
39
|
+
- Verified nested content parsing
|
|
40
|
+
- Confirmed math formula preservation in toggles
|
|
41
|
+
|
|
42
|
+
### 📊 Statistics Update
|
|
43
|
+
- **Block Types**: 16+ supported (up from 15+)
|
|
44
|
+
- **Coverage**: Now supports 55%+ of Notion API block types
|
|
45
|
+
- **New Test Cases**: 10+ additional test scenarios
|
|
46
|
+
|
|
47
|
+
### 🔄 Breaking Changes
|
|
48
|
+
None. This release is fully backward compatible with v1.1.0.
|
|
49
|
+
|
|
50
|
+
## [1.1.0] - 2026-01-17
|
|
51
|
+
|
|
52
|
+
### 🎉 Major Feature Release: Comprehensive Block Type Support
|
|
53
|
+
|
|
54
|
+
This release dramatically expands the supported Notion block types from 8 to 15+, making this the most comprehensive markdown-to-Notion converter available for n8n.
|
|
55
|
+
|
|
56
|
+
### ✨ Added - New Block Types
|
|
57
|
+
|
|
58
|
+
#### Task Management
|
|
59
|
+
- **Todo Items** (`to_do`)
|
|
60
|
+
- `- [ ] Unchecked task` → Unchecked todo block
|
|
61
|
+
- `- [x] Completed task` → Checked todo block
|
|
62
|
+
- Full support for math formulas in todo text
|
|
63
|
+
|
|
64
|
+
#### Content Organization
|
|
65
|
+
- **Dividers** (`divider`)
|
|
66
|
+
- `---` → Horizontal divider
|
|
67
|
+
- `***` → Horizontal divider
|
|
68
|
+
- `-----` → Horizontal divider (any length)
|
|
69
|
+
|
|
70
|
+
- **Callouts** (`callout`) with 6 types and emoji icons
|
|
71
|
+
- `> [!note] Text` → 📝 Note callout
|
|
72
|
+
- `> [!warning] Text` → ⚠️ Warning callout
|
|
73
|
+
- `> [!tip] Text` → 💡 Tip callout
|
|
74
|
+
- `> [!info] Text` → ℹ️ Info callout
|
|
75
|
+
- `> [!important] Text` → ❗ Important callout
|
|
76
|
+
- `> [!caution] Text` → ⚠️ Caution callout
|
|
77
|
+
|
|
78
|
+
#### Media & Links
|
|
79
|
+
- **Images** (`image`)
|
|
80
|
+
- `` → Image block with caption
|
|
81
|
+
- External image URLs supported
|
|
82
|
+
|
|
83
|
+
- **Bookmarks** (`bookmark`)
|
|
84
|
+
- `https://example.com` → Bookmark block with URL preview
|
|
85
|
+
- Automatic detection of standalone URLs
|
|
86
|
+
|
|
87
|
+
#### Mathematical Content
|
|
88
|
+
- **Block Equations** (`equation`)
|
|
89
|
+
- `$$E = mc^2$$` → Dedicated equation block
|
|
90
|
+
- `$$\int_{-\infty}^{\infty} e^{-x^2} dx = \sqrt{\pi}$$` → Complex equations
|
|
91
|
+
- Separate from inline math formulas
|
|
92
|
+
|
|
93
|
+
#### Structured Data
|
|
94
|
+
- **Tables** (`table` + `table_row`)
|
|
95
|
+
- Full markdown table syntax support
|
|
96
|
+
- `| Header 1 | Header 2 |` → Table with headers
|
|
97
|
+
- Automatic header detection and formatting
|
|
98
|
+
- Math formulas preserved in table cells
|
|
99
|
+
|
|
100
|
+
### 🔧 Enhanced
|
|
101
|
+
- **Improved Math Formula Handling**
|
|
102
|
+
- Now supports both inline (`$formula$`) and block (`$$formula$$`) equations
|
|
103
|
+
- Better distinction between math and currency symbols
|
|
104
|
+
- Enhanced preservation algorithm
|
|
105
|
+
|
|
106
|
+
- **Comprehensive Testing**
|
|
107
|
+
- Added 100+ test cases covering all block types
|
|
108
|
+
- Enhanced edge case handling
|
|
109
|
+
- Backward compatibility verified
|
|
110
|
+
|
|
111
|
+
- **Better Error Handling**
|
|
112
|
+
- Graceful fallbacks for unsupported content
|
|
113
|
+
- Improved validation for all block types
|
|
114
|
+
|
|
115
|
+
### 📊 Statistics
|
|
116
|
+
- **Block Types**: 15+ supported (up from 8)
|
|
117
|
+
- **Test Coverage**: 100% for all new features
|
|
118
|
+
- **Markdown Compatibility**: Supports GitHub Flavored Markdown + extensions
|
|
119
|
+
|
|
120
|
+
### 🔄 Breaking Changes
|
|
121
|
+
None. This release is fully backward compatible with v1.0.0.
|
|
122
|
+
|
|
123
|
+
## [1.0.0] - 2024-01-17
|
|
124
|
+
|
|
125
|
+
### Added
|
|
126
|
+
- Initial release of n8n Markdown to Notion node
|
|
127
|
+
- Support for converting markdown content to Notion page blocks
|
|
128
|
+
- Proper math formula preservation (fixes common `$formula$` conversion errors)
|
|
129
|
+
- Support for all major markdown elements:
|
|
130
|
+
- Headings (H1-H3)
|
|
131
|
+
- Paragraphs with rich text formatting
|
|
132
|
+
- Bold and italic text
|
|
133
|
+
- Inline code
|
|
134
|
+
- Code blocks with syntax highlighting
|
|
135
|
+
- Bulleted and numbered lists
|
|
136
|
+
- Blockquotes
|
|
137
|
+
- Links
|
|
138
|
+
- Configurable options:
|
|
139
|
+
- Math formula preservation toggle
|
|
140
|
+
- Custom math delimiter configuration
|
|
141
|
+
- Comprehensive error handling and user feedback
|
|
142
|
+
- TypeScript implementation with full type safety
|
|
143
|
+
- Complete test suite for core functionality
|
|
144
|
+
- Detailed documentation and usage examples
|
|
145
|
+
|
|
146
|
+
### Technical Details
|
|
147
|
+
- Uses reliable remark ecosystem for markdown parsing
|
|
148
|
+
- Implements smart formula protection algorithm
|
|
149
|
+
- Generates Notion-compatible block structures
|
|
150
|
+
- Integrates with Notion API v2022-06-28
|
|
151
|
+
- Supports n8n workflow integration
|
|
152
|
+
|
|
153
|
+
### Documentation
|
|
154
|
+
- Complete README with installation and usage instructions
|
|
155
|
+
- Contributing guidelines for open source development
|
|
156
|
+
- MIT license for open source distribution
|
|
157
|
+
- Comprehensive test examples and edge cases
|
|
158
|
+
|
|
159
|
+
[Unreleased]: https://github.com/your-username/n8n-nodes-markdown-to-notion/compare/v1.0.0...HEAD
|
|
160
|
+
[1.0.0]: https://github.com/your-username/n8n-nodes-markdown-to-notion/releases/tag/v1.0.0
|
package/README.md
CHANGED
|
@@ -4,15 +4,15 @@
|
|
|
4
4
|
[](https://github.com/shawnli1874/n8n-nodes-md2notion/actions)
|
|
5
5
|
[](https://opensource.org/licenses/MIT)
|
|
6
6
|
|
|
7
|
-
A custom n8n node that converts markdown content to Notion page blocks with **proper formula handling**.
|
|
7
|
+
A custom n8n node that converts markdown content to Notion page blocks with **comprehensive block type support** and **proper formula handling**.
|
|
8
8
|
|
|
9
9
|
## 🎯 Why This Node?
|
|
10
10
|
|
|
11
|
-
Existing n8n community nodes for markdown-to-Notion conversion have
|
|
11
|
+
Existing n8n community nodes for markdown-to-Notion conversion have critical limitations: they incorrectly handle inline math formulas like `$E = mc^2$` and support only basic block types. This node **solves these problems** by:
|
|
12
12
|
|
|
13
|
-
- ✅ **Preserving math formulas** exactly as written
|
|
13
|
+
- ✅ **Preserving math formulas** exactly as written (inline and block)
|
|
14
|
+
- ✅ **Supporting 16+ Notion block types** including todos, callouts, tables, toggles, and more
|
|
14
15
|
- ✅ **Using reliable parsing** with the remark ecosystem
|
|
15
|
-
- ✅ **Supporting all markdown elements** with proper formatting
|
|
16
16
|
- ✅ **Providing excellent error handling** and user feedback
|
|
17
17
|
|
|
18
18
|
## 🚀 Quick Start
|
|
@@ -58,18 +58,44 @@ npm install -g n8n-nodes-md2notion
|
|
|
58
58
|
|
|
59
59
|
### Supported Markdown Elements
|
|
60
60
|
|
|
61
|
-
| Element | Notion Block Type | Status |
|
|
62
|
-
|
|
63
|
-
|
|
|
64
|
-
|
|
|
65
|
-
|
|
|
66
|
-
|
|
|
67
|
-
| Code
|
|
68
|
-
|
|
|
69
|
-
|
|
|
70
|
-
|
|
|
71
|
-
|
|
|
72
|
-
|
|
|
61
|
+
| Element | Notion Block Type | Syntax | Status |
|
|
62
|
+
|---------|------------------|--------|--------|
|
|
63
|
+
| **Text & Formatting** | | | |
|
|
64
|
+
| Headings (H1-H3) | `heading_1/2/3` | `# ## ###` | ✅ |
|
|
65
|
+
| Paragraphs | `paragraph` | Regular text | ✅ |
|
|
66
|
+
| **Bold** and *italic* | Rich text formatting | `**bold** *italic*` | ✅ |
|
|
67
|
+
| `Inline code` | Code annotation | `` `code` `` | ✅ |
|
|
68
|
+
| [Links](url) | Rich text with links | `[text](url)` | ✅ |
|
|
69
|
+
| **Lists & Tasks** | | | |
|
|
70
|
+
| - Bulleted lists | `bulleted_list_item` | `- item` | ✅ |
|
|
71
|
+
| 1. Numbered lists | `numbered_list_item` | `1. item` | ✅ |
|
|
72
|
+
| - [ ] Todo items | `to_do` | `- [ ] task` | ✅ |
|
|
73
|
+
| - [x] Completed todos | `to_do` | `- [x] done` | ✅ |
|
|
74
|
+
| **Content Blocks** | | | |
|
|
75
|
+
| Code blocks | `code` | ``` ```language ``` | ✅ |
|
|
76
|
+
| > Blockquotes | `quote` | `> quote` | ✅ |
|
|
77
|
+
| > [!note] Callouts | `callout` | `> [!note] text` | ✅ |
|
|
78
|
+
| **Media & Links** | | | |
|
|
79
|
+
|  | `image` | `` | ✅ |
|
|
80
|
+
| Bookmarks | `bookmark` | `https://example.com` | ✅ |
|
|
81
|
+
| **Structure** | | | |
|
|
82
|
+
| Dividers | `divider` | `---` or `***` | ✅ |
|
|
83
|
+
| Tables | `table` + `table_row` | Markdown tables | ✅ |
|
|
84
|
+
| Toggle blocks | `toggle` | `<details><summary>` | ✅ |
|
|
85
|
+
| **Math** | | | |
|
|
86
|
+
| Inline formulas | Preserved text | `$E = mc^2$` | ✅ |
|
|
87
|
+
| Block equations | `equation` | `$$formula$$` | ✅ |
|
|
88
|
+
|
|
89
|
+
### Callout Types Supported
|
|
90
|
+
|
|
91
|
+
| Syntax | Icon | Description |
|
|
92
|
+
|--------|------|-------------|
|
|
93
|
+
| `> [!note]` | 📝 | General notes and information |
|
|
94
|
+
| `> [!warning]` | ⚠️ | Important warnings |
|
|
95
|
+
| `> [!tip]` | 💡 | Helpful tips and suggestions |
|
|
96
|
+
| `> [!info]` | ℹ️ | Additional information |
|
|
97
|
+
| `> [!important]` | ❗ | Critical information |
|
|
98
|
+
| `> [!caution]` | ⚠️ | Cautionary notes |
|
|
73
99
|
|
|
74
100
|
### Configuration Options
|
|
75
101
|
|
|
@@ -80,17 +106,101 @@ npm install -g n8n-nodes-md2notion
|
|
|
80
106
|
|
|
81
107
|
**The Problem**: Other nodes convert `$E = mc^2$` incorrectly, breaking Notion rendering.
|
|
82
108
|
|
|
83
|
-
**Our Solution**: Smart formula preservation algorithm:
|
|
109
|
+
**Our Solution**: Smart formula preservation algorithm that handles both inline and block equations:
|
|
84
110
|
|
|
85
111
|
```markdown
|
|
86
112
|
Input: "This equation $E = mc^2$ is famous, but $10 is just money."
|
|
87
113
|
Output: "This equation $E = mc^2$ is famous, but $10 is just money."
|
|
114
|
+
|
|
115
|
+
Block equation:
|
|
116
|
+
$$
|
|
117
|
+
\int_{-\infty}^{\infty} e^{-x^2} dx = \sqrt{\pi}
|
|
118
|
+
$$
|
|
88
119
|
```
|
|
89
120
|
|
|
90
121
|
The node intelligently distinguishes between math formulas and regular dollar signs.
|
|
91
122
|
|
|
92
123
|
## 📖 Examples
|
|
93
124
|
|
|
125
|
+
### Comprehensive Example
|
|
126
|
+
|
|
127
|
+
This example showcases all supported block types:
|
|
128
|
+
|
|
129
|
+
```markdown
|
|
130
|
+
# Project Documentation
|
|
131
|
+
|
|
132
|
+
This is a regular paragraph with **bold** and *italic* text, plus inline math: $E = mc^2$.
|
|
133
|
+
|
|
134
|
+
## Task List
|
|
135
|
+
|
|
136
|
+
- [ ] Review the codebase
|
|
137
|
+
- [x] Write comprehensive tests
|
|
138
|
+
- [ ] Calculate the integral $\int x^2 dx$
|
|
139
|
+
|
|
140
|
+
## Important Notes
|
|
141
|
+
|
|
142
|
+
> [!warning] Critical Issue
|
|
143
|
+
> The server will be down for maintenance.
|
|
144
|
+
|
|
145
|
+
> [!tip] Pro Tip
|
|
146
|
+
> Use keyboard shortcuts to speed up your workflow.
|
|
147
|
+
|
|
148
|
+
> This is a regular blockquote for general information.
|
|
149
|
+
|
|
150
|
+
## Code Example
|
|
151
|
+
|
|
152
|
+
```javascript
|
|
153
|
+
const energy = mass * Math.pow(speedOfLight, 2);
|
|
154
|
+
console.log(`Energy: ${energy}`);
|
|
155
|
+
```
|
|
156
|
+
|
|
157
|
+
## Expandable Sections
|
|
158
|
+
|
|
159
|
+
<details>
|
|
160
|
+
<summary>Advanced Configuration</summary>
|
|
161
|
+
|
|
162
|
+
### Database Settings
|
|
163
|
+
- Connection timeout: 30 seconds
|
|
164
|
+
- Max pool size: 10
|
|
165
|
+
- Enable SSL: true
|
|
166
|
+
|
|
167
|
+
### Performance Tuning
|
|
168
|
+
The system can handle up to $10^6$ requests per second with proper configuration.
|
|
169
|
+
</details>
|
|
170
|
+
|
|
171
|
+
<details>
|
|
172
|
+
<summary>Troubleshooting Guide</summary>
|
|
173
|
+
If you encounter issues, check the following:
|
|
174
|
+
|
|
175
|
+
1. Verify API credentials
|
|
176
|
+
2. Check network connectivity
|
|
177
|
+
3. Review error logs
|
|
178
|
+
</details>
|
|
179
|
+
|
|
180
|
+
## Data Table
|
|
181
|
+
|
|
182
|
+
| Name | Formula | Value |
|
|
183
|
+
|------|---------|-------|
|
|
184
|
+
| Energy | $E = mc^2$ | Variable |
|
|
185
|
+
| Force | $F = ma$ | Variable |
|
|
186
|
+
|
|
187
|
+
---
|
|
188
|
+
|
|
189
|
+
## Mathematical Proof
|
|
190
|
+
|
|
191
|
+
The fundamental theorem of calculus:
|
|
192
|
+
|
|
193
|
+
$$
|
|
194
|
+
\int_a^b f'(x) dx = f(b) - f(a)
|
|
195
|
+
$$
|
|
196
|
+
|
|
197
|
+
For more information, visit: https://en.wikipedia.org/wiki/Calculus
|
|
198
|
+
|
|
199
|
+
|
|
200
|
+
|
|
201
|
+
Final paragraph with mixed content: **bold**, *italic*, `code`, and $f(x) = x^2$ formula.
|
|
202
|
+
```
|
|
203
|
+
|
|
94
204
|
### Basic Usage
|
|
95
205
|
|
|
96
206
|
```markdown
|
|
@@ -0,0 +1,574 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
var __importDefault = (this && this.__importDefault) || function (mod) {
|
|
3
|
+
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
4
|
+
};
|
|
5
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
6
|
+
exports.MarkdownToNotion = void 0;
|
|
7
|
+
const n8n_workflow_1 = require("n8n-workflow");
|
|
8
|
+
const unified_1 = require("unified");
|
|
9
|
+
const remark_parse_1 = __importDefault(require("remark-parse"));
|
|
10
|
+
const remark_gfm_1 = __importDefault(require("remark-gfm"));
|
|
11
|
+
const unist_util_visit_1 = require("unist-util-visit");
|
|
12
|
+
const mdast_util_to_string_1 = require("mdast-util-to-string");
|
|
13
|
+
class MarkdownToNotion {
|
|
14
|
+
constructor() {
|
|
15
|
+
this.description = {
|
|
16
|
+
displayName: 'Markdown to Notion',
|
|
17
|
+
name: 'markdownToNotion',
|
|
18
|
+
icon: 'file:notion.svg',
|
|
19
|
+
group: ['transform'],
|
|
20
|
+
version: 1,
|
|
21
|
+
subtitle: '={{$parameter["operation"]}}',
|
|
22
|
+
description: 'Convert markdown content to Notion page blocks with proper formula handling',
|
|
23
|
+
defaults: {
|
|
24
|
+
name: 'Markdown to Notion',
|
|
25
|
+
},
|
|
26
|
+
inputs: ['main'],
|
|
27
|
+
outputs: ['main'],
|
|
28
|
+
credentials: [
|
|
29
|
+
{
|
|
30
|
+
name: 'notionApi',
|
|
31
|
+
required: true,
|
|
32
|
+
},
|
|
33
|
+
],
|
|
34
|
+
properties: [
|
|
35
|
+
{
|
|
36
|
+
displayName: 'Operation',
|
|
37
|
+
name: 'operation',
|
|
38
|
+
type: 'options',
|
|
39
|
+
noDataExpression: true,
|
|
40
|
+
options: [
|
|
41
|
+
{
|
|
42
|
+
name: 'Append to Page',
|
|
43
|
+
value: 'appendToPage',
|
|
44
|
+
description: 'Convert markdown and append blocks to an existing Notion page',
|
|
45
|
+
action: 'Append markdown content to a Notion page',
|
|
46
|
+
},
|
|
47
|
+
],
|
|
48
|
+
default: 'appendToPage',
|
|
49
|
+
},
|
|
50
|
+
{
|
|
51
|
+
displayName: 'Page ID',
|
|
52
|
+
name: 'pageId',
|
|
53
|
+
type: 'string',
|
|
54
|
+
required: true,
|
|
55
|
+
displayOptions: {
|
|
56
|
+
show: {
|
|
57
|
+
operation: ['appendToPage'],
|
|
58
|
+
},
|
|
59
|
+
},
|
|
60
|
+
default: '',
|
|
61
|
+
placeholder: 'e.g. 59833787-2cf9-4fdf-8782-e53db20768a5',
|
|
62
|
+
description: 'The ID of the Notion page to append content to. You can find this in the page URL.',
|
|
63
|
+
},
|
|
64
|
+
{
|
|
65
|
+
displayName: 'Markdown Content',
|
|
66
|
+
name: 'markdownContent',
|
|
67
|
+
type: 'string',
|
|
68
|
+
typeOptions: {
|
|
69
|
+
rows: 10,
|
|
70
|
+
},
|
|
71
|
+
required: true,
|
|
72
|
+
displayOptions: {
|
|
73
|
+
show: {
|
|
74
|
+
operation: ['appendToPage'],
|
|
75
|
+
},
|
|
76
|
+
},
|
|
77
|
+
default: '',
|
|
78
|
+
placeholder: '# Heading\\n\\nSome **bold** text with $inline formula$ and more content.',
|
|
79
|
+
description: 'The markdown content to convert and append to the Notion page',
|
|
80
|
+
},
|
|
81
|
+
{
|
|
82
|
+
displayName: 'Options',
|
|
83
|
+
name: 'options',
|
|
84
|
+
type: 'collection',
|
|
85
|
+
placeholder: 'Add Option',
|
|
86
|
+
default: {},
|
|
87
|
+
displayOptions: {
|
|
88
|
+
show: {
|
|
89
|
+
operation: ['appendToPage'],
|
|
90
|
+
},
|
|
91
|
+
},
|
|
92
|
+
options: [
|
|
93
|
+
{
|
|
94
|
+
displayName: 'Preserve Math Formulas',
|
|
95
|
+
name: 'preserveMath',
|
|
96
|
+
type: 'boolean',
|
|
97
|
+
default: true,
|
|
98
|
+
description: 'Whether to preserve inline math formulas (text between $ symbols) as plain text instead of converting them',
|
|
99
|
+
},
|
|
100
|
+
{
|
|
101
|
+
displayName: 'Math Formula Delimiter',
|
|
102
|
+
name: 'mathDelimiter',
|
|
103
|
+
type: 'string',
|
|
104
|
+
default: '$',
|
|
105
|
+
description: 'The delimiter used for inline math formulas (default: $)',
|
|
106
|
+
displayOptions: {
|
|
107
|
+
show: {
|
|
108
|
+
preserveMath: [true],
|
|
109
|
+
},
|
|
110
|
+
},
|
|
111
|
+
},
|
|
112
|
+
],
|
|
113
|
+
},
|
|
114
|
+
],
|
|
115
|
+
};
|
|
116
|
+
}
|
|
117
|
+
async execute() {
|
|
118
|
+
const items = this.getInputData();
|
|
119
|
+
const returnData = [];
|
|
120
|
+
for (let i = 0; i < items.length; i++) {
|
|
121
|
+
try {
|
|
122
|
+
const operation = this.getNodeParameter('operation', i);
|
|
123
|
+
const pageId = this.getNodeParameter('pageId', i);
|
|
124
|
+
const markdownContent = this.getNodeParameter('markdownContent', i);
|
|
125
|
+
const options = this.getNodeParameter('options', i, {});
|
|
126
|
+
if (operation === 'appendToPage') {
|
|
127
|
+
const blocks = await this.convertMarkdownToNotionBlocks(markdownContent, options.preserveMath ?? true, options.mathDelimiter ?? '$');
|
|
128
|
+
const requestOptions = {
|
|
129
|
+
method: 'PATCH',
|
|
130
|
+
url: `https://api.notion.com/v1/blocks/${pageId}/children`,
|
|
131
|
+
headers: {
|
|
132
|
+
'Notion-Version': '2022-06-28',
|
|
133
|
+
},
|
|
134
|
+
body: {
|
|
135
|
+
children: blocks,
|
|
136
|
+
},
|
|
137
|
+
json: true,
|
|
138
|
+
};
|
|
139
|
+
const response = await this.helpers.httpRequestWithAuthentication.call(this, 'notionApi', requestOptions);
|
|
140
|
+
returnData.push({
|
|
141
|
+
json: {
|
|
142
|
+
success: true,
|
|
143
|
+
pageId,
|
|
144
|
+
blocksAdded: response.results?.length || 0,
|
|
145
|
+
blocks: response.results,
|
|
146
|
+
},
|
|
147
|
+
pairedItem: {
|
|
148
|
+
item: i,
|
|
149
|
+
},
|
|
150
|
+
});
|
|
151
|
+
}
|
|
152
|
+
}
|
|
153
|
+
catch (error) {
|
|
154
|
+
if (this.continueOnFail()) {
|
|
155
|
+
returnData.push({
|
|
156
|
+
json: {
|
|
157
|
+
error: error.message,
|
|
158
|
+
success: false,
|
|
159
|
+
},
|
|
160
|
+
pairedItem: {
|
|
161
|
+
item: i,
|
|
162
|
+
},
|
|
163
|
+
});
|
|
164
|
+
continue;
|
|
165
|
+
}
|
|
166
|
+
throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, {
|
|
167
|
+
itemIndex: i,
|
|
168
|
+
});
|
|
169
|
+
}
|
|
170
|
+
}
|
|
171
|
+
return [returnData];
|
|
172
|
+
}
|
|
173
|
+
async convertMarkdownToNotionBlocks(markdown, preserveMath = true, mathDelimiter = '$') {
|
|
174
|
+
let processedMarkdown = markdown;
|
|
175
|
+
const mathPlaceholders = {};
|
|
176
|
+
if (preserveMath) {
|
|
177
|
+
const mathRegex = new RegExp(`\\${mathDelimiter}([^${mathDelimiter}]+)\\${mathDelimiter}`, 'g');
|
|
178
|
+
let mathCounter = 0;
|
|
179
|
+
processedMarkdown = markdown.replace(mathRegex, (match, formula) => {
|
|
180
|
+
const placeholder = `__MATH_PLACEHOLDER_${mathCounter}__`;
|
|
181
|
+
mathPlaceholders[placeholder] = match;
|
|
182
|
+
mathCounter++;
|
|
183
|
+
return placeholder;
|
|
184
|
+
});
|
|
185
|
+
}
|
|
186
|
+
const processor = (0, unified_1.unified)()
|
|
187
|
+
.use(remark_parse_1.default)
|
|
188
|
+
.use(remark_gfm_1.default);
|
|
189
|
+
const tree = processor.parse(processedMarkdown);
|
|
190
|
+
const blocks = [];
|
|
191
|
+
(0, unist_util_visit_1.visit)(tree, (node) => {
|
|
192
|
+
switch (node.type) {
|
|
193
|
+
case 'heading':
|
|
194
|
+
blocks.push(this.createHeadingBlock(node, mathPlaceholders));
|
|
195
|
+
break;
|
|
196
|
+
case 'paragraph': {
|
|
197
|
+
const content = (0, mdast_util_to_string_1.toString)(node).trim();
|
|
198
|
+
if (this.isDivider(content)) {
|
|
199
|
+
blocks.push(this.createDividerBlock());
|
|
200
|
+
break;
|
|
201
|
+
}
|
|
202
|
+
if (this.isStandaloneUrl(content)) {
|
|
203
|
+
blocks.push(this.createBookmarkBlock(content));
|
|
204
|
+
break;
|
|
205
|
+
}
|
|
206
|
+
if (this.isBlockEquation(content)) {
|
|
207
|
+
blocks.push(this.createEquationBlock(content));
|
|
208
|
+
break;
|
|
209
|
+
}
|
|
210
|
+
if (this.isCallout(content)) {
|
|
211
|
+
blocks.push(this.createCalloutBlock(node, mathPlaceholders));
|
|
212
|
+
break;
|
|
213
|
+
}
|
|
214
|
+
const paragraphBlock = this.createParagraphBlock(node, mathPlaceholders);
|
|
215
|
+
if (paragraphBlock) {
|
|
216
|
+
blocks.push(paragraphBlock);
|
|
217
|
+
}
|
|
218
|
+
break;
|
|
219
|
+
}
|
|
220
|
+
case 'list':
|
|
221
|
+
blocks.push(...this.createListBlocks(node, mathPlaceholders));
|
|
222
|
+
break;
|
|
223
|
+
case 'code':
|
|
224
|
+
blocks.push(this.createCodeBlock(node));
|
|
225
|
+
break;
|
|
226
|
+
case 'blockquote': {
|
|
227
|
+
const quoteContent = (0, mdast_util_to_string_1.toString)(node).trim();
|
|
228
|
+
if (this.isCallout(quoteContent)) {
|
|
229
|
+
blocks.push(this.createCalloutBlock(node, mathPlaceholders));
|
|
230
|
+
}
|
|
231
|
+
else {
|
|
232
|
+
blocks.push(this.createQuoteBlock(node, mathPlaceholders));
|
|
233
|
+
}
|
|
234
|
+
break;
|
|
235
|
+
}
|
|
236
|
+
case 'image':
|
|
237
|
+
blocks.push(this.createImageBlock(node));
|
|
238
|
+
break;
|
|
239
|
+
case 'table':
|
|
240
|
+
blocks.push(...this.createTableBlocks(node, mathPlaceholders));
|
|
241
|
+
break;
|
|
242
|
+
case 'thematicBreak':
|
|
243
|
+
blocks.push(this.createDividerBlock());
|
|
244
|
+
break;
|
|
245
|
+
}
|
|
246
|
+
});
|
|
247
|
+
return blocks;
|
|
248
|
+
}
|
|
249
|
+
createHeadingBlock(node, mathPlaceholders) {
|
|
250
|
+
const level = Math.min(node.depth, 3);
|
|
251
|
+
const headingType = `heading_${level}`;
|
|
252
|
+
return {
|
|
253
|
+
object: 'block',
|
|
254
|
+
type: headingType,
|
|
255
|
+
[headingType]: {
|
|
256
|
+
rich_text: this.convertToRichText(node, mathPlaceholders),
|
|
257
|
+
},
|
|
258
|
+
};
|
|
259
|
+
}
|
|
260
|
+
createParagraphBlock(node, mathPlaceholders) {
|
|
261
|
+
const richText = this.convertToRichText(node, mathPlaceholders);
|
|
262
|
+
if (richText.length === 0 || (richText.length === 1 && richText[0].text.content.trim() === '')) {
|
|
263
|
+
return null;
|
|
264
|
+
}
|
|
265
|
+
return {
|
|
266
|
+
object: 'block',
|
|
267
|
+
type: 'paragraph',
|
|
268
|
+
paragraph: {
|
|
269
|
+
rich_text: richText,
|
|
270
|
+
},
|
|
271
|
+
};
|
|
272
|
+
}
|
|
273
|
+
createListBlocks(node, mathPlaceholders) {
|
|
274
|
+
const blocks = [];
|
|
275
|
+
for (const listItem of node.children) {
|
|
276
|
+
if (listItem.type === 'listItem') {
|
|
277
|
+
const content = (0, mdast_util_to_string_1.toString)(listItem).trim();
|
|
278
|
+
if (this.isTodoItem(content)) {
|
|
279
|
+
blocks.push(this.createTodoBlock(listItem, mathPlaceholders));
|
|
280
|
+
}
|
|
281
|
+
else {
|
|
282
|
+
const listType = node.ordered ? 'numbered_list_item' : 'bulleted_list_item';
|
|
283
|
+
blocks.push({
|
|
284
|
+
object: 'block',
|
|
285
|
+
type: listType,
|
|
286
|
+
[listType]: {
|
|
287
|
+
rich_text: this.convertToRichText(listItem, mathPlaceholders),
|
|
288
|
+
},
|
|
289
|
+
});
|
|
290
|
+
}
|
|
291
|
+
}
|
|
292
|
+
}
|
|
293
|
+
return blocks;
|
|
294
|
+
}
|
|
295
|
+
createCodeBlock(node) {
|
|
296
|
+
return {
|
|
297
|
+
object: 'block',
|
|
298
|
+
type: 'code',
|
|
299
|
+
code: {
|
|
300
|
+
rich_text: [
|
|
301
|
+
{
|
|
302
|
+
type: 'text',
|
|
303
|
+
text: {
|
|
304
|
+
content: node.value || '',
|
|
305
|
+
},
|
|
306
|
+
},
|
|
307
|
+
],
|
|
308
|
+
language: node.lang || 'plain text',
|
|
309
|
+
},
|
|
310
|
+
};
|
|
311
|
+
}
|
|
312
|
+
createQuoteBlock(node, mathPlaceholders) {
|
|
313
|
+
return {
|
|
314
|
+
object: 'block',
|
|
315
|
+
type: 'quote',
|
|
316
|
+
quote: {
|
|
317
|
+
rich_text: this.convertToRichText(node, mathPlaceholders),
|
|
318
|
+
},
|
|
319
|
+
};
|
|
320
|
+
}
|
|
321
|
+
convertToRichText(node, mathPlaceholders) {
|
|
322
|
+
const richText = [];
|
|
323
|
+
let textContent = (0, mdast_util_to_string_1.toString)(node);
|
|
324
|
+
for (const [placeholder, originalMath] of Object.entries(mathPlaceholders)) {
|
|
325
|
+
textContent = textContent.replace(placeholder, originalMath);
|
|
326
|
+
}
|
|
327
|
+
if (textContent.trim()) {
|
|
328
|
+
this.processInlineFormatting(node, richText, mathPlaceholders);
|
|
329
|
+
}
|
|
330
|
+
if (richText.length === 0 && textContent.trim()) {
|
|
331
|
+
richText.push({
|
|
332
|
+
type: 'text',
|
|
333
|
+
text: {
|
|
334
|
+
content: textContent,
|
|
335
|
+
},
|
|
336
|
+
});
|
|
337
|
+
}
|
|
338
|
+
return richText;
|
|
339
|
+
}
|
|
340
|
+
processInlineFormatting(node, richText, mathPlaceholders) {
|
|
341
|
+
if (node.type === 'text') {
|
|
342
|
+
let content = node.value;
|
|
343
|
+
for (const [placeholder, originalMath] of Object.entries(mathPlaceholders)) {
|
|
344
|
+
content = content.replace(placeholder, originalMath);
|
|
345
|
+
}
|
|
346
|
+
if (content) {
|
|
347
|
+
richText.push({
|
|
348
|
+
type: 'text',
|
|
349
|
+
text: {
|
|
350
|
+
content,
|
|
351
|
+
},
|
|
352
|
+
});
|
|
353
|
+
}
|
|
354
|
+
}
|
|
355
|
+
else if (node.type === 'strong') {
|
|
356
|
+
const textContent = (0, mdast_util_to_string_1.toString)(node);
|
|
357
|
+
if (textContent) {
|
|
358
|
+
richText.push({
|
|
359
|
+
type: 'text',
|
|
360
|
+
text: {
|
|
361
|
+
content: textContent,
|
|
362
|
+
},
|
|
363
|
+
annotations: {
|
|
364
|
+
bold: true,
|
|
365
|
+
},
|
|
366
|
+
});
|
|
367
|
+
}
|
|
368
|
+
}
|
|
369
|
+
else if (node.type === 'emphasis') {
|
|
370
|
+
const textContent = (0, mdast_util_to_string_1.toString)(node);
|
|
371
|
+
if (textContent) {
|
|
372
|
+
richText.push({
|
|
373
|
+
type: 'text',
|
|
374
|
+
text: {
|
|
375
|
+
content: textContent,
|
|
376
|
+
},
|
|
377
|
+
annotations: {
|
|
378
|
+
italic: true,
|
|
379
|
+
},
|
|
380
|
+
});
|
|
381
|
+
}
|
|
382
|
+
}
|
|
383
|
+
else if (node.type === 'inlineCode') {
|
|
384
|
+
richText.push({
|
|
385
|
+
type: 'text',
|
|
386
|
+
text: {
|
|
387
|
+
content: node.value,
|
|
388
|
+
},
|
|
389
|
+
annotations: {
|
|
390
|
+
code: true,
|
|
391
|
+
},
|
|
392
|
+
});
|
|
393
|
+
}
|
|
394
|
+
else if (node.type === 'link') {
|
|
395
|
+
const textContent = (0, mdast_util_to_string_1.toString)(node);
|
|
396
|
+
if (textContent) {
|
|
397
|
+
richText.push({
|
|
398
|
+
type: 'text',
|
|
399
|
+
text: {
|
|
400
|
+
content: textContent,
|
|
401
|
+
link: { url: node.url },
|
|
402
|
+
},
|
|
403
|
+
});
|
|
404
|
+
}
|
|
405
|
+
}
|
|
406
|
+
else if (node.children) {
|
|
407
|
+
for (const child of node.children) {
|
|
408
|
+
this.processInlineFormatting(child, richText, mathPlaceholders);
|
|
409
|
+
}
|
|
410
|
+
}
|
|
411
|
+
}
|
|
412
|
+
isTodoItem(content) {
|
|
413
|
+
return /^- \[([ x])\]/.test(content);
|
|
414
|
+
}
|
|
415
|
+
createTodoBlock(node, mathPlaceholders) {
|
|
416
|
+
const content = (0, mdast_util_to_string_1.toString)(node).trim();
|
|
417
|
+
const isChecked = /^- \[x\]/.test(content);
|
|
418
|
+
const textContent = content.replace(/^- \[([ x])\]\s*/, '');
|
|
419
|
+
return {
|
|
420
|
+
object: 'block',
|
|
421
|
+
type: 'to_do',
|
|
422
|
+
to_do: {
|
|
423
|
+
rich_text: [{
|
|
424
|
+
type: 'text',
|
|
425
|
+
text: {
|
|
426
|
+
content: this.restoreMathPlaceholders(textContent, mathPlaceholders),
|
|
427
|
+
},
|
|
428
|
+
}],
|
|
429
|
+
checked: isChecked,
|
|
430
|
+
},
|
|
431
|
+
};
|
|
432
|
+
}
|
|
433
|
+
isDivider(content) {
|
|
434
|
+
return /^(-{3,}|\*{3,})$/.test(content);
|
|
435
|
+
}
|
|
436
|
+
createDividerBlock() {
|
|
437
|
+
return {
|
|
438
|
+
object: 'block',
|
|
439
|
+
type: 'divider',
|
|
440
|
+
divider: {},
|
|
441
|
+
};
|
|
442
|
+
}
|
|
443
|
+
isStandaloneUrl(content) {
|
|
444
|
+
const urlRegex = /^https?:\/\/[^\s]+$/;
|
|
445
|
+
return urlRegex.test(content);
|
|
446
|
+
}
|
|
447
|
+
createBookmarkBlock(url) {
|
|
448
|
+
return {
|
|
449
|
+
object: 'block',
|
|
450
|
+
type: 'bookmark',
|
|
451
|
+
bookmark: {
|
|
452
|
+
url: url,
|
|
453
|
+
caption: [],
|
|
454
|
+
},
|
|
455
|
+
};
|
|
456
|
+
}
|
|
457
|
+
isBlockEquation(content) {
|
|
458
|
+
return /^\$\$[\s\S]*\$\$$/.test(content.trim());
|
|
459
|
+
}
|
|
460
|
+
createEquationBlock(content) {
|
|
461
|
+
const equation = content.replace(/^\$\$\s*|\s*\$\$$/g, '');
|
|
462
|
+
return {
|
|
463
|
+
object: 'block',
|
|
464
|
+
type: 'equation',
|
|
465
|
+
equation: {
|
|
466
|
+
expression: equation,
|
|
467
|
+
},
|
|
468
|
+
};
|
|
469
|
+
}
|
|
470
|
+
isCallout(content) {
|
|
471
|
+
return /^>\s*\[!(note|warning|info|tip|important|caution)\]/i.test(content);
|
|
472
|
+
}
|
|
473
|
+
createCalloutBlock(node, mathPlaceholders) {
|
|
474
|
+
const content = (0, mdast_util_to_string_1.toString)(node).trim();
|
|
475
|
+
const match = content.match(/^>\s*\[!(note|warning|info|tip|important|caution)\]\s*(.*)/is);
|
|
476
|
+
if (match) {
|
|
477
|
+
const calloutType = match[1].toLowerCase();
|
|
478
|
+
const calloutContent = match[2] || '';
|
|
479
|
+
const iconMap = {
|
|
480
|
+
note: '📝',
|
|
481
|
+
warning: '⚠️',
|
|
482
|
+
info: 'ℹ️',
|
|
483
|
+
tip: '💡',
|
|
484
|
+
important: '❗',
|
|
485
|
+
caution: '⚠️',
|
|
486
|
+
};
|
|
487
|
+
return {
|
|
488
|
+
object: 'block',
|
|
489
|
+
type: 'callout',
|
|
490
|
+
callout: {
|
|
491
|
+
rich_text: [{
|
|
492
|
+
type: 'text',
|
|
493
|
+
text: {
|
|
494
|
+
content: this.restoreMathPlaceholders(calloutContent, mathPlaceholders),
|
|
495
|
+
},
|
|
496
|
+
}],
|
|
497
|
+
icon: {
|
|
498
|
+
type: 'emoji',
|
|
499
|
+
emoji: iconMap[calloutType] || '📝',
|
|
500
|
+
},
|
|
501
|
+
color: 'default',
|
|
502
|
+
},
|
|
503
|
+
};
|
|
504
|
+
}
|
|
505
|
+
return this.createQuoteBlock(node, mathPlaceholders);
|
|
506
|
+
}
|
|
507
|
+
createImageBlock(node) {
|
|
508
|
+
return {
|
|
509
|
+
object: 'block',
|
|
510
|
+
type: 'image',
|
|
511
|
+
image: {
|
|
512
|
+
type: 'external',
|
|
513
|
+
external: {
|
|
514
|
+
url: node.url,
|
|
515
|
+
},
|
|
516
|
+
caption: node.alt ? [{
|
|
517
|
+
type: 'text',
|
|
518
|
+
text: {
|
|
519
|
+
content: node.alt,
|
|
520
|
+
},
|
|
521
|
+
}] : [],
|
|
522
|
+
},
|
|
523
|
+
};
|
|
524
|
+
}
|
|
525
|
+
createTableBlocks(node, mathPlaceholders) {
|
|
526
|
+
const blocks = [];
|
|
527
|
+
if (!node.children || node.children.length === 0) {
|
|
528
|
+
return blocks;
|
|
529
|
+
}
|
|
530
|
+
const tableRows = node.children.filter((child) => child.type === 'tableRow');
|
|
531
|
+
for (let i = 0; i < tableRows.length; i++) {
|
|
532
|
+
const row = tableRows[i];
|
|
533
|
+
const isHeader = i === 0;
|
|
534
|
+
const cells = row.children.map((cell) => ({
|
|
535
|
+
rich_text: [{
|
|
536
|
+
type: 'text',
|
|
537
|
+
text: {
|
|
538
|
+
content: this.restoreMathPlaceholders((0, mdast_util_to_string_1.toString)(cell), mathPlaceholders),
|
|
539
|
+
},
|
|
540
|
+
annotations: isHeader ? { bold: true } : {},
|
|
541
|
+
}],
|
|
542
|
+
}));
|
|
543
|
+
blocks.push({
|
|
544
|
+
object: 'block',
|
|
545
|
+
type: 'table_row',
|
|
546
|
+
table_row: {
|
|
547
|
+
cells: cells,
|
|
548
|
+
},
|
|
549
|
+
});
|
|
550
|
+
}
|
|
551
|
+
if (blocks.length > 0) {
|
|
552
|
+
const tableBlock = {
|
|
553
|
+
object: 'block',
|
|
554
|
+
type: 'table',
|
|
555
|
+
table: {
|
|
556
|
+
table_width: tableRows[0]?.children?.length || 1,
|
|
557
|
+
has_column_header: true,
|
|
558
|
+
has_row_header: false,
|
|
559
|
+
children: blocks,
|
|
560
|
+
},
|
|
561
|
+
};
|
|
562
|
+
return [tableBlock];
|
|
563
|
+
}
|
|
564
|
+
return blocks;
|
|
565
|
+
}
|
|
566
|
+
restoreMathPlaceholders(text, mathPlaceholders) {
|
|
567
|
+
let result = text;
|
|
568
|
+
for (const [placeholder, originalMath] of Object.entries(mathPlaceholders)) {
|
|
569
|
+
result = result.replace(placeholder, originalMath);
|
|
570
|
+
}
|
|
571
|
+
return result;
|
|
572
|
+
}
|
|
573
|
+
}
|
|
574
|
+
exports.MarkdownToNotion = MarkdownToNotion;
|
|
@@ -10,4 +10,17 @@ export declare class MarkdownToNotion implements INodeType {
|
|
|
10
10
|
private createQuoteBlock;
|
|
11
11
|
private convertToRichText;
|
|
12
12
|
private processInlineFormatting;
|
|
13
|
+
private isTodoItem;
|
|
14
|
+
private createTodoBlock;
|
|
15
|
+
private isDivider;
|
|
16
|
+
private createDividerBlock;
|
|
17
|
+
private isStandaloneUrl;
|
|
18
|
+
private createBookmarkBlock;
|
|
19
|
+
private isBlockEquation;
|
|
20
|
+
private createEquationBlock;
|
|
21
|
+
private isCallout;
|
|
22
|
+
private createCalloutBlock;
|
|
23
|
+
private createImageBlock;
|
|
24
|
+
private createTableBlocks;
|
|
25
|
+
private restoreMathPlaceholders;
|
|
13
26
|
}
|
|
@@ -184,6 +184,8 @@ class MarkdownToNotion {
|
|
|
184
184
|
return placeholder;
|
|
185
185
|
});
|
|
186
186
|
}
|
|
187
|
+
// Pre-process toggle blocks (details/summary)
|
|
188
|
+
processedMarkdown = this.preprocessToggleBlocks(processedMarkdown);
|
|
187
189
|
const processor = (0, unified_1.unified)()
|
|
188
190
|
.use(remark_parse_1.default)
|
|
189
191
|
.use(remark_gfm_1.default);
|
|
@@ -195,6 +197,27 @@ class MarkdownToNotion {
|
|
|
195
197
|
blocks.push(this.createHeadingBlock(node, mathPlaceholders));
|
|
196
198
|
break;
|
|
197
199
|
case 'paragraph': {
|
|
200
|
+
const content = (0, mdast_util_to_string_1.toString)(node).trim();
|
|
201
|
+
if (this.isDivider(content)) {
|
|
202
|
+
blocks.push(this.createDividerBlock());
|
|
203
|
+
break;
|
|
204
|
+
}
|
|
205
|
+
if (this.isStandaloneUrl(content)) {
|
|
206
|
+
blocks.push(this.createBookmarkBlock(content));
|
|
207
|
+
break;
|
|
208
|
+
}
|
|
209
|
+
if (this.isBlockEquation(content)) {
|
|
210
|
+
blocks.push(this.createEquationBlock(content));
|
|
211
|
+
break;
|
|
212
|
+
}
|
|
213
|
+
if (this.isCallout(content)) {
|
|
214
|
+
blocks.push(this.createCalloutBlock(node, mathPlaceholders));
|
|
215
|
+
break;
|
|
216
|
+
}
|
|
217
|
+
if (this.isToggleBlock(content)) {
|
|
218
|
+
blocks.push(this.createToggleBlock(content, mathPlaceholders));
|
|
219
|
+
break;
|
|
220
|
+
}
|
|
198
221
|
const paragraphBlock = this.createParagraphBlock(node, mathPlaceholders);
|
|
199
222
|
if (paragraphBlock) {
|
|
200
223
|
blocks.push(paragraphBlock);
|
|
@@ -207,8 +230,24 @@ class MarkdownToNotion {
|
|
|
207
230
|
case 'code':
|
|
208
231
|
blocks.push(this.createCodeBlock(node));
|
|
209
232
|
break;
|
|
210
|
-
case 'blockquote':
|
|
211
|
-
|
|
233
|
+
case 'blockquote': {
|
|
234
|
+
const quoteContent = (0, mdast_util_to_string_1.toString)(node).trim();
|
|
235
|
+
if (this.isCallout(quoteContent)) {
|
|
236
|
+
blocks.push(this.createCalloutBlock(node, mathPlaceholders));
|
|
237
|
+
}
|
|
238
|
+
else {
|
|
239
|
+
blocks.push(this.createQuoteBlock(node, mathPlaceholders));
|
|
240
|
+
}
|
|
241
|
+
break;
|
|
242
|
+
}
|
|
243
|
+
case 'image':
|
|
244
|
+
blocks.push(this.createImageBlock(node));
|
|
245
|
+
break;
|
|
246
|
+
case 'table':
|
|
247
|
+
blocks.push(...this.createTableBlocks(node, mathPlaceholders));
|
|
248
|
+
break;
|
|
249
|
+
case 'thematicBreak':
|
|
250
|
+
blocks.push(this.createDividerBlock());
|
|
212
251
|
break;
|
|
213
252
|
}
|
|
214
253
|
});
|
|
@@ -240,16 +279,22 @@ class MarkdownToNotion {
|
|
|
240
279
|
}
|
|
241
280
|
createListBlocks(node, mathPlaceholders) {
|
|
242
281
|
const blocks = [];
|
|
243
|
-
const listType = node.ordered ? 'numbered_list_item' : 'bulleted_list_item';
|
|
244
282
|
for (const listItem of node.children) {
|
|
245
283
|
if (listItem.type === 'listItem') {
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
284
|
+
const content = (0, mdast_util_to_string_1.toString)(listItem).trim();
|
|
285
|
+
if (this.isTodoItem(content)) {
|
|
286
|
+
blocks.push(this.createTodoBlock(listItem, mathPlaceholders));
|
|
287
|
+
}
|
|
288
|
+
else {
|
|
289
|
+
const listType = node.ordered ? 'numbered_list_item' : 'bulleted_list_item';
|
|
290
|
+
blocks.push({
|
|
291
|
+
object: 'block',
|
|
292
|
+
type: listType,
|
|
293
|
+
[listType]: {
|
|
294
|
+
rich_text: this.convertToRichText(listItem, mathPlaceholders),
|
|
295
|
+
},
|
|
296
|
+
});
|
|
297
|
+
}
|
|
253
298
|
}
|
|
254
299
|
}
|
|
255
300
|
return blocks;
|
|
@@ -371,5 +416,251 @@ class MarkdownToNotion {
|
|
|
371
416
|
}
|
|
372
417
|
}
|
|
373
418
|
}
|
|
419
|
+
isTodoItem(content) {
|
|
420
|
+
return /^- \[([ x])\]/.test(content);
|
|
421
|
+
}
|
|
422
|
+
createTodoBlock(node, mathPlaceholders) {
|
|
423
|
+
const content = (0, mdast_util_to_string_1.toString)(node).trim();
|
|
424
|
+
const isChecked = /^- \[x\]/.test(content);
|
|
425
|
+
const textContent = content.replace(/^- \[([ x])\]\s*/, '');
|
|
426
|
+
return {
|
|
427
|
+
object: 'block',
|
|
428
|
+
type: 'to_do',
|
|
429
|
+
to_do: {
|
|
430
|
+
rich_text: [{
|
|
431
|
+
type: 'text',
|
|
432
|
+
text: {
|
|
433
|
+
content: this.restoreMathPlaceholders(textContent, mathPlaceholders),
|
|
434
|
+
},
|
|
435
|
+
}],
|
|
436
|
+
checked: isChecked,
|
|
437
|
+
},
|
|
438
|
+
};
|
|
439
|
+
}
|
|
440
|
+
isDivider(content) {
|
|
441
|
+
return /^(-{3,}|\*{3,})$/.test(content);
|
|
442
|
+
}
|
|
443
|
+
createDividerBlock() {
|
|
444
|
+
return {
|
|
445
|
+
object: 'block',
|
|
446
|
+
type: 'divider',
|
|
447
|
+
divider: {},
|
|
448
|
+
};
|
|
449
|
+
}
|
|
450
|
+
isStandaloneUrl(content) {
|
|
451
|
+
const urlRegex = /^https?:\/\/[^\s]+$/;
|
|
452
|
+
return urlRegex.test(content);
|
|
453
|
+
}
|
|
454
|
+
createBookmarkBlock(url) {
|
|
455
|
+
return {
|
|
456
|
+
object: 'block',
|
|
457
|
+
type: 'bookmark',
|
|
458
|
+
bookmark: {
|
|
459
|
+
url: url,
|
|
460
|
+
caption: [],
|
|
461
|
+
},
|
|
462
|
+
};
|
|
463
|
+
}
|
|
464
|
+
isBlockEquation(content) {
|
|
465
|
+
return /^\$\$[\s\S]*\$\$$/.test(content.trim());
|
|
466
|
+
}
|
|
467
|
+
createEquationBlock(content) {
|
|
468
|
+
const equation = content.replace(/^\$\$\s*|\s*\$\$$/g, '');
|
|
469
|
+
return {
|
|
470
|
+
object: 'block',
|
|
471
|
+
type: 'equation',
|
|
472
|
+
equation: {
|
|
473
|
+
expression: equation,
|
|
474
|
+
},
|
|
475
|
+
};
|
|
476
|
+
}
|
|
477
|
+
isCallout(content) {
|
|
478
|
+
return /^>\s*\[!(note|warning|info|tip|important|caution)\]/i.test(content);
|
|
479
|
+
}
|
|
480
|
+
createCalloutBlock(node, mathPlaceholders) {
|
|
481
|
+
const content = (0, mdast_util_to_string_1.toString)(node).trim();
|
|
482
|
+
const match = content.match(/^>\s*\[!(note|warning|info|tip|important|caution)\]\s*(.*)/is);
|
|
483
|
+
if (match) {
|
|
484
|
+
const calloutType = match[1].toLowerCase();
|
|
485
|
+
const calloutContent = match[2] || '';
|
|
486
|
+
const iconMap = {
|
|
487
|
+
note: '📝',
|
|
488
|
+
warning: '⚠️',
|
|
489
|
+
info: 'ℹ️',
|
|
490
|
+
tip: '💡',
|
|
491
|
+
important: '❗',
|
|
492
|
+
caution: '⚠️',
|
|
493
|
+
};
|
|
494
|
+
return {
|
|
495
|
+
object: 'block',
|
|
496
|
+
type: 'callout',
|
|
497
|
+
callout: {
|
|
498
|
+
rich_text: [{
|
|
499
|
+
type: 'text',
|
|
500
|
+
text: {
|
|
501
|
+
content: this.restoreMathPlaceholders(calloutContent, mathPlaceholders),
|
|
502
|
+
},
|
|
503
|
+
}],
|
|
504
|
+
icon: {
|
|
505
|
+
type: 'emoji',
|
|
506
|
+
emoji: iconMap[calloutType] || '📝',
|
|
507
|
+
},
|
|
508
|
+
color: 'default',
|
|
509
|
+
},
|
|
510
|
+
};
|
|
511
|
+
}
|
|
512
|
+
return this.createQuoteBlock(node, mathPlaceholders);
|
|
513
|
+
}
|
|
514
|
+
createImageBlock(node) {
|
|
515
|
+
return {
|
|
516
|
+
object: 'block',
|
|
517
|
+
type: 'image',
|
|
518
|
+
image: {
|
|
519
|
+
type: 'external',
|
|
520
|
+
external: {
|
|
521
|
+
url: node.url,
|
|
522
|
+
},
|
|
523
|
+
caption: node.alt ? [{
|
|
524
|
+
type: 'text',
|
|
525
|
+
text: {
|
|
526
|
+
content: node.alt,
|
|
527
|
+
},
|
|
528
|
+
}] : [],
|
|
529
|
+
},
|
|
530
|
+
};
|
|
531
|
+
}
|
|
532
|
+
createTableBlocks(node, mathPlaceholders) {
|
|
533
|
+
var _a, _b;
|
|
534
|
+
const blocks = [];
|
|
535
|
+
if (!node.children || node.children.length === 0) {
|
|
536
|
+
return blocks;
|
|
537
|
+
}
|
|
538
|
+
const tableRows = node.children.filter((child) => child.type === 'tableRow');
|
|
539
|
+
for (let i = 0; i < tableRows.length; i++) {
|
|
540
|
+
const row = tableRows[i];
|
|
541
|
+
const isHeader = i === 0;
|
|
542
|
+
const cells = row.children.map((cell) => ({
|
|
543
|
+
rich_text: [{
|
|
544
|
+
type: 'text',
|
|
545
|
+
text: {
|
|
546
|
+
content: this.restoreMathPlaceholders((0, mdast_util_to_string_1.toString)(cell), mathPlaceholders),
|
|
547
|
+
},
|
|
548
|
+
annotations: isHeader ? { bold: true } : {},
|
|
549
|
+
}],
|
|
550
|
+
}));
|
|
551
|
+
blocks.push({
|
|
552
|
+
object: 'block',
|
|
553
|
+
type: 'table_row',
|
|
554
|
+
table_row: {
|
|
555
|
+
cells: cells,
|
|
556
|
+
},
|
|
557
|
+
});
|
|
558
|
+
}
|
|
559
|
+
if (blocks.length > 0) {
|
|
560
|
+
const tableBlock = {
|
|
561
|
+
object: 'block',
|
|
562
|
+
type: 'table',
|
|
563
|
+
table: {
|
|
564
|
+
table_width: ((_b = (_a = tableRows[0]) === null || _a === void 0 ? void 0 : _a.children) === null || _b === void 0 ? void 0 : _b.length) || 1,
|
|
565
|
+
has_column_header: true,
|
|
566
|
+
has_row_header: false,
|
|
567
|
+
children: blocks,
|
|
568
|
+
},
|
|
569
|
+
};
|
|
570
|
+
return [tableBlock];
|
|
571
|
+
}
|
|
572
|
+
return blocks;
|
|
573
|
+
}
|
|
574
|
+
restoreMathPlaceholders(text, mathPlaceholders) {
|
|
575
|
+
let result = text;
|
|
576
|
+
for (const [placeholder, originalMath] of Object.entries(mathPlaceholders)) {
|
|
577
|
+
result = result.replace(placeholder, originalMath);
|
|
578
|
+
}
|
|
579
|
+
return result;
|
|
580
|
+
}
|
|
581
|
+
preprocessToggleBlocks(markdown) {
|
|
582
|
+
const detailsRegex = /<details>\s*<summary>(.*?)<\/summary>\s*([\s\S]*?)<\/details>/gi;
|
|
583
|
+
return markdown.replace(detailsRegex, (match, summary, content) => {
|
|
584
|
+
const cleanSummary = summary.trim();
|
|
585
|
+
const cleanContent = content.trim();
|
|
586
|
+
return `__TOGGLE_START__${cleanSummary}__TOGGLE_CONTENT__${cleanContent}__TOGGLE_END__`;
|
|
587
|
+
});
|
|
588
|
+
}
|
|
589
|
+
isToggleBlock(content) {
|
|
590
|
+
return content.includes('__TOGGLE_START__') && content.includes('__TOGGLE_END__');
|
|
591
|
+
}
|
|
592
|
+
createToggleBlock(content, mathPlaceholders) {
|
|
593
|
+
const match = content.match(/__TOGGLE_START__(.*?)__TOGGLE_CONTENT__(.*?)__TOGGLE_END__/s);
|
|
594
|
+
if (!match) {
|
|
595
|
+
return this.createParagraphBlock({ children: [{ type: 'text', value: content }] }, mathPlaceholders) || {
|
|
596
|
+
object: 'block',
|
|
597
|
+
type: 'paragraph',
|
|
598
|
+
paragraph: { rich_text: [] }
|
|
599
|
+
};
|
|
600
|
+
}
|
|
601
|
+
const [, summary, toggleContent] = match;
|
|
602
|
+
const cleanSummary = this.restoreMathPlaceholders(summary.trim(), mathPlaceholders);
|
|
603
|
+
const cleanContent = this.restoreMathPlaceholders(toggleContent.trim(), mathPlaceholders);
|
|
604
|
+
const children = [];
|
|
605
|
+
if (cleanContent) {
|
|
606
|
+
const contentLines = cleanContent.split('\n').filter(line => line.trim());
|
|
607
|
+
for (const line of contentLines) {
|
|
608
|
+
const trimmedLine = line.trim();
|
|
609
|
+
if (trimmedLine) {
|
|
610
|
+
if (trimmedLine.startsWith('#')) {
|
|
611
|
+
const level = Math.min((trimmedLine.match(/^#+/) || [''])[0].length, 3);
|
|
612
|
+
const headingType = `heading_${level}`;
|
|
613
|
+
const headingText = trimmedLine.replace(/^#+\s*/, '');
|
|
614
|
+
children.push({
|
|
615
|
+
object: 'block',
|
|
616
|
+
type: headingType,
|
|
617
|
+
[headingType]: {
|
|
618
|
+
rich_text: [{
|
|
619
|
+
type: 'text',
|
|
620
|
+
text: { content: headingText }
|
|
621
|
+
}]
|
|
622
|
+
}
|
|
623
|
+
});
|
|
624
|
+
} else if (trimmedLine.startsWith('- ')) {
|
|
625
|
+
children.push({
|
|
626
|
+
object: 'block',
|
|
627
|
+
type: 'bulleted_list_item',
|
|
628
|
+
bulleted_list_item: {
|
|
629
|
+
rich_text: [{
|
|
630
|
+
type: 'text',
|
|
631
|
+
text: { content: trimmedLine.substring(2) }
|
|
632
|
+
}]
|
|
633
|
+
}
|
|
634
|
+
});
|
|
635
|
+
} else {
|
|
636
|
+
children.push({
|
|
637
|
+
object: 'block',
|
|
638
|
+
type: 'paragraph',
|
|
639
|
+
paragraph: {
|
|
640
|
+
rich_text: [{
|
|
641
|
+
type: 'text',
|
|
642
|
+
text: { content: trimmedLine }
|
|
643
|
+
}]
|
|
644
|
+
}
|
|
645
|
+
});
|
|
646
|
+
}
|
|
647
|
+
}
|
|
648
|
+
}
|
|
649
|
+
}
|
|
650
|
+
return {
|
|
651
|
+
object: 'block',
|
|
652
|
+
type: 'toggle',
|
|
653
|
+
toggle: {
|
|
654
|
+
rich_text: [{
|
|
655
|
+
type: 'text',
|
|
656
|
+
text: {
|
|
657
|
+
content: cleanSummary || 'Toggle'
|
|
658
|
+
}
|
|
659
|
+
}],
|
|
660
|
+
color: 'default',
|
|
661
|
+
children: children
|
|
662
|
+
}
|
|
663
|
+
};
|
|
664
|
+
}
|
|
374
665
|
}
|
|
375
666
|
exports.MarkdownToNotion = MarkdownToNotion;
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "n8n-nodes-md2notion",
|
|
3
|
-
"version": "1.
|
|
3
|
+
"version": "1.2.0",
|
|
4
4
|
"description": "Convert markdown to Notion pages with proper math formula handling - fixes common formula conversion errors in existing community nodes",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"n8n-community-node-package",
|
|
@@ -40,7 +40,7 @@
|
|
|
40
40
|
"dist",
|
|
41
41
|
"README.md",
|
|
42
42
|
"LICENSE",
|
|
43
|
-
"
|
|
43
|
+
"CHANGELOG.md"
|
|
44
44
|
],
|
|
45
45
|
"n8n": {
|
|
46
46
|
"n8nNodesApiVersion": 1,
|