writr 4.1.2 → 4.1.4

package/README.md

@@ -1,21 +1,38 @@
 ![Writr](site/logo.svg)
 
----
-
-## Markdown Rendering Simplified
+# Markdown Rendering Simplified
 [![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)
 [![npm](https://img.shields.io/npm/v/writr)](https://npmjs.com/package/writr)
 
----
-## Table of Contents
+# Table of Contents
 - [Features](#features)
+- [ESM and Node Version Support](#esm-and-node-version-support)
 - [Getting Started](#getting-started)
-- [License - MIT](#license)
-
-## Features
+- [API](#api)
+  - [`new Writr(arg?: string | WritrOptions, options?: WritrOptions)`](#new-writrarg-string--writroptions-options-writroptions)
+  - [`.content`](#content)
+  - [`.body`](#body)
+  - [`.options`](#options)
+  - [`.frontmatter`](#frontmatter)
+  - [`.frontMatterRaw`](#frontmatterraw)
+  - [`.cache`](#cache)
+  - [`.engine`](#engine)
+  - [`.render(options?: RenderOptions): Promise<string>`](#renderoptions-renderoptions-promisestring)
+  - [`.renderSync(options?: RenderOptions): string`](#rendersyncoptions-renderoptions-string)
+  - [`.renderReact(options?: RenderOptions, reactOptions?: HTMLReactParserOptions): Promise<React.JSX.Element />`](#renderreactoptions-renderoptions-reactoptions-htmlreactparseroptions-promise-reactjsxelement-)
+  - [`.renderReactSync( options?: RenderOptions, reactOptions?: HTMLReactParserOptions): React.JSX.Element`](#renderreactsync-options-renderoptions-reactoptions-htmlreactparseroptions-reactjsxelement)
+  - [`.loadFromFile(filePath: string): Promise<void>`](#loadfromfilefilepath-string-promisevoid)
+  - [`.loadFromFileSync(filePath: string): void`](#loadfromfilesyncfilepath-string-void)
+  - [`.saveToFile(filePath: string): Promise<void>`](#savetofilefilepath-string-promisevoid)
+  - [`.saveToFileSync(filePath: string): void`](#savetofilesyncfilepath-string-void)
+- [Code of Conduct and Contributing](#code-of-conduct-and-contributing)
+- [License](#license)
+
+
+# Features
 * 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:
@@ -29,11 +46,11 @@
 * Emoji Support (remark-emoji).
 * MDX Support (remark-mdx).
 
-## ESM and Node Version Support
+# ESM and Node Version Support
 
 This package is ESM only and tested on the current lts version and its previous. Please don't open issues for questions regarding CommonJS / ESM or previous Nodejs versions. To learn more about using ESM please read this from `sindresorhus`: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c
 
-## Getting Started 
+# Getting Started 
 
 ```bash
 > npm install writr
@@ -79,9 +96,9 @@ const writr = new Writr(`# Hello World ::-):\n\n This is a test.`, writrOptions)
 const html = await writr.render(options); // <h1>Hello World ::-):</h1><p>This is a test.</p>
 ```
 
-## API
+# API
 
-### `new Writr(arg?: string | WritrOptions, options?: WritrOptions)` 
+## `new Writr(arg?: string | WritrOptions, options?: 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.
 
@@ -102,7 +119,7 @@ const writrOptions = {
 const writr = new Writr(writrOptions);
 ```
 
-### `.content`
+## `.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`.
 
@@ -116,60 +133,96 @@ title: Hello World
 # Hello World ::-):\n\n This is a test.`;
 ```
 
-### `.options`
+## `.body`
+
+gets the body of the markdown content. This is the content without the frontmatter.
+
+```javascript
+import { Writr } from 'writr';
+const writr = new Writr();
+writr.content = `---
+title: Hello World
+---
+# Hello World ::-):\n\n This is a test.`;
+console.log(writr.body); // '# Hello World ::-):\n\n This is a test.'
+```
+
+## `.options`
 
 Accessing the default options for this instance of Writr.
 
-### `.cache`
+## `.frontmatter`
 
-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:
+Accessing the frontmatter for this instance of Writr. This is a `Record<string, any>` and can be set via the `.content` property.
 
 ```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>
+const writr = new Writr();
+writr.content = `---
+title: Hello World
+---
+# Hello World ::-):\n\n This is a test.`;
+console.log(writr.frontmatter); // { title: 'Hello World' }
 ```
 
-If you would like to use a specific storage adapter from https://keyv.org you can pass in the adapter like so:
+you can also set the front matter directly like this:
+
+```javascript
+import { Writr } from 'writr';
+const writr = new Writr();
+writr.frontmatter = { title: 'Hello World' };
+```
+
+## `.frontMatterRaw`
+
+Accessing the raw frontmatter for this instance of Writr. This is a `string` and can be set via the `.content` property.
+
+```javascript
+import { Writr } from 'writr';
+const writr = new Writr();
+writr.content = `---
+title: Hello World
+---
+# Hello World ::-):\n\n This is a test.`;
+console.log(writr.frontMatterRaw); // '---\ntitle: Hello World\n---'
+```
+
+## `.cache`
+
+Accessing the cache for this instance of Writr. By default this is an in memory cache and is disabled (set to false) by default. You can enable this by setting `caching: true` in the `RenderOptions` of the `WritrOptions` or when calling render passing the `RenderOptions` like here:
 
 ```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);
+const options  = {
+  caching: true
+}
+const html = await writr.render(options); // <h1>Hello World ::-):</h1><p>This is a test.</p>
 ```
 
-### `.engine`
+
+## `.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>`
+## `.render(options?: RenderOptions): Promise<string>`
 
 Rendering markdown to HTML. the options are based on RenderOptions. Which you can access from the Writr instance.
 
 ```javascript
-import { Writr, RenderOptions } from 'writr';
+import { Writr } from 'writr';
+const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
+const html = await writr.render(); // <h1>Hello World 🙂</h1><p>This is a test.</p>
 
-## `RenderOptions`
+//passing in with render options
+const options  = {
+  emoji: false
+}
 
-```js
-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)
-};
+const html = await writr.render(options); // <h1>Hello World ::-):</h1><p>This is a test.</p>
 ```
 
-### `.renderSync(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.
 
@@ -179,7 +232,7 @@ 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(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`.
 
@@ -189,7 +242,7 @@ const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
 const reactElement = await writr.renderReact(); // Will return a React.JSX.Element
 ```
 
-### '.renderReactSync( 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`.
 
@@ -199,7 +252,7 @@ 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>`
+## `.loadFromFile(filePath: string): Promise<void>`
 
 Load your markdown content from a file path.
 
@@ -209,11 +262,11 @@ const writr = new Writr();
 await writr.loadFromFile('path/to/file.md');
 ```
 
-### `.loadFromFileSync(filePath: string): void`
+## `.loadFromFileSync(filePath: string): void`
 
 Load your markdown content from a file path synchronously.
 
-### `.saveToFile(filePath: string): Promise<void>`
+## `.saveToFile(filePath: string): Promise<void>`
 
 Save your markdown and frontmatter (if included) content to a file path.
 
@@ -223,13 +276,40 @@ const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
 await writr.saveToFile('path/to/file.md');
 ```
 
-### `.saveToFileSync(filePath: string): void`
+## `.saveToFileSync(filePath: string): void`
 
 Save your markdown and frontmatter (if included) content to a file path synchronously.
 
-## Code of Conduct and Contributing
+# Caching On Render
+
+Caching is built into Writr and is an in-memory cache using `CacheableMemory` from [Cacheable](https://cacheable.org). It is turned off by default and can be enabled by setting `caching: true` 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.`, { renderOptions: { caching: true } });
+```
+
+or via `RenderOptions` such as:
+
+```javascript
+import { Writr } from 'writr';
+const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
+await writr.render({ caching: true});
+```
+
+If you want to set the caching options for the instance of Writr you can do so like this:
+
+```javascript
+// we will set the lruSize of the cache and the default ttl
+import {Writr} from 'writr';
+const writr = new Writr(`# Hello World ::-):\n\n This is a test.`, { renderOptions: { caching: true } });
+writr.cache.store.lruSize = 100;
+writr.cache.store.ttl = '5m'; // setting it to 5 minutes
+```
+
+# Code of Conduct and Contributing
 [Code of Conduct](CODE_OF_CONDUCT.md) and [Contributing](CONTRIBUTING.md) guidelines.
 
-## License
+# License
 
 MIT © [Jared Wray](https://jaredwray.com)

package/dist/writr.d.ts

@@ -3,33 +3,42 @@ import * as hast from 'hast';
 import * as mdast from 'mdast';
 import React from 'react';
 import { HTMLReactParserOptions } from 'html-react-parser';
-import { Cacheable, CacheableMemory } from 'cacheable';
-import { KeyvStoreAdapter } from 'keyv';
+import { Hookified } from 'hookified';
+import { CacheableMemory } from 'cacheable';
 
 declare class WritrCache {
-    private _markdownStore;
-    private readonly _markdownStoreSync;
+    private readonly _store;
     private readonly _hashStore;
-    get markdownStore(): Cacheable;
-    get markdownStoreSync(): CacheableMemory;
+    get store(): CacheableMemory;
     get hashStore(): CacheableMemory;
-    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;
+    get(markdown: string, options?: RenderOptions): string | undefined;
+    set(markdown: string, value: string, options?: RenderOptions): void;
+    clear(): void;
     hash(markdown: string, options?: RenderOptions): string;
 }
 
+/**
+ * Writr options.
+ * @typedef {Object} WritrOptions
+ * @property {string} [openai] - Openai api key (default: undefined)
+ * @property {RenderOptions} [renderOptions] - Default render options (default: undefined)
+ */
 type WritrOptions = {
     openai?: string;
     renderOptions?: RenderOptions;
 };
+/**
+ * Render options.
+ * @typedef {Object} RenderOptions
+ * @property {boolean} [emoji] - Emoji support (default: true)
+ * @property {boolean} [toc] - Table of contents generation (default: true)
+ * @property {boolean} [slug] - Slug generation (default: true)
+ * @property {boolean} [highlight] - Code highlighting (default: true)
+ * @property {boolean} [gfm] - Github flavor markdown (default: true)
+ * @property {boolean} [math] - Math support (default: true)
+ * @property {boolean} [mdx] - MDX support (default: true)
+ * @property {boolean} [caching] - Caching (default: true)
+ */
 type RenderOptions = {
     emoji?: boolean;
     toc?: boolean;
@@ -40,32 +49,125 @@ type RenderOptions = {
     mdx?: boolean;
     caching?: boolean;
 };
-declare class Writr {
+declare class Writr extends Hookified {
     engine: unified.Processor<mdast.Root, mdast.Root, hast.Root, hast.Root, string>;
     private readonly _options;
     private _content;
     private readonly _cache;
+    /**
+     * Initialize Writr. Accepts a string or options object.
+     * @param {string | WritrOptions} [arguments1] If you send in a string, it will be used as the markdown content. If you send in an object, it will be used as the options.
+     * @param {WritrOptions} [arguments2] This is if you send in the content in the first argument and also want to send in options.
+     *
+     * @example
+     * const writr = new Writr('Hello, world!', {caching: false});
+     */
     constructor(arguments1?: string | WritrOptions, arguments2?: WritrOptions);
+    /**
+     * Get the options.
+     * @type {WritrOptions}
+     */
     get options(): WritrOptions;
+    /**
+     * Get the Content. This is the markdown content and front matter if it exists.
+     * @type {WritrOptions}
+     */
     get content(): string;
+    /**
+     * Set the Content. This is the markdown content and front matter if it exists.
+     * @type {WritrOptions}
+     */
     set content(value: string);
+    /**
+     * Get the cache.
+     * @type {WritrCache}
+     */
     get cache(): WritrCache;
+    /**
+     * Get the front matter raw content.
+     * @type {string} The front matter content including the delimiters.
+     */
     get frontMatterRaw(): string;
+    /**
+     * Get the body content without the front matter.
+     * @type {string} The markdown content without the front matter.
+     */
     get body(): string;
+    /**
+     * Get the markdown content. This is an alias for the body property.
+     * @type {string} The markdown content.
+     */
     get markdown(): string;
+    /**
+     * Get the front matter content as an object.
+     * @type {Record<string, any>} The front matter content as an object.
+     */
     get frontMatter(): Record<string, any>;
+    /**
+     * Set the front matter content as an object.
+     * @type {Record<string, any>} The front matter content as an object.
+     */
     set frontMatter(data: Record<string, any>);
+    /**
+     * Get the front matter value for a key.
+     * @param {string} key The key to get the value for.
+     * @returns {T} The value for the key.
+     */
     getFrontMatterValue<T>(key: string): T;
+    /**
+     * Render the markdown content to HTML.
+     * @param {RenderOptions} [options] The render options.
+     * @returns {Promise<string>} The rendered HTML content.
+     */
     render(options?: RenderOptions): Promise<string>;
+    /**
+     * Render the markdown content to HTML synchronously.
+     * @param {RenderOptions} [options] The render options.
+     * @returns {string} The rendered HTML content.
+     */
     renderSync(options?: RenderOptions): string;
+    /**
+     * Render the markdown content to React.
+     * @param {RenderOptions} [options] The render options.
+     * @param {HTMLReactParserOptions} [reactParseOptions] The HTML React parser options.
+     * @returns {Promise<string | React.JSX.Element | React.JSX.Element[]>} The rendered React content.
+     */
     renderReact(options?: RenderOptions, reactParseOptions?: HTMLReactParserOptions): Promise<string | React.JSX.Element | React.JSX.Element[]>;
+    /**
+     * Render the markdown content to React synchronously.
+     * @param {RenderOptions} [options] The render options.
+     * @param {HTMLReactParserOptions} [reactParseOptions] The HTML React parser options.
+     * @returns {string | React.JSX.Element | React.JSX.Element[]} The rendered React content.
+     */
     renderReactSync(options?: RenderOptions, reactParseOptions?: HTMLReactParserOptions): string | React.JSX.Element | React.JSX.Element[];
+    /**
+     * Load markdown content from a file.
+     * @param {string} filePath The file path to load the markdown content from.
+     * @returns {Promise<void>}
+     */
     loadFromFile(filePath: string): Promise<void>;
+    /**
+     * Load markdown content from a file synchronously.
+     * @param {string} filePath The file path to load the markdown content from.
+     * @returns {void}
+     */
     loadFromFileSync(filePath: string): void;
+    /**
+     * Save the markdown content to a file. If the directory doesn't exist it will be created.
+     * @param {string} filePath The file path to save the markdown content to.
+     * @returns {Promise<void>}
+     */
     saveToFile(filePath: string): Promise<void>;
+    /**
+     * Save the markdown content to a file synchronously. If the directory doesn't exist it will be created.
+     * @param {string} filePath The file path to save the markdown content to.
+     * @returns {void}
+     */
     saveToFileSync(filePath: string): void;
     private isCacheEnabled;
     private createProcessor;
+    private mergeOptions;
+    private mergeRenderOptions;
 }
 
 export { type RenderOptions, Writr, type WritrOptions };

package/dist/writr.js

@@ -15,75 +15,46 @@ import remarkEmoji from "remark-emoji";
 import remarkMDX from "remark-mdx";
 import parse from "html-react-parser";
 import * as yaml from "js-yaml";
+import { Hookified } from "hookified";
 
 // src/writr-cache.ts
-import { createHash } from "node:crypto";
-import { Cacheable, CacheableMemory } from "cacheable";
+import { CacheableMemory } from "cacheable";
 var WritrCache = class {
-  _markdownStore = new Cacheable();
-  _markdownStoreSync = new CacheableMemory();
+  _store = new CacheableMemory();
   _hashStore = new CacheableMemory();
-  get markdownStore() {
-    return this._markdownStore;
-  }
-  get markdownStoreSync() {
-    return this._markdownStoreSync;
+  get store() {
+    return this._store;
   }
   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) {
+  get(markdown, options) {
     const key = this.hash(markdown, options);
-    return this.set(key, value);
+    return this._store.get(key);
   }
-  setMarkdownSync(markdown, value, options) {
+  set(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);
+    this._store.set(key, value);
   }
-  setSync(key, value) {
-    this._markdownStoreSync.set(key, value);
-    return true;
-  }
-  async clear() {
-    await this._markdownStore.clear();
-    this._markdownStoreSync.clear();
+  clear() {
+    this._store.clear();
     this._hashStore.clear();
   }
-  setStorageAdapter(adapter) {
-    this._markdownStore = new Cacheable({ primary: adapter });
-  }
   hash(markdown, options) {
-    const key = JSON.stringify({ markdown, options });
+    const content = { markdown, options };
+    const key = JSON.stringify(content);
     let result = this._hashStore.get(key);
     if (result) {
       return result;
     }
-    result = createHash("sha256").update(key).digest("hex");
+    result = this._hashStore.hash(content);
     this._hashStore.set(key, result);
     return result;
   }
 };
 
 // src/writr.ts
-var Writr = class {
+var Writr = class extends Hookified {
   engine = unified().use(remarkParse).use(remarkGfm).use(remarkToc).use(remarkEmoji).use(remarkRehype).use(rehypeSlug).use(remarkMath).use(rehypeKatex).use(rehypeHighlight).use(remarkMDX).use(rehypeStringify);
   // Stringify HTML
   _options = {
@@ -96,72 +67,117 @@ var Writr = class {
       gfm: true,
       math: true,
       mdx: true,
-      caching: true
+      caching: false
     }
   };
   _content = "";
   _cache = new WritrCache();
+  /**
+   * Initialize Writr. Accepts a string or options object.
+   * @param {string | WritrOptions} [arguments1] If you send in a string, it will be used as the markdown content. If you send in an object, it will be used as the options.
+   * @param {WritrOptions} [arguments2] This is if you send in the content in the first argument and also want to send in options.
+   *
+   * @example
+   * const writr = new Writr('Hello, world!', {caching: false});
+   */
   constructor(arguments1, arguments2) {
+    super();
     if (typeof arguments1 === "string") {
       this._content = arguments1;
     } else if (arguments1) {
-      this._options = { ...this._options, ...arguments1 };
+      this._options = this.mergeOptions(this._options, arguments1);
       if (this._options.renderOptions) {
         this.engine = this.createProcessor(this._options.renderOptions);
       }
     }
     if (arguments2) {
-      this._options = { ...this._options, ...arguments2 };
+      this._options = this.mergeOptions(this._options, arguments2);
       if (this._options.renderOptions) {
         this.engine = this.createProcessor(this._options.renderOptions);
       }
     }
   }
+  /**
+   * Get the options.
+   * @type {WritrOptions}
+   */
   get options() {
     return this._options;
   }
+  /**
+   * Get the Content. This is the markdown content and front matter if it exists.
+   * @type {WritrOptions}
+   */
   get content() {
     return this._content;
   }
+  /**
+   * Set the Content. This is the markdown content and front matter if it exists.
+   * @type {WritrOptions}
+   */
   set content(value) {
     this._content = value;
   }
+  /**
+   * Get the cache.
+   * @type {WritrCache}
+   */
   get cache() {
     return this._cache;
   }
+  /**
+   * Get the front matter raw content.
+   * @type {string} The front matter content including the delimiters.
+   */
   get frontMatterRaw() {
-    const start = this._content.indexOf("---\n");
-    if (start === -1) {
+    if (!this._content.trimStart().startsWith("---")) {
       return "";
     }
+    const start = this._content.indexOf("---\n");
     const end = this._content.indexOf("\n---\n", start + 4);
     if (end === -1) {
       return "";
     }
     return this._content.slice(start, end + 5);
   }
+  /**
+   * Get the body content without the front matter.
+   * @type {string} The markdown content without the front matter.
+   */
   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) {
+    if (this.frontMatterRaw === "") {
       return this._content;
     }
+    const end = this._content.indexOf("\n---\n");
     return this._content.slice(Math.max(0, end + 5)).trim();
   }
+  /**
+   * Get the markdown content. This is an alias for the body property.
+   * @type {string} The markdown content.
+   */
   get markdown() {
     return this.body;
   }
+  /**
+   * Get the front matter content as an object.
+   * @type {Record<string, any>} The front matter content as an object.
+   */
   get frontMatter() {
     const frontMatter = this.frontMatterRaw;
     const match = /^---\s*([\s\S]*?)\s*---\s*/.exec(frontMatter);
     if (match) {
-      return yaml.load(match[1].trim());
+      try {
+        return yaml.load(match[1].trim());
+      } catch (error) {
+        this.emit("error", error);
+      }
     }
     return {};
   }
+  /**
+   * Set the front matter content as an object.
+   * @type {Record<string, any>} The front matter content as an object.
+   */
   set frontMatter(data) {
     const frontMatter = this.frontMatterRaw;
     const yamlString = yaml.dump(data);
@@ -170,14 +186,24 @@ ${yamlString}---
 `;
     this._content = this._content.replace(frontMatter, newFrontMatter);
   }
+  /**
+   * Get the front matter value for a key.
+   * @param {string} key The key to get the value for.
+   * @returns {T} The value for the key.
+   */
   getFrontMatterValue(key) {
     return this.frontMatter[key];
   }
+  /**
+   * Render the markdown content to HTML.
+   * @param {RenderOptions} [options] The render options.
+   * @returns {Promise<string>} The rendered HTML content.
+   */
   async render(options) {
     try {
       let result = "";
       if (this.isCacheEnabled(options)) {
-        const cached = await this._cache.getMarkdown(this._content, options);
+        const cached = this._cache.get(this._content, options);
         if (cached) {
           return cached;
         }
@@ -190,18 +216,23 @@ ${yamlString}---
       const file = await engine.process(this.body);
       result = String(file);
       if (this.isCacheEnabled(options)) {
-        await this._cache.setMarkdown(this._content, result, options);
+        this._cache.set(this._content, result, options);
       }
       return result;
     } catch (error) {
       throw new Error(`Failed to render markdown: ${error.message}`);
     }
   }
+  /**
+   * Render the markdown content to HTML synchronously.
+   * @param {RenderOptions} [options] The render options.
+   * @returns {string} The rendered HTML content.
+   */
   renderSync(options) {
     try {
       let result = "";
       if (this.isCacheEnabled(options)) {
-        const cached = this._cache.getMarkdownSync(this._content, options);
+        const cached = this._cache.get(this._content, options);
         if (cached) {
           return cached;
         }
@@ -214,34 +245,66 @@ ${yamlString}---
       const file = engine.processSync(this.body);
       result = String(file);
       if (this.isCacheEnabled(options)) {
-        this._cache.setMarkdownSync(this._content, result, options);
+        this._cache.set(this._content, result, options);
       }
       return result;
     } catch (error) {
       throw new Error(`Failed to render markdown: ${error.message}`);
     }
   }
+  /**
+   * Render the markdown content to React.
+   * @param {RenderOptions} [options] The render options.
+   * @param {HTMLReactParserOptions} [reactParseOptions] The HTML React parser options.
+   * @returns {Promise<string | React.JSX.Element | React.JSX.Element[]>} The rendered React content.
+   */
   async renderReact(options, reactParseOptions) {
     const html = await this.render(options);
     return parse(html, reactParseOptions);
   }
+  /**
+   * Render the markdown content to React synchronously.
+   * @param {RenderOptions} [options] The render options.
+   * @param {HTMLReactParserOptions} [reactParseOptions] The HTML React parser options.
+   * @returns {string | React.JSX.Element | React.JSX.Element[]} The rendered React content.
+   */
   renderReactSync(options, reactParseOptions) {
     const html = this.renderSync(options);
     return parse(html, reactParseOptions);
   }
+  /**
+   * Load markdown content from a file.
+   * @param {string} filePath The file path to load the markdown content from.
+   * @returns {Promise<void>}
+   */
   async loadFromFile(filePath) {
     const { readFile } = fs.promises;
     this._content = await readFile(filePath, "utf8");
   }
+  /**
+   * Load markdown content from a file synchronously.
+   * @param {string} filePath The file path to load the markdown content from.
+   * @returns {void}
+   */
   loadFromFileSync(filePath) {
     this._content = fs.readFileSync(filePath, "utf8");
   }
+  /**
+   * Save the markdown content to a file. If the directory doesn't exist it will be created.
+   * @param {string} filePath The file path to save the markdown content to.
+   * @returns {Promise<void>}
+   */
   async saveToFile(filePath) {
     const { writeFile, mkdir } = fs.promises;
     const directoryPath = dirname(filePath);
     await mkdir(directoryPath, { recursive: true });
     await writeFile(filePath, this._content, "utf8");
   }
+  /**
+   * Save the markdown content to a file synchronously. If the directory doesn't exist it will be created.
+   * @param {string} filePath The file path to save the markdown content to.
+   * @returns {void}
+   */
   saveToFileSync(filePath) {
     const directoryPath = dirname(filePath);
     fs.mkdirSync(directoryPath, { recursive: true });
@@ -280,6 +343,43 @@ ${yamlString}---
     processor.use(rehypeStringify);
     return processor;
   }
+  mergeOptions(current, options) {
+    if (options.openai) {
+      current.openai = options.openai;
+    }
+    if (options.renderOptions) {
+      current.renderOptions ??= {};
+      this.mergeRenderOptions(current.renderOptions, options.renderOptions);
+    }
+    return current;
+  }
+  mergeRenderOptions(current, options) {
+    if (options.emoji !== void 0) {
+      current.emoji = options.emoji;
+    }
+    if (options.toc !== void 0) {
+      current.toc = options.toc;
+    }
+    if (options.slug !== void 0) {
+      current.slug = options.slug;
+    }
+    if (options.highlight !== void 0) {
+      current.highlight = options.highlight;
+    }
+    if (options.gfm !== void 0) {
+      current.gfm = options.gfm;
+    }
+    if (options.math !== void 0) {
+      current.math = options.math;
+    }
+    if (options.mdx !== void 0) {
+      current.mdx = options.mdx;
+    }
+    if (options.caching !== void 0) {
+      current.caching = options.caching;
+    }
+    return current;
+  }
 };
 export {
   Writr

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "writr",
-  "version": "4.1.2",
+  "version": "4.1.4",
   "description": "Markdown Rendering Simplified",
   "type": "module",
   "main": "./dist/writr.js",
@@ -53,38 +53,35 @@
     "website:serve": "rimraf ./site/README.md ./site/dist && npx docula serve -s ./site -o ./site/dist"
   },
   "dependencies": {
-    "cacheable": "^1.8.0",
-    "crypto": "^1.0.1",
-    "fs": "^0.0.1-security",
+    "cacheable": "^1.8.2",
+    "hookified": "^1.5.0",
     "html-react-parser": "^5.1.18",
     "js-yaml": "^4.1.0",
-    "keyv": "^5.1.0",
     "react": "^18.3.1",
-    "rehype-highlight": "^7.0.0",
+    "rehype-highlight": "^7.0.1",
     "rehype-katex": "^7.0.1",
     "rehype-slug": "^6.0.0",
     "rehype-stringify": "^10.0.1",
     "remark-emoji": "^5.0.1",
     "remark-gfm": "^4.0.0",
     "remark-math": "^6.0.0",
-    "remark-mdx": "^3.0.1",
+    "remark-mdx": "^3.1.0",
     "remark-parse": "^11.0.0",
     "remark-rehype": "^11.1.1",
     "remark-toc": "^9.0.0",
     "unified": "^11.0.5"
   },
   "devDependencies": {
-    "@keyv/sqlite": "^4.0.1",
     "@types/js-yaml": "^4.0.9",
-    "@types/node": "^22.7.5",
-    "@types/react": "^18.3.11",
-    "@vitest/coverage-v8": "^2.1.2",
-    "docula": "^0.9.1",
+    "@types/node": "^22.8.4",
+    "@types/react": "^18.3.12",
+    "@vitest/coverage-v8": "^2.1.4",
+    "docula": "^0.9.4",
     "rimraf": "^6.0.1",
     "ts-node": "^10.9.2",
-    "tsup": "^8.3.0",
-    "typescript": "^5.6.2",
-    "vitest": "^2.1.2",
+    "tsup": "^8.3.5",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.4",
     "webpack": "^5.95.0",
     "xo": "^0.59.3"
   },