docula 0.3.6 → 0.4.0

package/README.md

@@ -1,51 +1,120 @@
-<img src="branding-guidelines/Docula Logos/PNG/Color/docula.png" />
+![Docula](site/logo.svg)
 
-# Docula
+---
 
+## Beautiful Website for Your Projects
 [![tests](https://github.com/jaredwray/docula/actions/workflows/tests.yaml/badge.svg)](https://github.com/jaredwray/docula/actions/workflows/tests.yaml)
-[![codecov](https://codecov.io/github/jaredwray/docula/branch/main/graph/badge.svg?token=RS0GPY4V4M)](https://codecov.io/github/jaredwray/docula)
-[![release](https://github.com/jaredwray/docula/actions/workflows/release.yaml/badge.svg)](https://github.com/jaredwray/docula/actions/workflows/release.yaml)
-[![npm](https://img.shields.io/npm/dm/docula.svg)](https://www.npmjs.com/package/docula)
-[![npm](https://img.shields.io/npm/v/docula.svg)](https://www.npmjs.com/package/docula)
+[![GitHub license](https://img.shields.io/github/license/jaredwray/docula)](https://github.com/jaredwray/docula/blob/master/LICENSE)
+[![codecov](https://codecov.io/gh/jaredwray/docula/graph/badge.svg?token=RS0GPY4V4M)](https://codecov.io/gh/jaredwray/docula)
+[![npm](https://img.shields.io/npm/dm/docula)](https://npmjs.com/package/docula)
+[![npm](https://img.shields.io/npm/v/docula)](https://npmjs.com/package/docula)
+
+---
+## Table of Contents
+- [Features](#features)
+- [Getting Started](#getting-started)
+- [Using Your own Template](#using-your-own-template)
+- [Building Multiple Pages](#building-multiple-pages)
+- [Helper Functions for Markdown](#helper-functions-for-markdown)
+- [Code of Conduct and Contributing](#code-of-conduct-and-contributing)
+- [License - MIT](#license)
 
 ## Features
+* No configuration requrired. Just setup the folder structure with a logo, favicon, and css file. 
+* Builds a static website that can be hosted anywhere.
+* For more complex projects easily add a `docula.config.js` or `docula.config.ts` file to customize the build process. With PRE and POST methods. 
+* Support for single page with readme or multiple markdown pages in a docs folder.
+* Will generate a sitemap.xml and robots.txt for your site.
+* Uses Github release notes to generate a changelog / releases page.
+* Uses Github to show contributors and link to their profiles.
+* Simple search is provided by default out of the box. 
+
+## Getting Started 
+
+## 1. Install docula
+
+> npx docula init
 
-- Zero Config - no config needed
-- Can run from `npx` or installed globally
-- Knowledge Base that is easy to setup and manage
-- Beautiful and Responsive Design
-- Search Engine Optimized and Plugin (Algolia) and local search by default.
-- Convention over Configuration - just add your files, use a template (or build your own) and you're done.
-- Will generate a sitemap.xml
-- Will generate a robots.txt
-- Will generate a release based on Github Releases
-- Generatses an RSS feed.xml file to use and share 
-
-## Site Structure
-
-- `site/docs` - contains the documentation files
-- `site/template` - contains the templates files
-
-This will all be generated in the `dist` folder by default. To change that you can use the `--output=<folder_name>` flag.
-
-### Github Integration
-- Pull all of your Contributors and Display Them
-- Pulls your release notes and puts it into a good looking data format for your templates
-- Pulls your project stats based on Github Forks, Stars, and Watchers
-## How the CLI should work
-To create a new project it should be as simple as:
-```bash
-docula init <project-name>
+This will create a folder called site with the following structure:
+
+```
+site
+├───site.css
+├───logo.png
+├───favicon.ico
+├───README.md
+├───docula.config.js
 ```
+Note: for typescript do 'docula init --typescript'
+
+## 2. Add your content
+
+Simply replace the logo, favicon, and css file with your own. The readme is your root project readme and you just need to at build time move it over to the site folder. If you have it at the root of the project and this is a folder inside just delete the  README.md file in the site folder and docula will copy it over for you automatically.
+
+## 3. Build your site
+
+> npx docula
+
+This will build your site and place it in the `dist` folder. You can then host it anywhere you like.
+
+## Using Your own Template
+
+If you want to use your own template you can do so by adding a `docula.config.ts` file to the root of your project. This file will be used to configure the build process.
+
+or at the command line:
+
+> npx docula --template path/to/template
 
-This will actually do all the scaffolding for the site setting up the package.json, the config file, and the templates. It will also install the default template.
+## Building Multiple Pages
 
-To build the site just do:
-```bash
-docula <path optional>
+If you want to build multiple pages you can easily do that by adding in a `docs` folder to the root of the site folder. Inside of that folder you can add as many pages as you like. Each page will be a markdown file and it will generate a table of contents for you. Here is an example of what it looks like:
+
+```
+site
+├───site.css
+├───logo.png
+├───favicon.ico
+├───docula.config.ts
+├───docs
+│   ├───getting-started.md
+│   ├───contributing.md
+│   ├───license.md
+│   ├───code-of-conduct.md
 ```
 
-To build the site and watch for changes:
-```bash
-docula <path optional> --serve --watch --port=8081
+The `readme.md` file will be the root page and the rest will be added to the table of contents. If you want to control the title or order of the pages you can do so by setting the `title` and `order` properties in the front matter of the markdown file. Here is an example:
+
+```md
+---
+title: Getting Started
+order: 2
+---
+```
+
+## Helper Functions for Markdown
+
+docula comes with some helper functions that you can use in your markdown files.
+* `doculaHelpers.getFrontMatter(fileName)` - Gets the front matter of a markdown file.
+* `doculaHelpers.setFrontMatter(fileName, frontMatter)` - Sets the front matter of a markdown file.
+* `doculaHelpers.createDoc(source, destination, frontMatter?, contentFn[]?)` - Creates a markdown file with the specified front matter and content. The contentFn is a function that is executed on the original content of the file. This is useful if you want to remove content from the original file.
+
+### Remove html content
+
+In some cases your markdown file will have html content in it such as the logo of your project or a badge. You can use the `wrtirHelpers.removeHtmlContent()` helper function to remove that content from the page. Here is an example:
+
+### Get and Set the Front Matter of a Markdown File
+
+You can use the `doculaHelpers.getFrontMatter()` and `doculaHelpers.setFrontMatter()` helper functions to get and set the front matter of a markdown file. Here is an example:
+
+```js
+const frontMatter = doculaHelpers.getFrontMatter('../readme.md');
+frontMatter.title = 'My Title';
+doculaHelpers.setFrontMatter('../readme.md', frontMatter);
 ```
+
+## Code of Conduct and Contributing
+[Code of Conduct](CODE_OF_CONDUCT.md) and [Contributing](CONTRIBUTING.md) guidelines.
+
+## License
+
+MIT © [Jared Wray](https://jaredwray.com)

package/bin/docula.mjs

@@ -0,0 +1,8 @@
+#!/usr/bin/env ts-node
+
+import * as process from 'node:process';
+import Docula from '../dist/docula.js';
+
+const docula = new Docula();
+
+await docula.execute(process);

package/dist/builder.d.ts

@@ -0,0 +1,34 @@
+import { DoculaOptions } from './options.js';
+import { type GithubData } from './github.js';
+export type DoculaData = {
+    siteUrl: string;
+    siteTitle: string;
+    siteDescription: string;
+    sitePath: string;
+    templatePath: string;
+    outputPath: string;
+    githubPath?: string;
+    github?: GithubData;
+    templates?: DoculaTemplates;
+};
+export type DoculaTemplates = {
+    index: string;
+    releases: string;
+};
+export declare class DoculaBuilder {
+    private readonly _options;
+    private readonly _ecto;
+    private readonly _console;
+    constructor(options?: DoculaOptions, engineOptions?: any);
+    get options(): DoculaOptions;
+    build(): Promise<void>;
+    validateOptions(options: DoculaOptions): void;
+    getGithubData(githubPath: string): Promise<GithubData>;
+    getTemplates(options: DoculaOptions): Promise<DoculaTemplates>;
+    getTemplateFile(path: string, name: string): Promise<string | undefined>;
+    buildRobotsPage(options: DoculaOptions): Promise<void>;
+    buildSiteMapPage(data: DoculaData): Promise<void>;
+    buildIndexPage(data: DoculaData): Promise<void>;
+    buildReleasePage(data: DoculaData): Promise<void>;
+    buildReadmeSection(data: DoculaData): Promise<string>;
+}

package/dist/builder.js

@@ -0,0 +1,182 @@
+import { Ecto } from 'ecto';
+import fs from 'fs-extra';
+import { DoculaOptions } from './options.js';
+import { DoculaConsole } from './console.js';
+import { Github } from './github.js';
+export class DoculaBuilder {
+    _options = new DoculaOptions();
+    _ecto;
+    _console = new DoculaConsole();
+    constructor(options, engineOptions) {
+        if (options) {
+            this._options = options;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        this._ecto = new Ecto(engineOptions);
+    }
+    get options() {
+        return this._options;
+    }
+    async build() {
+        const startTime = Date.now();
+        // Validate the options
+        this.validateOptions(this.options);
+        // Set the site options
+        const doculaData = {
+            siteUrl: this.options.siteUrl,
+            siteTitle: this.options.siteTitle,
+            siteDescription: this.options.siteDescription,
+            sitePath: this.options.sitePath,
+            templatePath: this.options.templatePath,
+            outputPath: this.options.outputPath,
+            githubPath: this.options.githubPath,
+        };
+        // Get data from github
+        const githubData = await this.getGithubData(this.options.githubPath);
+        // Get data of the site
+        doculaData.github = githubData;
+        // Get the templates to use
+        doculaData.templates = await this.getTemplates(this.options);
+        // Build the home page (index.html)
+        await this.buildIndexPage(doculaData);
+        // Build the releases page (/releases/index.html)
+        await this.buildReleasePage(doculaData);
+        // Build the sitemap (/sitemap.xml)
+        await this.buildSiteMapPage(doculaData);
+        // Build the robots.txt (/robots.txt)
+        await this.buildRobotsPage(this.options);
+        const siteRelativePath = this.options.sitePath;
+        // Copy over favicon
+        if (await fs.pathExists(`${siteRelativePath}/favicon.ico`)) {
+            await fs.copy(`${siteRelativePath}/favicon.ico`, `${this.options.outputPath}/favicon.ico`);
+        }
+        // Copy over logo
+        if (await fs.pathExists(`${siteRelativePath}/logo.svg`)) {
+            await fs.copy(`${siteRelativePath}/logo.svg`, `${this.options.outputPath}/logo.svg`);
+        }
+        // Copy over css
+        if (await fs.pathExists(`${this.options.templatePath}/css`)) {
+            await fs.copy(`${this.options.templatePath}/css`, `${this.options.outputPath}/css`);
+        }
+        // Copy over variables
+        if (await fs.pathExists(`${siteRelativePath}/variables.css`)) {
+            await fs.copy(`${siteRelativePath}/variables.css`, `${this.options.outputPath}/css/variables.css`);
+        }
+        const endTime = Date.now();
+        const executionTime = endTime - startTime;
+        this._console.log(`Build completed in ${executionTime}ms`);
+    }
+    validateOptions(options) {
+        if (options.githubPath.length < 3) {
+            throw new Error('No github options provided');
+        }
+        if (options.siteDescription.length < 3) {
+            throw new Error('No site description options provided');
+        }
+        if (!options.siteTitle) {
+            throw new Error('No site title options provided');
+        }
+        if (!options.siteUrl) {
+            throw new Error('No site url options provided');
+        }
+    }
+    async getGithubData(githubPath) {
+        const paths = githubPath.split('/');
+        const options = {
+            author: paths[0],
+            repo: paths[1],
+        };
+        const github = new Github(options);
+        return github.getData();
+    }
+    async getTemplates(options) {
+        const templates = {
+            index: '',
+            releases: '',
+        };
+        if (await fs.pathExists(options.templatePath)) {
+            const index = await this.getTemplateFile(options.templatePath, 'index');
+            if (index) {
+                templates.index = index;
+            }
+            const releases = await this.getTemplateFile(options.templatePath, 'releases');
+            if (releases) {
+                templates.releases = releases;
+            }
+        }
+        else {
+            throw new Error(`No template path found at ${options.templatePath}`);
+        }
+        return templates;
+    }
+    async getTemplateFile(path, name) {
+        let result;
+        const files = await fs.readdir(path);
+        for (const file of files) {
+            const fileName = file.split('.');
+            if (fileName[0].toString().toLowerCase() === name.toLowerCase()) {
+                result = file.toString();
+                break;
+            }
+        }
+        return result;
+    }
+    async buildRobotsPage(options) {
+        const { sitePath } = options;
+        const { outputPath } = options;
+        const robotsPath = `${outputPath}/robots.txt`;
+        await fs.ensureDir(outputPath);
+        await ((await fs.pathExists(`${sitePath}/robots.txt`))
+            ? fs.copy(`${sitePath}/robots.txt`, robotsPath)
+            : fs.writeFile(robotsPath, 'User-agent: *\nDisallow:'));
+    }
+    async buildSiteMapPage(data) {
+        const sitemapPath = `${data.outputPath}/sitemap.xml`;
+        const urls = [{ url: data.siteUrl }, { url: `${data.siteUrl}/releases` }];
+        let xml = '<?xml version="1.0" encoding="UTF-8"?>';
+        xml += '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">';
+        for (const { url } of urls) {
+            xml += '<url>';
+            xml += `<loc>${url}</loc>`;
+            xml += '</url>';
+        }
+        xml += '</urlset>';
+        await fs.ensureDir(data.outputPath);
+        await fs.writeFile(sitemapPath, xml, 'utf8');
+    }
+    async buildIndexPage(data) {
+        if (data.templates) {
+            const indexPath = `${data.outputPath}/index.html`;
+            await fs.ensureDir(data.outputPath);
+            const indexTemplate = `${data.templatePath}/${data.templates.index}`;
+            const htmlReadme = await this.buildReadmeSection(data);
+            const indexContent = await this._ecto.renderFromFile(indexTemplate, { ...data, content: htmlReadme }, data.templatePath);
+            await fs.writeFile(indexPath, indexContent, 'utf8');
+        }
+        else {
+            throw new Error('No templates found');
+        }
+    }
+    async buildReleasePage(data) {
+        if (data.github && data.templates) {
+            const releasesPath = `${data.outputPath}/releases/index.html`;
+            const releaseOutputPath = `${data.outputPath}/releases`;
+            await fs.ensureDir(releaseOutputPath);
+            const releasesTemplate = `${data.templatePath}/${data.templates.releases}`;
+            const releasesContent = await this._ecto.renderFromFile(releasesTemplate, data, data.templatePath);
+            await fs.writeFile(releasesPath, releasesContent, 'utf8');
+        }
+        else {
+            throw new Error('No github data found');
+        }
+    }
+    async buildReadmeSection(data) {
+        let htmlReadme = '';
+        if (fs.existsSync(`${data.sitePath}/README.md`)) {
+            const readmeContent = fs.readFileSync(`${data.sitePath}/README.md`, 'utf8');
+            htmlReadme = await this._ecto.markdown.render(readmeContent);
+        }
+        return htmlReadme;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"builder.js","sourceRoot":"","sources":["../src/builder.ts"],"names":[],"mappings":"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","sourcesContent":["import {Ecto} from 'ecto';\nimport fs from 'fs-extra';\nimport {DoculaOptions} from './options.js';\nimport {DoculaConsole} from './console.js';\nimport {Github, type GithubData, type GithubOptions} from './github.js';\n\nexport type DoculaData = {\n\tsiteUrl: string;\n\tsiteTitle: string;\n\tsiteDescription: string;\n\tsitePath: string;\n\ttemplatePath: string;\n\toutputPath: string;\n\tgithubPath?: string;\n\tgithub?: GithubData;\n\ttemplates?: DoculaTemplates;\n};\n\nexport type DoculaTemplates = {\n\tindex: string;\n\treleases: string;\n};\n\nexport class DoculaBuilder {\n\tprivate readonly _options: DoculaOptions = new DoculaOptions();\n\tprivate readonly _ecto: Ecto;\n\tprivate readonly _console: DoculaConsole = new DoculaConsole();\n\n\tconstructor(options?: DoculaOptions, engineOptions?: any) {\n\t\tif (options) {\n\t\t\tthis._options = options;\n\t\t}\n\n\t\t// eslint-disable-next-line @typescript-eslint/no-unsafe-argument\n\t\tthis._ecto = new Ecto(engineOptions);\n\t}\n\n\tpublic get options(): DoculaOptions {\n\t\treturn this._options;\n\t}\n\n\tpublic async build(): Promise<void> {\n\t\tconst startTime = Date.now();\n\n\t\t// Validate the options\n\t\tthis.validateOptions(this.options);\n\t\t// Set the site options\n\t\tconst doculaData: DoculaData = {\n\t\t\tsiteUrl: this.options.siteUrl,\n\t\t\tsiteTitle: this.options.siteTitle,\n\t\t\tsiteDescription: this.options.siteDescription,\n\t\t\tsitePath: this.options.sitePath,\n\t\t\ttemplatePath: this.options.templatePath,\n\t\t\toutputPath: this.options.outputPath,\n\t\t\tgithubPath: this.options.githubPath,\n\t\t};\n\n\t\t// Get data from github\n\t\tconst githubData = await this.getGithubData(this.options.githubPath);\n\t\t// Get data of the site\n\t\tdoculaData.github = githubData;\n\t\t// Get the templates to use\n\t\tdoculaData.templates = await this.getTemplates(this.options);\n\n\t\t// Build the home page (index.html)\n\t\tawait this.buildIndexPage(doculaData);\n\n\t\t// Build the releases page (/releases/index.html)\n\t\tawait this.buildReleasePage(doculaData);\n\n\t\t// Build the sitemap (/sitemap.xml)\n\t\tawait this.buildSiteMapPage(doculaData);\n\n\t\t// Build the robots.txt (/robots.txt)\n\t\tawait this.buildRobotsPage(this.options);\n\n\t\tconst siteRelativePath = this.options.sitePath;\n\n\t\t// Copy over favicon\n\t\tif (await fs.pathExists(`${siteRelativePath}/favicon.ico`)) {\n\t\t\tawait fs.copy(\n\t\t\t\t`${siteRelativePath}/favicon.ico`,\n\t\t\t\t`${this.options.outputPath}/favicon.ico`,\n\t\t\t);\n\t\t}\n\n\t\t// Copy over logo\n\t\tif (await fs.pathExists(`${siteRelativePath}/logo.svg`)) {\n\t\t\tawait fs.copy(\n\t\t\t\t`${siteRelativePath}/logo.svg`,\n\t\t\t\t`${this.options.outputPath}/logo.svg`,\n\t\t\t);\n\t\t}\n\n\t\t// Copy over css\n\t\tif (await fs.pathExists(`${this.options.templatePath}/css`)) {\n\t\t\tawait fs.copy(\n\t\t\t\t`${this.options.templatePath}/css`,\n\t\t\t\t`${this.options.outputPath}/css`,\n\t\t\t);\n\t\t}\n\n\t\t// Copy over variables\n\t\tif (await fs.pathExists(`${siteRelativePath}/variables.css`)) {\n\t\t\tawait fs.copy(\n\t\t\t\t`${siteRelativePath}/variables.css`,\n\t\t\t\t`${this.options.outputPath}/css/variables.css`,\n\t\t\t);\n\t\t}\n\n\t\tconst endTime = Date.now();\n\n\t\tconst executionTime = endTime - startTime;\n\n\t\tthis._console.log(`Build completed in ${executionTime}ms`);\n\t}\n\n\tpublic validateOptions(options: DoculaOptions): void {\n\t\tif (options.githubPath.length < 3) {\n\t\t\tthrow new Error('No github options provided');\n\t\t}\n\n\t\tif (options.siteDescription.length < 3) {\n\t\t\tthrow new Error('No site description options provided');\n\t\t}\n\n\t\tif (!options.siteTitle) {\n\t\t\tthrow new Error('No site title options provided');\n\t\t}\n\n\t\tif (!options.siteUrl) {\n\t\t\tthrow new Error('No site url options provided');\n\t\t}\n\t}\n\n\tpublic async getGithubData(githubPath: string): Promise<GithubData> {\n\t\tconst paths = githubPath.split('/');\n\t\tconst options: GithubOptions = {\n\t\t\tauthor: paths[0],\n\t\t\trepo: paths[1],\n\t\t};\n\t\tconst github = new Github(options);\n\t\treturn github.getData();\n\t}\n\n\tpublic async getTemplates(options: DoculaOptions): Promise<DoculaTemplates> {\n\t\tconst templates: DoculaTemplates = {\n\t\t\tindex: '',\n\t\t\treleases: '',\n\t\t};\n\n\t\tif (await fs.pathExists(options.templatePath)) {\n\t\t\tconst index = await this.getTemplateFile(options.templatePath, 'index');\n\t\t\tif (index) {\n\t\t\t\ttemplates.index = index;\n\t\t\t}\n\n\t\t\tconst releases = await this.getTemplateFile(\n\t\t\t\toptions.templatePath,\n\t\t\t\t'releases',\n\t\t\t);\n\t\t\tif (releases) {\n\t\t\t\ttemplates.releases = releases;\n\t\t\t}\n\t\t} else {\n\t\t\tthrow new Error(`No template path found at ${options.templatePath}`);\n\t\t}\n\n\t\treturn templates;\n\t}\n\n\tpublic async getTemplateFile(\n\t\tpath: string,\n\t\tname: string,\n\t): Promise<string | undefined> {\n\t\tlet result;\n\t\tconst files = await fs.readdir(path);\n\t\tfor (const file of files) {\n\t\t\tconst fileName = file.split('.');\n\t\t\tif (fileName[0].toString().toLowerCase() === name.toLowerCase()) {\n\t\t\t\tresult = file.toString();\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\treturn result;\n\t}\n\n\tpublic async buildRobotsPage(options: DoculaOptions): Promise<void> {\n\t\tconst {sitePath} = options;\n\t\tconst {outputPath} = options;\n\t\tconst robotsPath = `${outputPath}/robots.txt`;\n\n\t\tawait fs.ensureDir(outputPath);\n\n\t\tawait ((await fs.pathExists(`${sitePath}/robots.txt`))\n\t\t\t? fs.copy(`${sitePath}/robots.txt`, robotsPath)\n\t\t\t: fs.writeFile(robotsPath, 'User-agent: *\\nDisallow:'));\n\t}\n\n\tpublic async buildSiteMapPage(data: DoculaData): Promise<void> {\n\t\tconst sitemapPath = `${data.outputPath}/sitemap.xml`;\n\t\tconst urls = [{url: data.siteUrl}, {url: `${data.siteUrl}/releases`}];\n\n\t\tlet xml = '<?xml version=\"1.0\" encoding=\"UTF-8\"?>';\n\t\txml += '<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">';\n\n\t\tfor (const {url} of urls) {\n\t\t\txml += '<url>';\n\t\t\txml += `<loc>${url}</loc>`;\n\t\t\txml += '</url>';\n\t\t}\n\n\t\txml += '</urlset>';\n\n\t\tawait fs.ensureDir(data.outputPath);\n\n\t\tawait fs.writeFile(sitemapPath, xml, 'utf8');\n\t}\n\n\tpublic async buildIndexPage(data: DoculaData): Promise<void> {\n\t\tif (data.templates) {\n\t\t\tconst indexPath = `${data.outputPath}/index.html`;\n\n\t\t\tawait fs.ensureDir(data.outputPath);\n\n\t\t\tconst indexTemplate = `${data.templatePath}/${data.templates.index}`;\n\n\t\t\tconst htmlReadme = await this.buildReadmeSection(data);\n\n\t\t\tconst indexContent = await this._ecto.renderFromFile(\n\t\t\t\tindexTemplate,\n\t\t\t\t{...data, content: htmlReadme},\n\t\t\t\tdata.templatePath,\n\t\t\t);\n\t\t\tawait fs.writeFile(indexPath, indexContent, 'utf8');\n\t\t} else {\n\t\t\tthrow new Error('No templates found');\n\t\t}\n\t}\n\n\tpublic async buildReleasePage(data: DoculaData): Promise<void> {\n\t\tif (data.github && data.templates) {\n\t\t\tconst releasesPath = `${data.outputPath}/releases/index.html`;\n\t\t\tconst releaseOutputPath = `${data.outputPath}/releases`;\n\n\t\t\tawait fs.ensureDir(releaseOutputPath);\n\n\t\t\tconst releasesTemplate = `${data.templatePath}/${data.templates.releases}`;\n\t\t\tconst releasesContent = await this._ecto.renderFromFile(\n\t\t\t\treleasesTemplate,\n\t\t\t\tdata,\n\t\t\t\tdata.templatePath,\n\t\t\t);\n\t\t\tawait fs.writeFile(releasesPath, releasesContent, 'utf8');\n\t\t} else {\n\t\t\tthrow new Error('No github data found');\n\t\t}\n\t}\n\n\tpublic async buildReadmeSection(data: DoculaData): Promise<string> {\n\t\tlet htmlReadme = '';\n\t\tif (fs.existsSync(`${data.sitePath}/README.md`)) {\n\t\t\tconst readmeContent = fs.readFileSync(\n\t\t\t\t`${data.sitePath}/README.md`,\n\t\t\t\t'utf8',\n\t\t\t);\n\t\t\thtmlReadme = await this._ecto.markdown.render(readmeContent);\n\t\t}\n\n\t\treturn htmlReadme;\n\t}\n}\n"]}

package/dist/console.d.ts

@@ -0,0 +1,22 @@
+export declare class DoculaConsole {
+    log(message: string): void;
+    error(message: string): void;
+    warn(message: string): void;
+    printHelp(): void;
+    parseProcessArgv(argv: string[]): DoculaConsoleProcess;
+    getCommand(argv: string[]): string | undefined;
+    getArguments(argv: string[]): DoculaConsoleArguments;
+}
+type DoculaConsoleProcess = {
+    argv: string[];
+    command: string | undefined;
+    args: DoculaConsoleArguments;
+};
+type DoculaConsoleArguments = {
+    sitePath: string | undefined;
+    templatePath: string | undefined;
+    output: string | undefined;
+    watch: boolean;
+    port: number;
+};
+export {};

package/dist/console.js

@@ -0,0 +1,120 @@
+import path from 'node:path';
+import process from 'node:process';
+export class DoculaConsole {
+    log(message) {
+        console.log(message);
+    }
+    error(message) {
+        console.error(message);
+    }
+    warn(message) {
+        console.warn(message);
+    }
+    printHelp() {
+        console.log('   Usage: docula [command] [arguments]');
+        console.log();
+        console.log('   Commands:');
+        console.log('     init           Initialize a new project');
+        console.log('     build          Build the project. By default just npx docula will build the project if it finds a ./site folder');
+        console.log('     serve          Serve the project as a local website');
+        console.log('     help           Print this help');
+        console.log('     version        Print the version');
+        console.log();
+        console.log('   Arguments Build:');
+        console.log('     -w, --watch            watch for changes and rebuild');
+        console.log('     -s, --site             Set the path where site files are located');
+        console.log('     -o, --outputPath       Set the output directory. Default is ./site/dist');
+        console.log('     -t, --templatePath     Set the custom template to use');
+        console.log();
+        console.log('   Arguments serve:');
+        console.log('     -p, --port         Set the port number used with serve');
+        console.log('     -w, --watch        watch for changes and rebuild');
+        console.log('     -s, --site         Set the path where site files are located');
+    }
+    parseProcessArgv(argv) {
+        const command = this.getCommand(argv);
+        const args = this.getArguments(argv);
+        return {
+            argv,
+            command,
+            args,
+        };
+    }
+    getCommand(argv) {
+        let result;
+        for (const arg of argv) {
+            // eslint-disable-next-line default-case
+            switch (arg) {
+                case 'init': {
+                    result = 'init';
+                    break;
+                }
+                case 'build': {
+                    result = 'build';
+                    break;
+                }
+                case 'serve': {
+                    result = 'serve';
+                    break;
+                }
+                case 'help': {
+                    result = 'help';
+                    break;
+                }
+                case 'version': {
+                    result = arg;
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+    getArguments(argv) {
+        const args = {
+            sitePath: '',
+            templatePath: '',
+            output: '',
+            watch: false,
+            port: 3000,
+        };
+        for (let i = 0; i < argv.length; i++) {
+            const arg = argv[i];
+            // eslint-disable-next-line default-case
+            switch (arg) {
+                case '-p':
+                case '--port': {
+                    const portString = argv[i + 1];
+                    if (portString !== undefined) {
+                        args.port = Number.parseInt(portString, 10);
+                    }
+                    break;
+                }
+                case '-o':
+                case '--output': {
+                    args.output = argv[i + 1];
+                    args.output = path.join(process.cwd(), args.output);
+                    break;
+                }
+                case '-w':
+                case '--watch': {
+                    args.watch = true;
+                    break;
+                }
+                case '-s':
+                case '--site': {
+                    args.sitePath = argv[i + 1];
+                    args.sitePath = path.join(process.cwd(), args.sitePath);
+                    break;
+                }
+                case '-t':
+                case '--templatePath': {
+                    args.templatePath = argv[i + 1];
+                    args.templatePath = path.join(process.cwd(), args.templatePath);
+                    break;
+                }
+            }
+        }
+        return args;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"console.js","sourceRoot":"","sources":["../src/console.ts"],"names":[],"mappings":"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","sourcesContent":["import path from 'node:path';\nimport process from 'node:process';\n\nexport class DoculaConsole {\n\tlog(message: string): void {\n\t\tconsole.log(message);\n\t}\n\n\terror(message: string): void {\n\t\tconsole.error(message);\n\t}\n\n\twarn(message: string): void {\n\t\tconsole.warn(message);\n\t}\n\n\tprintHelp(): void {\n\t\tconsole.log('   Usage: docula [command] [arguments]');\n\t\tconsole.log();\n\t\tconsole.log('   Commands:');\n\t\tconsole.log('     init           Initialize a new project');\n\t\tconsole.log('     build          Build the project. By default just npx docula will build the project if it finds a ./site folder');\n\t\tconsole.log('     serve          Serve the project as a local website');\n\t\tconsole.log('     help           Print this help');\n\t\tconsole.log('     version        Print the version');\n\t\tconsole.log();\n\t\tconsole.log('   Arguments Build:');\n\t\tconsole.log('     -w, --watch            watch for changes and rebuild');\n\t\tconsole.log('     -s, --site             Set the path where site files are located');\n\t\tconsole.log('     -o, --outputPath       Set the output directory. Default is ./site/dist');\n\t\tconsole.log('     -t, --templatePath     Set the custom template to use');\n\t\tconsole.log();\n\t\tconsole.log('   Arguments serve:');\n\t\tconsole.log('     -p, --port         Set the port number used with serve');\n\t\tconsole.log('     -w, --watch        watch for changes and rebuild');\n\t\tconsole.log('     -s, --site         Set the path where site files are located');\n\t}\n\n\tpublic parseProcessArgv(argv: string[]): DoculaConsoleProcess {\n\t\tconst command = this.getCommand(argv);\n\t\tconst args = this.getArguments(argv);\n\t\treturn {\n\t\t\targv,\n\t\t\tcommand,\n\t\t\targs,\n\t\t};\n\t}\n\n\tpublic getCommand(argv: string[]): string | undefined {\n\t\tlet result;\n\t\tfor (const arg of argv) {\n\t\t\t// eslint-disable-next-line default-case\n\t\t\tswitch (arg) {\n\t\t\t\tcase 'init': {\n\t\t\t\t\tresult = 'init';\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tcase 'build': {\n\t\t\t\t\tresult = 'build';\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tcase 'serve': {\n\t\t\t\t\tresult = 'serve';\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tcase 'help': {\n\t\t\t\t\tresult = 'help';\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tcase 'version': {\n\t\t\t\t\tresult = arg;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn result;\n\t}\n\n\tpublic getArguments(argv: string[]): DoculaConsoleArguments {\n\t\tconst args = {\n\t\t\tsitePath: '',\n\t\t\ttemplatePath: '',\n\t\t\toutput: '',\n\t\t\twatch: false,\n\t\t\tport: 3000,\n\t\t};\n\t\tfor (let i = 0; i < argv.length; i++) {\n\t\t\tconst arg = argv[i];\n\t\t\t// eslint-disable-next-line default-case\n\t\t\tswitch (arg) {\n\t\t\t\tcase '-p':\n\t\t\t\tcase '--port': {\n\t\t\t\t\tconst portString = argv[i + 1];\n\t\t\t\t\tif (portString !== undefined) {\n\t\t\t\t\t\targs.port = Number.parseInt(portString, 10);\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tcase '-o':\n\t\t\t\tcase '--output': {\n\t\t\t\t\targs.output = argv[i + 1];\n\t\t\t\t\targs.output = path.join(process.cwd(), args.output);\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tcase '-w':\n\t\t\t\tcase '--watch': {\n\t\t\t\t\targs.watch = true;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tcase '-s':\n\t\t\t\tcase '--site': {\n\t\t\t\t\targs.sitePath = argv[i + 1];\n\t\t\t\t\targs.sitePath = path.join(process.cwd(), args.sitePath);\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tcase '-t':\n\t\t\t\tcase '--templatePath': {\n\t\t\t\t\targs.templatePath = argv[i + 1];\n\t\t\t\t\targs.templatePath = path.join(process.cwd(), args.templatePath);\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn args;\n\t}\n}\n\ntype DoculaConsoleProcess = {\n\targv: string[];\n\tcommand: string | undefined;\n\targs: DoculaConsoleArguments;\n};\n\ntype DoculaConsoleArguments = {\n\tsitePath: string | undefined;\n\ttemplatePath: string | undefined;\n\toutput: string | undefined;\n\twatch: boolean;\n\tport: number;\n};\n\n"]}

package/dist/docula.d.ts

@@ -1,22 +1,23 @@
-import { Config } from './config.js';
-import type { CommanderOptions } from './index.js';
-export declare class Docula {
-    readonly config: Config;
-    private readonly eleventy;
-    private pluginInstances;
-    private readonly beforePlugins;
-    private readonly afterPlugins;
-    private readonly landingFilesExceptions;
-    constructor(options?: CommanderOptions);
-    init(sitePath?: string): Promise<void>;
-    build(): Promise<void>;
-    serve(): Promise<void>;
-    copyLandingFolder(source: string, target: string): void;
-    copyFolder(source: string, target: string): void;
-    copySearchEngineFiles(): void;
-    writeConfigFile(sitePath?: string): Promise<Record<string, unknown>>;
-    validateFilePath(source: string, target: string): Record<string, any>;
-    private loadPlugins;
-    private readonly executePlugins;
+/// <reference types="node" />
+/// <reference types="node" />
+import type http from 'node:http';
+import { DoculaOptions } from './options.js';
+export default class Docula {
+    private _options;
+    private readonly _console;
+    private _configFileModule;
+    private _server;
+    constructor(options?: DoculaOptions);
+    get options(): DoculaOptions;
+    set options(value: DoculaOptions);
+    get server(): http.Server | undefined;
+    get configFileModule(): any;
+    checkForUpdates(): void;
+    execute(process: NodeJS.Process): Promise<void>;
+    isSinglePageWebsite(sitePath: string): boolean;
+    generateInit(sitePath: string): void;
+    getVersion(): string;
+    loadConfigFile(sitePath: string): Promise<void>;
+    serve(options: DoculaOptions): Promise<void>;
 }
-//# sourceMappingURL=docula.d.ts.map
+export { DoculaHelpers } from './helpers.js';