writr 3.2.3 → 4.0.0

package/README.md

@@ -3,7 +3,7 @@
 ---
 
 ## Markdown Rendering Simplified
-[![Build](https://github.com/jaredwray/writr/actions/workflows/tests.yml/badge.svg)](https://github.com/jaredwray/writr/actions/workflows/tests.yml)
+[![tests](https://github.com/jaredwray/writr/actions/workflows/tests.yml/badge.svg)](https://github.com/jaredwray/writr/actions/workflows/tests.yml)
 [![GitHub license](https://img.shields.io/github/license/jaredwray/writr)](https://github.com/jaredwray/writr/blob/master/LICENSE)
 [![codecov](https://codecov.io/gh/jaredwray/writr/branch/master/graph/badge.svg?token=1YdMesM07X)](https://codecov.io/gh/jaredwray/writr)
 [![npm](https://img.shields.io/npm/dm/writr)](https://npmjs.com/package/writr)
@@ -16,8 +16,9 @@
 - [License - MIT](#license)
 
 ## Features
-* Takes the complexity of Remark and makes it easy to use.
-* Simpke to use and easy API
+* Removes the remark / unified complexity and easy to use.
+* Built in caching 💥 making it render very fast when there isnt a change
+* Frontmatter support built in by default. :tada:
 * Easily Render to `React` or `HTML`.
 * Generates a Table of Contents for your markdown files (remark-toc).
 * Slug generation for your markdown files (rehype-slug).
@@ -27,6 +28,7 @@
 * Github Flavor Markdown (remark-gfm).
 * Emoji Support (remark-emoji).
 * MDX Support (remark-mdx).
+* ESM and Node 20+
 
 ## Getting Started 
 
@@ -41,53 +43,30 @@
 ```javascript
 import { Writr } from 'writr';
 
-const writr = new Writr();
-const markdown = `# Hello World ::-):\n\n This is a test.`;
+const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
 
-const html = await writr.render(markdown); // <h1>Hello World 🙂</h1><p>This is a test.</p>
+const html = await writr.render(); // <h1>Hello World 🙂</h1><p>This is a test.</p>
 ```
 Its just that simple. Want to add some options? No problem.
 
 ```javascript
 import { Writr } from 'writr';
-const writr = new Writr();
-const markdown = `# Hello World ::-):\n\n This is a test.`;
+const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
 const options  = {
 	emoji: false
 }
-const html = await writr.render(markdown, options); // <h1>Hello World ::-):</h1><p>This is a test.</p>
-```
-
-Want to render to a translation? No problem.
-
-```javascript
-import { Writr } from 'writr';
-const writr = new Writr({ openai: 'your-api-key'});
-const markdown = `# Hello World ::-):\n\n This is a test.`;
-const langCode = 'es';
-const html = await writr.renderTranslation(markdown, langCode, options); // <h1>Hola Mundo 🙂</h1><p>Esta es una prueba.</p>
-```
-
-How about generating keywords and descriptions for your front matter?
-
-```javascript
-import { Writr } from 'writr';
-const writr = new Writr({ openai: 'your-api-key'});
-const markdown = `# Hello World ::-):\n\n This is a test.`;
-const keywords = await writr.keywords(markdown); // ['Hello World', 'Test']
-const description = await writr.description(markdown); // 'Hello World Test'
+const html = await writr.render(options); // <h1>Hello World ::-):</h1><p>This is a test.</p>
 ```
 
 ## API
 
-### `new Writr(options?: WritrOptions)`
+### `new Writr(arg?: string | WritrOptions, options?: WritrOptions)` 
 
-You can access the `WritrOptions` from the instance of Writr. Here is an example of WritrOptions.
+By default the constructor takes in a markdown `string` or `WritrOptions` in the first parameter. You can also send in nothing and set the markdown via `.content` property. If you want to pass in your markdown and options you can easily do this with `new Writr('## Your Markdown Here', { ...options here})`. You can access the `WritrOptions` from the instance of Writr. Here is an example of WritrOptions.
 
 ```javascript
 import { Writr, WritrOptions } from 'writr';
 const writrOptions = {
-  openai: 'your-api-key', // openai api key (default: undefined)
   renderOptions: {
     emoji: true,
     toc: true,
@@ -95,22 +74,59 @@ const writrOptions = {
     highlight: true,
     gfm: true,
     math: true,
-    mdx: true
+    mdx: true,
+    caching: true,
   }
 };
 const writr = new Writr(writrOptions);
 ```
 
-### `.engine`
+### `.content`
+
+Setting the markdown content for the instance of Writr. This can be set via the constructor or directly on the instance and can even handle `frontmatter`.
 
-Accessing the underlying engine for this instance of Writr. This is a `Processor<Root, Root, Root, undefined, undefined>` fromt the unified `.use()` function. You can use this to add additional plugins to the engine.
+```javascript
 
+import { Writr } from 'writr';
+const writr = new Writr();
+writr.content = `---
+title: Hello World
+---
+# Hello World ::-):\n\n This is a test.`;
+```
 
 ### `.options`
 
 Accessing the default options for this instance of Writr.
 
-### `.render(markdown: string, options?: RenderOptions): Promise<string>`
+### `.cache`
+
+Accessing the cache for this instance of Writr. By default this is an in memory cache and is enabled by default. You can disable this by setting `caching: false` in the `RenderOptions` of the `WritrOptions` or when calling render passing the `RenderOptions` like here:
+
+```javascript
+import { Writr } from 'writr';
+const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
+const options  = {
+  caching: false
+}
+const html = await writr.render(options); // <h1>Hello World ::-):</h1><p>This is a test.</p>
+```
+
+If you would like to use a specific storage adapter from https://keyv.org you can pass in the adapter like so:
+
+```javascript
+import { Writr } from 'writr';
+import Keyv from '@keyv/redis';
+const keyvRedis = new Keyv('redis://user:pass@localhost:6379');
+const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
+writr.cache.setStorageAdapter(keyvRedis);
+```
+
+### `.engine`
+
+Accessing the underlying engine for this instance of Writr. This is a `Processor<Root, Root, Root, undefined, undefined>` fro the unified `.use()` function. You can use this to add additional plugins to the engine.
+
+### `.render(options?: RenderOptions): Promise<string>`
 
 Rendering markdown to HTML. the options are based on RenderOptions. Which you can access from the Writr instance.
 
@@ -120,48 +136,76 @@ import { Writr, RenderOptions } from 'writr';
 ## `RenderOptions`
 
 ```js
-interface RenderOptions {
-  emoji?: boolean; // emoji support
-  toc?: boolean; // table of contents generation
-  slug?: boolean; // slug generation
-  highlight?: boolean; // code highlighting
-  gfm?: boolean; // github flavor markdown
-}
+type RenderOptions = {
+	emoji?: boolean; // Emoji support (default: true)
+	toc?: boolean; // Table of contents generation (default: true)
+	slug?: boolean; // Slug generation (default: true)
+	highlight?: boolean; // Code highlighting (default: true)
+	gfm?: boolean; // Github flavor markdown (default: true)
+	math?: boolean; // Math support (default: true)
+	mdx?: boolean; // MDX support (default: true)
+	caching?: boolean; // Caching (default: true)
+};
 ```
 
-### `.renderSync(markdown: string, options?: RenderOptions): string`
+### `.renderSync(options?: RenderOptions): string`
 
 Rendering markdown to HTML synchronously. the options are based on RenderOptions. Which you can access from the Writr instance. The parameters are the same as the `.render()` function.
 
 ```javascript
 import { Writr } from 'writr';
-const writr = new Writr();
-const markdown = `# Hello World ::-):\n\n This is a test.`;
-const html = writr.renderSync(markdown); // <h1>Hello World 🙂</h1><p>This is a test.</p>
+const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
+const html = writr.renderSync(); // <h1>Hello World 🙂</h1><p>This is a test.</p>
 ```
 
-### '.renderReact(markdown: string, options?: RenderOptions, reactOptions?: HTMLReactParserOptions): Promise<React.JSX.Element />'
+### '.renderReact(options?: RenderOptions, reactOptions?: HTMLReactParserOptions): Promise<React.JSX.Element />'
 
 Rendering markdown to React. The options are based on RenderOptions and now HTMLReactParserOptions from `html-react-parser`.
 
 ```javascript
 import { Writr } from 'writr';
-const writr = new Writr();
-const markdown = `# Hello World ::-):\n\n This is a test.`;
-const reactElement = await writr.renderReact(markdown); // Will return a React.JSX.Element
+const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
+const reactElement = await writr.renderReact(); // Will return a React.JSX.Element
 ```
 
-### '.renderReactSync(markdown: string, options?: RenderOptions, reactOptions?: HTMLReactParserOptions): React.JSX.Element'
+### '.renderReactSync( options?: RenderOptions, reactOptions?: HTMLReactParserOptions): React.JSX.Element'
 
 Rendering markdown to React. The options are based on RenderOptions and now HTMLReactParserOptions from `html-react-parser`.
 
+```javascript
+import { Writr } from 'writr';
+const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
+const reactElement = writr.renderReactSync(); // Will return a React.JSX.Element
+```
+
+### `.loadFromFile(filePath: string): Promise<void>`
+
+Load your markdown content from a file path.
+
 ```javascript
 import { Writr } from 'writr';
 const writr = new Writr();
-const markdown = `# Hello World ::-):\n\n This is a test.`;
-const reactElement = writr.renderReactSync(markdown); // Will return a React.JSX.Element
+await writr.loadFromFile('path/to/file.md');
 ```
 
+### `.loadFromFileSync(filePath: string): void`
+
+Load your markdown content from a file path synchronously.
+
+### `.saveToFile(filePath: string): Promise<void>`
+
+Save your markdown and frontmatter (if included) content to a file path.
+
+```javascript
+import { Writr } from 'writr';
+const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
+await writr.saveToFile('path/to/file.md');
+```
+
+### `.saveToFileSync(filePath: string): void`
+
+Save your markdown and frontmatter (if included) content to a file path synchronously.
+
 ## Code of Conduct and Contributing
 [Code of Conduct](CODE_OF_CONDUCT.md) and [Contributing](CONTRIBUTING.md) guidelines.
 

package/dist/writr-cache.d.ts

@@ -0,0 +1,22 @@
+import { Keyv, type KeyvStoreAdapter } from 'keyv';
+import { type RenderOptions } from './writr.js';
+export declare class WritrCache {
+    private _markdownStore;
+    private _markdownStoreSync;
+    private _hashStore;
+    constructor();
+    get markdownStore(): Keyv;
+    get markdownStoreSync(): Map<string, string>;
+    get hashStore(): Map<string, string>;
+    getMarkdown(markdown: string, options?: RenderOptions): Promise<string | undefined>;
+    getMarkdownSync(markdown: string, options?: RenderOptions): string | undefined;
+    setMarkdown(markdown: string, value: string, options?: RenderOptions): Promise<boolean>;
+    setMarkdownSync(markdown: string, value: string, options?: RenderOptions): boolean;
+    get(key: string): Promise<string | undefined>;
+    getSync(key: string): string | undefined;
+    set(key: string, value: string): Promise<boolean>;
+    setSync(key: string, value: string): boolean;
+    clear(): Promise<void>;
+    setStorageAdapter(adapter: KeyvStoreAdapter): void;
+    hash(markdown: string, options?: RenderOptions): string;
+}

package/dist/writr-cache.js

@@ -0,0 +1,70 @@
+import { createHash } from 'node:crypto';
+import { Keyv } from 'keyv';
+export class WritrCache {
+    _markdownStore;
+    _markdownStoreSync;
+    _hashStore;
+    constructor() {
+        this._markdownStore = new Keyv();
+        this._markdownStoreSync = new Map();
+        this._hashStore = new Map();
+    }
+    get markdownStore() {
+        return this._markdownStore;
+    }
+    get markdownStoreSync() {
+        return this._markdownStoreSync;
+    }
+    get hashStore() {
+        return this._hashStore;
+    }
+    async getMarkdown(markdown, options) {
+        const key = this.hash(markdown, options);
+        return this.get(key);
+    }
+    getMarkdownSync(markdown, options) {
+        const key = this.hash(markdown, options);
+        return this.getSync(key);
+    }
+    async setMarkdown(markdown, value, options) {
+        const key = this.hash(markdown, options);
+        return this.set(key, value);
+    }
+    setMarkdownSync(markdown, value, options) {
+        const key = this.hash(markdown, options);
+        this.setSync(key, value);
+        return true;
+    }
+    async get(key) {
+        return this._markdownStore.get(key);
+    }
+    getSync(key) {
+        return this._markdownStoreSync.get(key);
+    }
+    async set(key, value) {
+        return this._markdownStore.set(key, value);
+    }
+    setSync(key, value) {
+        this._markdownStoreSync.set(key, value);
+        return true;
+    }
+    async clear() {
+        await this._markdownStore.clear();
+        this._markdownStoreSync = new Map();
+        this._hashStore = new Map();
+    }
+    setStorageAdapter(adapter) {
+        this._markdownStore = new Keyv({ store: adapter });
+    }
+    hash(markdown, options) {
+        const key = JSON.stringify({ markdown, options });
+        let result = this._hashStore.get(key);
+        if (result) {
+            return result;
+        }
+        result = createHash('sha256').update(key).digest('hex');
+        this._hashStore.set(key, result);
+        return result;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/writr.d.ts

@@ -1,6 +1,6 @@
-import { Processor } from 'unified';
 import type React from 'react';
 import { type HTMLReactParserOptions } from 'html-react-parser';
+import { WritrCache } from './writr-cache.js';
 type WritrOptions = {
     openai?: string;
     renderOptions?: RenderOptions;
@@ -13,16 +13,33 @@ type RenderOptions = {
     gfm?: boolean;
     math?: boolean;
     mdx?: boolean;
+    caching?: boolean;
 };
 declare class Writr {
-    engine: Processor<import("mdast").Root, import("mdast").Root, import("hast").Root, import("hast").Root, string>;
+    engine: import("unified").Processor<import("mdast").Root, import("mdast").Root, import("hast").Root, import("hast").Root, string>;
     private readonly _options;
-    constructor(options?: WritrOptions);
+    private _content;
+    private readonly _cache;
+    constructor(arguments1?: string | WritrOptions, arguments2?: WritrOptions);
     get options(): WritrOptions;
-    render(markdown: string, options?: RenderOptions): Promise<string>;
-    renderSync(markdown: string, options?: RenderOptions): string;
-    renderReact(markdown: string, options?: RenderOptions, reactParseOptions?: HTMLReactParserOptions): Promise<string | React.JSX.Element | React.JSX.Element[]>;
-    renderReactSync(markdown: string, options?: RenderOptions, reactParseOptions?: HTMLReactParserOptions): string | React.JSX.Element | React.JSX.Element[];
+    get content(): string;
+    set content(value: string);
+    get cache(): WritrCache;
+    get frontMatterRaw(): string;
+    get body(): string;
+    get markdown(): string;
+    get frontMatter(): Record<string, any>;
+    set frontMatter(data: Record<string, any>);
+    getFrontMatterValue<T>(key: string): T;
+    render(options?: RenderOptions): Promise<string>;
+    renderSync(options?: RenderOptions): string;
+    renderReact(options?: RenderOptions, reactParseOptions?: HTMLReactParserOptions): Promise<string | React.JSX.Element | React.JSX.Element[]>;
+    renderReactSync(options?: RenderOptions, reactParseOptions?: HTMLReactParserOptions): string | React.JSX.Element | React.JSX.Element[];
+    loadFromFile(filePath: string): Promise<void>;
+    loadFromFileSync(filePath: string): void;
+    saveToFile(filePath: string): Promise<void>;
+    saveToFileSync(filePath: string): void;
+    private isCacheEnabled;
     private createProcessor;
 }
 export { Writr, type WritrOptions, type RenderOptions };

package/dist/writr.js

@@ -1,3 +1,5 @@
+import fs from 'node:fs';
+import { dirname } from 'node:path';
 import { unified } from 'unified';
 import remarkParse from 'remark-parse';
 import remarkRehype from 'remark-rehype';
@@ -11,6 +13,8 @@ import remarkGfm from 'remark-gfm';
 import remarkEmoji from 'remark-emoji';
 import remarkMDX from 'remark-mdx';
 import parse from 'html-react-parser';
+import * as yaml from 'js-yaml';
+import { WritrCache } from './writr-cache.js';
 class Writr {
     engine = unified()
         .use(remarkParse)
@@ -34,11 +38,24 @@ class Writr {
             gfm: true,
             math: true,
             mdx: true,
+            caching: true,
         },
     };
-    constructor(options) {
-        if (options) {
-            this._options = { ...this._options, ...options };
+    _content = '';
+    _cache = new WritrCache();
+    constructor(arguments1, arguments2) {
+        if (typeof arguments1 === 'string') {
+            this._content = arguments1;
+        }
+        else if (arguments1) {
+            this._options = { ...this._options, ...arguments1 };
+            if (this._options.renderOptions) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                this.engine = this.createProcessor(this._options.renderOptions);
+            }
+        }
+        if (arguments2) {
+            this._options = { ...this._options, ...arguments2 };
             if (this._options.renderOptions) {
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 this.engine = this.createProcessor(this._options.renderOptions);
@@ -48,44 +65,142 @@ class Writr {
     get options() {
         return this._options;
     }
-    async render(markdown, options) {
+    get content() {
+        return this._content;
+    }
+    set content(value) {
+        this._content = value;
+    }
+    get cache() {
+        return this._cache;
+    }
+    get frontMatterRaw() {
+        const start = this._content.indexOf('---\n');
+        if (start === -1) {
+            return '';
+        } // Return empty string if no starting delimiter is found
+        const end = this._content.indexOf('\n---\n', start + 4);
+        if (end === -1) {
+            return '';
+        } // Return empty string if no ending delimiter is found
+        return this._content.slice(start, end + 5); // Extract front matter including delimiters
+    }
+    get body() {
+        const start = this._content.indexOf('---\n');
+        if (start === -1) {
+            return this._content;
+        }
+        const end = this._content.indexOf('\n---\n', start + 4);
+        if (end === -1) {
+            return this._content;
+        }
+        // Return the content after the closing --- marker
+        return this._content.slice(Math.max(0, end + 5)).trim();
+    }
+    get markdown() {
+        return this.body;
+    }
+    get frontMatter() {
+        const frontMatter = this.frontMatterRaw;
+        const match = /^---\s*([\s\S]*?)\s*---\s*/.exec(frontMatter);
+        if (match) {
+            return yaml.load(match[1].trim());
+        }
+        return {};
+    }
+    set frontMatter(data) {
+        const frontMatter = this.frontMatterRaw;
+        const yamlString = yaml.dump(data);
+        const newFrontMatter = `---\n${yamlString}---\n`;
+        this._content = this._content.replace(frontMatter, newFrontMatter);
+    }
+    getFrontMatterValue(key) {
+        return this.frontMatter[key];
+    }
+    async render(options) {
         try {
+            let result = '';
+            if (this.isCacheEnabled(options)) {
+                const cached = await this._cache.getMarkdown(this._content, options);
+                if (cached) {
+                    return cached;
+                }
+            }
             let { engine } = this;
             if (options) {
                 options = { ...this._options.renderOptions, ...options };
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 engine = this.createProcessor(options);
             }
-            const file = await engine.process(markdown);
-            return String(file);
+            const file = await engine.process(this.body);
+            result = String(file);
+            if (this.isCacheEnabled(options)) {
+                await this._cache.setMarkdown(this._content, result, options);
+            }
+            return result;
         }
         catch (error) {
             throw new Error(`Failed to render markdown: ${error.message}`);
         }
     }
-    renderSync(markdown, options) {
+    renderSync(options) {
         try {
+            let result = '';
+            if (this.isCacheEnabled(options)) {
+                const cached = this._cache.getMarkdownSync(this._content, options);
+                if (cached) {
+                    return cached;
+                }
+            }
             let { engine } = this;
             if (options) {
                 options = { ...this._options.renderOptions, ...options };
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 engine = this.createProcessor(options);
             }
-            const file = engine.processSync(markdown);
-            return String(file);
+            const file = engine.processSync(this.body);
+            result = String(file);
+            if (this.isCacheEnabled(options)) {
+                this._cache.setMarkdownSync(this._content, result, options);
+            }
+            return result;
         }
         catch (error) {
             throw new Error(`Failed to render markdown: ${error.message}`);
         }
     }
-    async renderReact(markdown, options, reactParseOptions) {
-        const html = await this.render(markdown, options);
+    async renderReact(options, reactParseOptions) {
+        const html = await this.render(options);
         return parse(html, reactParseOptions);
     }
-    renderReactSync(markdown, options, reactParseOptions) {
-        const html = this.renderSync(markdown, options);
+    renderReactSync(options, reactParseOptions) {
+        const html = this.renderSync(options);
         return parse(html, reactParseOptions);
     }
+    async loadFromFile(filePath) {
+        const { readFile } = fs.promises;
+        this._content = await readFile(filePath, 'utf8');
+    }
+    loadFromFileSync(filePath) {
+        this._content = fs.readFileSync(filePath, 'utf8');
+    }
+    async saveToFile(filePath) {
+        const { writeFile, mkdir } = fs.promises;
+        const directoryPath = dirname(filePath);
+        await mkdir(directoryPath, { recursive: true });
+        await writeFile(filePath, this._content, 'utf8');
+    }
+    saveToFileSync(filePath) {
+        const directoryPath = dirname(filePath);
+        fs.mkdirSync(directoryPath, { recursive: true });
+        fs.writeFileSync(filePath, this._content, 'utf8');
+    }
+    isCacheEnabled(options) {
+        if (options?.caching !== undefined) {
+            return options.caching;
+        }
+        return this._options?.renderOptions?.caching ?? false;
+    }
     createProcessor(options) {
         const processor = unified().use(remarkParse);
         if (options.gfm) {
@@ -115,4 +230,4 @@ class Writr {
     }
 }
 export { Writr };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"writr.js","sourceRoot":"","sources":["../src/writr.ts"],"names":[],"mappings":"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","sourcesContent":["import {unified, Processor} from 'unified';\nimport remarkParse from 'remark-parse';\nimport remarkRehype from 'remark-rehype';\nimport rehypeSlug from 'rehype-slug';\nimport rehypeHighlight from 'rehype-highlight';\nimport rehypeStringify from 'rehype-stringify';\nimport remarkToc from 'remark-toc';\nimport remarkMath from 'remark-math';\nimport rehypeKatex from 'rehype-katex';\nimport remarkGfm from 'remark-gfm';\nimport remarkEmoji from 'remark-emoji';\nimport remarkMDX from 'remark-mdx';\nimport type React from 'react';\nimport parse, {type HTMLReactParserOptions} from 'html-react-parser';\n\ntype WritrOptions = {\n\topenai?: string; // Openai api key (default: undefined)\n\trenderOptions?: RenderOptions; // Default render options (default: undefined)\n};\n\ntype RenderOptions = {\n\temoji?: boolean; // Emoji support (default: true)\n\ttoc?: boolean; // Table of contents generation (default: true)\n\tslug?: boolean; // Slug generation (default: true)\n\thighlight?: boolean; // Code highlighting (default: true)\n\tgfm?: boolean; // Github flavor markdown (default: true)\n\tmath?: boolean; // Math support (default: true)\n\tmdx?: boolean; // MDX support (default: true)\n};\n\nclass Writr {\n\tpublic engine = unified()\n\t\t.use(remarkParse)\n\t\t.use(remarkGfm) // Use GitHub Flavored Markdown\n\t\t.use(remarkToc) // Add table of contents\n\t\t.use(remarkEmoji) // Add emoji support\n\t\t.use(remarkRehype) // Convert markdown to HTML\n\t\t.use(rehypeSlug) // Add slugs to headings in HTML\n\t\t.use(remarkMath) // Add math support\n\t\t.use(rehypeKatex) // Add math support\n\t\t.use(rehypeHighlight) // Apply syntax highlighting\n\t\t.use(remarkMDX) // Add MDX support\n\t\t.use(rehypeStringify); // Stringify HTML\n\n\tprivate readonly _options: WritrOptions = {\n\t\topenai: undefined,\n\t\trenderOptions: {\n\t\t\temoji: true,\n\t\t\ttoc: true,\n\t\t\tslug: true,\n\t\t\thighlight: true,\n\t\t\tgfm: true,\n\t\t\tmath: true,\n\t\t\tmdx: true,\n\t\t},\n\t};\n\n\tconstructor(options?: WritrOptions) {\n\t\tif (options) {\n\t\t\tthis._options = {...this._options, ...options};\n\t\t\tif (this._options.renderOptions) {\n\t\t\t\t// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n\t\t\t\tthis.engine = this.createProcessor(this._options.renderOptions);\n\t\t\t}\n\t\t}\n\t}\n\n\tpublic get options(): WritrOptions {\n\t\treturn this._options;\n\t}\n\n\tasync render(markdown: string, options?: RenderOptions): Promise<string> {\n\t\ttry {\n\t\t\tlet {engine} = this;\n\t\t\tif (options) {\n\t\t\t\toptions = {...this._options.renderOptions, ...options};\n\t\t\t\t// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n\t\t\t\tengine = this.createProcessor(options);\n\t\t\t}\n\n\t\t\tconst file = await engine.process(markdown);\n\t\t\treturn String(file);\n\t\t} catch (error) {\n\t\t\tthrow new Error(`Failed to render markdown: ${(error as Error).message}`);\n\t\t}\n\t}\n\n\trenderSync(markdown: string, options?: RenderOptions): string {\n\t\ttry {\n\t\t\tlet {engine} = this;\n\t\t\tif (options) {\n\t\t\t\toptions = {...this._options.renderOptions, ...options};\n\t\t\t\t// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n\t\t\t\tengine = this.createProcessor(options);\n\t\t\t}\n\n\t\t\tconst file = engine.processSync(markdown);\n\t\t\treturn String(file);\n\t\t} catch (error) {\n\t\t\tthrow new Error(`Failed to render markdown: ${(error as Error).message}`);\n\t\t}\n\t}\n\n\tasync renderReact(markdown: string, options?: RenderOptions, reactParseOptions?: HTMLReactParserOptions): Promise<string | React.JSX.Element | React.JSX.Element[]> {\n\t\tconst html = await this.render(markdown, options);\n\n\t\treturn parse(html, reactParseOptions);\n\t}\n\n\trenderReactSync(markdown: string, options?: RenderOptions, reactParseOptions?: HTMLReactParserOptions): string | React.JSX.Element | React.JSX.Element[] {\n\t\tconst html = this.renderSync(markdown, options);\n\t\treturn parse(html, reactParseOptions);\n\t}\n\n\tprivate createProcessor(options: RenderOptions): any {\n\t\tconst processor = unified().use(remarkParse);\n\n\t\tif (options.gfm) {\n\t\t\tprocessor.use(remarkGfm);\n\t\t}\n\n\t\tif (options.toc) {\n\t\t\tprocessor.use(remarkToc, {heading: 'toc|table of contents'});\n\t\t}\n\n\t\tif (options.emoji) {\n\t\t\tprocessor.use(remarkEmoji);\n\t\t}\n\n\t\tprocessor.use(remarkRehype);\n\n\t\tif (options.slug) {\n\t\t\tprocessor.use(rehypeSlug);\n\t\t}\n\n\t\tif (options.highlight) {\n\t\t\tprocessor.use(rehypeHighlight);\n\t\t}\n\n\t\tif (options.math) {\n\t\t\tprocessor.use(remarkMath).use(rehypeKatex);\n\t\t}\n\n\t\tif (options.mdx) {\n\t\t\tprocessor.use(remarkMDX);\n\t\t}\n\n\t\tprocessor.use(rehypeStringify);\n\n\t\treturn processor;\n\t}\n}\n\nexport {Writr, type WritrOptions, type RenderOptions};\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"writr.js","sourceRoot":"","sources":["../src/writr.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from 'node:fs';\nimport {dirname} from 'node:path';\nimport {unified} from 'unified';\nimport remarkParse from 'remark-parse';\nimport remarkRehype from 'remark-rehype';\nimport rehypeSlug from 'rehype-slug';\nimport rehypeHighlight from 'rehype-highlight';\nimport rehypeStringify from 'rehype-stringify';\nimport remarkToc from 'remark-toc';\nimport remarkMath from 'remark-math';\nimport rehypeKatex from 'rehype-katex';\nimport remarkGfm from 'remark-gfm';\nimport remarkEmoji from 'remark-emoji';\nimport remarkMDX from 'remark-mdx';\nimport type React from 'react';\nimport parse, {type HTMLReactParserOptions} from 'html-react-parser';\nimport * as yaml from 'js-yaml';\nimport {WritrCache} from './writr-cache.js';\n\ntype WritrOptions = {\n\topenai?: string; // Openai api key (default: undefined)\n\trenderOptions?: RenderOptions; // Default render options (default: undefined)\n};\n\ntype RenderOptions = {\n\temoji?: boolean; // Emoji support (default: true)\n\ttoc?: boolean; // Table of contents generation (default: true)\n\tslug?: boolean; // Slug generation (default: true)\n\thighlight?: boolean; // Code highlighting (default: true)\n\tgfm?: boolean; // Github flavor markdown (default: true)\n\tmath?: boolean; // Math support (default: true)\n\tmdx?: boolean; // MDX support (default: true)\n\tcaching?: boolean; // Caching (default: true)\n};\n\nclass Writr {\n\tpublic engine = unified()\n\t\t.use(remarkParse)\n\t\t.use(remarkGfm) // Use GitHub Flavored Markdown\n\t\t.use(remarkToc) // Add table of contents\n\t\t.use(remarkEmoji) // Add emoji support\n\t\t.use(remarkRehype) // Convert markdown to HTML\n\t\t.use(rehypeSlug) // Add slugs to headings in HTML\n\t\t.use(remarkMath) // Add math support\n\t\t.use(rehypeKatex) // Add math support\n\t\t.use(rehypeHighlight) // Apply syntax highlighting\n\t\t.use(remarkMDX) // Add MDX support\n\t\t.use(rehypeStringify); // Stringify HTML\n\n\tprivate readonly _options: WritrOptions = {\n\t\topenai: undefined,\n\t\trenderOptions: {\n\t\t\temoji: true,\n\t\t\ttoc: true,\n\t\t\tslug: true,\n\t\t\thighlight: true,\n\t\t\tgfm: true,\n\t\t\tmath: true,\n\t\t\tmdx: true,\n\t\t\tcaching: true,\n\t\t},\n\t};\n\n\tprivate _content = '';\n\n\tprivate readonly _cache = new WritrCache();\n\n\tconstructor(arguments1?: string | WritrOptions, arguments2?: WritrOptions) {\n\t\tif (typeof arguments1 === 'string') {\n\t\t\tthis._content = arguments1;\n\t\t} else if (arguments1) {\n\t\t\tthis._options = {...this._options, ...arguments1};\n\t\t\tif (this._options.renderOptions) {\n\t\t\t\t// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n\t\t\t\tthis.engine = this.createProcessor(this._options.renderOptions);\n\t\t\t}\n\t\t}\n\n\t\tif (arguments2) {\n\t\t\tthis._options = {...this._options, ...arguments2};\n\t\t\tif (this._options.renderOptions) {\n\t\t\t\t// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n\t\t\t\tthis.engine = this.createProcessor(this._options.renderOptions);\n\t\t\t}\n\t\t}\n\t}\n\n\tpublic get options(): WritrOptions {\n\t\treturn this._options;\n\t}\n\n\tpublic get content(): string {\n\t\treturn this._content;\n\t}\n\n\tpublic set content(value: string) {\n\t\tthis._content = value;\n\t}\n\n\tpublic get cache(): WritrCache {\n\t\treturn this._cache;\n\t}\n\n\tget frontMatterRaw(): string {\n\t\tconst start = this._content.indexOf('---\\n');\n\t\tif (start === -1) {\n\t\t\treturn '';\n\t\t} // Return empty string if no starting delimiter is found\n\n\t\tconst end = this._content.indexOf('\\n---\\n', start + 4);\n\t\tif (end === -1) {\n\t\t\treturn '';\n\t\t} // Return empty string if no ending delimiter is found\n\n\t\treturn this._content.slice(start, end + 5); // Extract front matter including delimiters\n\t}\n\n\tget body(): string {\n\t\tconst start = this._content.indexOf('---\\n');\n\t\tif (start === -1) {\n\t\t\treturn this._content;\n\t\t}\n\n\t\tconst end = this._content.indexOf('\\n---\\n', start + 4);\n\t\tif (end === -1) {\n\t\t\treturn this._content;\n\t\t}\n\n\t\t// Return the content after the closing --- marker\n\t\treturn this._content.slice(Math.max(0, end + 5)).trim();\n\t}\n\n\tget markdown(): string {\n\t\treturn this.body;\n\t}\n\n\tget frontMatter(): Record<string, any> {\n\t\tconst frontMatter = this.frontMatterRaw;\n\t\tconst match = /^---\\s*([\\s\\S]*?)\\s*---\\s*/.exec(frontMatter);\n\t\tif (match) {\n\t\t\treturn yaml.load(match[1].trim()) as Record<string, any>;\n\t\t}\n\n\t\treturn {};\n\t}\n\n\tset frontMatter(data: Record<string, any>) {\n\t\tconst frontMatter = this.frontMatterRaw;\n\t\tconst yamlString = yaml.dump(data);\n\t\tconst newFrontMatter = `---\\n${yamlString}---\\n`;\n\t\tthis._content = this._content.replace(frontMatter, newFrontMatter);\n\t}\n\n\tpublic getFrontMatterValue<T>(key: string): T {\n\t\treturn this.frontMatter[key] as T;\n\t}\n\n\tasync render(options?: RenderOptions): Promise<string> {\n\t\ttry {\n\t\t\tlet result = '';\n\t\t\tif (this.isCacheEnabled(options)) {\n\t\t\t\tconst cached = await this._cache.getMarkdown(this._content, options);\n\t\t\t\tif (cached) {\n\t\t\t\t\treturn cached;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tlet {engine} = this;\n\t\t\tif (options) {\n\t\t\t\toptions = {...this._options.renderOptions, ...options};\n\t\t\t\t// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n\t\t\t\tengine = this.createProcessor(options);\n\t\t\t}\n\n\t\t\tconst file = await engine.process(this.body);\n\t\t\tresult = String(file);\n\t\t\tif (this.isCacheEnabled(options)) {\n\t\t\t\tawait this._cache.setMarkdown(this._content, result, options);\n\t\t\t}\n\n\t\t\treturn result;\n\t\t} catch (error) {\n\t\t\tthrow new Error(`Failed to render markdown: ${(error as Error).message}`);\n\t\t}\n\t}\n\n\trenderSync(options?: RenderOptions): string {\n\t\ttry {\n\t\t\tlet result = '';\n\t\t\tif (this.isCacheEnabled(options)) {\n\t\t\t\tconst cached = this._cache.getMarkdownSync(this._content, options);\n\t\t\t\tif (cached) {\n\t\t\t\t\treturn cached;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tlet {engine} = this;\n\t\t\tif (options) {\n\t\t\t\toptions = {...this._options.renderOptions, ...options};\n\t\t\t\t// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n\t\t\t\tengine = this.createProcessor(options);\n\t\t\t}\n\n\t\t\tconst file = engine.processSync(this.body);\n\t\t\tresult = String(file);\n\t\t\tif (this.isCacheEnabled(options)) {\n\t\t\t\tthis._cache.setMarkdownSync(this._content, result, options);\n\t\t\t}\n\n\t\t\treturn result;\n\t\t} catch (error) {\n\t\t\tthrow new Error(`Failed to render markdown: ${(error as Error).message}`);\n\t\t}\n\t}\n\n\tasync renderReact(options?: RenderOptions, reactParseOptions?: HTMLReactParserOptions): Promise<string | React.JSX.Element | React.JSX.Element[]> {\n\t\tconst html = await this.render(options);\n\n\t\treturn parse(html, reactParseOptions);\n\t}\n\n\trenderReactSync(options?: RenderOptions, reactParseOptions?: HTMLReactParserOptions): string | React.JSX.Element | React.JSX.Element[] {\n\t\tconst html = this.renderSync(options);\n\t\treturn parse(html, reactParseOptions);\n\t}\n\n\tasync loadFromFile(filePath: string): Promise<void> {\n\t\tconst {readFile} = fs.promises;\n\t\tthis._content = await readFile(filePath, 'utf8');\n\t}\n\n\tloadFromFileSync(filePath: string): void {\n\t\tthis._content = fs.readFileSync(filePath, 'utf8');\n\t}\n\n\tasync saveToFile(filePath: string): Promise<void> {\n\t\tconst {writeFile, mkdir} = fs.promises;\n\t\tconst directoryPath = dirname(filePath);\n\t\tawait mkdir(directoryPath, {recursive: true});\n\t\tawait writeFile(filePath, this._content, 'utf8');\n\t}\n\n\tsaveToFileSync(filePath: string): void {\n\t\tconst directoryPath = dirname(filePath);\n\t\tfs.mkdirSync(directoryPath, {recursive: true});\n\t\tfs.writeFileSync(filePath, this._content, 'utf8');\n\t}\n\n\tprivate isCacheEnabled(options?: RenderOptions): boolean {\n\t\tif (options?.caching !== undefined) {\n\t\t\treturn options.caching;\n\t\t}\n\n\t\treturn this._options?.renderOptions?.caching ?? false;\n\t}\n\n\tprivate createProcessor(options: RenderOptions): any {\n\t\tconst processor = unified().use(remarkParse);\n\n\t\tif (options.gfm) {\n\t\t\tprocessor.use(remarkGfm);\n\t\t}\n\n\t\tif (options.toc) {\n\t\t\tprocessor.use(remarkToc, {heading: 'toc|table of contents'});\n\t\t}\n\n\t\tif (options.emoji) {\n\t\t\tprocessor.use(remarkEmoji);\n\t\t}\n\n\t\tprocessor.use(remarkRehype);\n\n\t\tif (options.slug) {\n\t\t\tprocessor.use(rehypeSlug);\n\t\t}\n\n\t\tif (options.highlight) {\n\t\t\tprocessor.use(rehypeHighlight);\n\t\t}\n\n\t\tif (options.math) {\n\t\t\tprocessor.use(remarkMath).use(rehypeKatex);\n\t\t}\n\n\t\tif (options.mdx) {\n\t\t\tprocessor.use(remarkMDX);\n\t\t}\n\n\t\tprocessor.use(rehypeStringify);\n\n\t\treturn processor;\n\t}\n}\n\nexport {Writr, type WritrOptions, type RenderOptions};\n\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "writr",
-  "version": "3.2.3",
+  "version": "4.0.0",
   "description": "Markdown Rendering Simplified",
   "type": "module",
   "exports": "./dist/writr.js",
@@ -8,7 +8,7 @@
   "repository": "https://github.com/jaredwray/writr.git",
   "author": "Jared Wray <me@jaredwray.com>",
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20"
   },
   "license": "MIT",
   "keywords": [
@@ -40,40 +40,46 @@
     "markdown-to-react"
   ],
   "scripts": {
-    "clean": "rimraf ./dist ./coverage ./node_modules ./package-lock.json ./yarn.lock ./site/README.md ./site-output",
+    "clean": "rimraf ./dist ./coverage ./node_modules ./package-lock.json ./yarn.lock ./site/README.md ./site/dist",
     "build": "rimraf ./dist && tsc",
     "test": "xo --fix && vitest run --coverage",
     "prepare": "npm run build",
-    "website:build": "rimraf ./site/README.md ./site-output && npx docula build -s ./site -o ./site-output",
-    "website:serve": "rimraf ./site/README.md ./site-output && npx docula serve -s ./site -o ./site-output"
+    "website:build": "rimraf ./site/README.md ./site/dist && npx docula build -s ./site -o ./site/dist",
+    "website:serve": "rimraf ./site/README.md ./site/dist && npx docula serve -s ./site -o ./site/dist"
   },
   "dependencies": {
-    "html-react-parser": "^5.1.10",
+    "crypto": "^1.0.1",
+    "fs": "^0.0.1-security",
+    "html-react-parser": "^5.1.15",
+    "js-yaml": "^4.1.0",
+    "keyv": "^5.0.1",
     "react": "^18.3.1",
     "rehype-highlight": "^7.0.0",
-    "rehype-katex": "^7.0.0",
+    "rehype-katex": "^7.0.1",
     "rehype-slug": "^6.0.0",
     "rehype-stringify": "^10.0.0",
-    "remark-emoji": "^4.0.1",
+    "remark-emoji": "^5.0.1",
     "remark-gfm": "^4.0.0",
     "remark-math": "^6.0.0",
     "remark-mdx": "^3.0.1",
     "remark-parse": "^11.0.0",
     "remark-rehype": "^11.1.0",
     "remark-toc": "^9.0.0",
-    "ts-node": "^10.9.2",
-    "unified": "^11.0.4"
+    "unified": "^11.0.5"
   },
   "devDependencies": {
-    "@types/node": "^20.12.11",
-    "@types/react": "^18.3.2",
-    "@vitest/coverage-v8": "^1.6.0",
-    "docula": "^0.5.3",
-    "rimraf": "^5.0.7",
-    "typescript": "^5.4.5",
-    "vitest": "^1.6.0",
-    "webpack": "^5.91.0",
-    "xo": "^0.58.0"
+    "@keyv/sqlite": "^4.0.1",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^22.5.1",
+    "@types/react": "^18.3.5",
+    "@vitest/coverage-v8": "^2.0.5",
+    "docula": "^0.9.0",
+    "rimraf": "^6.0.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.5.4",
+    "vitest": "^2.0.5",
+    "webpack": "^5.94.0",
+    "xo": "^0.59.3"
   },
   "xo": {
     "ignores": [
@@ -81,6 +87,8 @@
     ]
   },
   "files": [
-    "dist"
+    "dist",
+    "README.md",
+    "LICENSE"
   ]
 }