docula 0.9.0 → 0.9.2

package/dist/docula.js

@@ -1,148 +1,841 @@
-import path from 'node:path';
-import process from 'node:process';
-import fs from 'node:fs';
-import updateNotifier from 'update-notifier';
-import express from 'express';
-import { DoculaOptions } from './options.js';
-import { DoculaConsole } from './console.js';
-import { DoculaBuilder } from './builder.js';
-export default class Docula {
-    _options = new DoculaOptions();
-    _console = new DoculaConsole();
-    _configFileModule = {};
-    _server;
-    constructor(options) {
-        if (options) {
-            this._options = options;
-        }
+// src/docula.ts
+import path3 from "node:path";
+import process3 from "node:process";
+import fs3 from "node:fs";
+import updateNotifier from "update-notifier";
+import express from "express";
+
+// src/options.ts
+import path from "node:path";
+import process from "node:process";
+var DoculaOptions = class {
+  templatePath = path.join(import.meta.url, "../../template").replace("file:", "");
+  outputPath = path.join(process.cwd(), "./dist");
+  sitePath = path.join(process.cwd(), "./site");
+  githubPath = "jaredwray/docula";
+  siteTitle = "docula";
+  siteDescription = "Beautiful Website for Your Projects";
+  siteUrl = "https://docula.org";
+  port = 3e3;
+  singlePage = true;
+  sections;
+  constructor(options) {
+    if (options) {
+      this.parseOptions(options);
     }
-    get options() {
-        return this._options;
+  }
+  parseOptions(options) {
+    if (options.templatePath) {
+      this.templatePath = options.templatePath;
+      this.templatePath = path.join(process.cwd(), this.templatePath);
     }
-    set options(value) {
-        this._options = value;
+    if (options.outputPath) {
+      this.outputPath = options.outputPath;
+      this.githubPath = path.join(process.cwd(), this.outputPath);
     }
-    get server() {
-        return this._server;
+    if (options.sitePath) {
+      this.sitePath = options.sitePath;
+      this.sitePath = path.join(process.cwd(), this.sitePath);
     }
-    get configFileModule() {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return this._configFileModule;
+    if (options.githubPath) {
+      this.githubPath = options.githubPath;
     }
-    checkForUpdates() {
-        const packageJsonPath = path.join(process.cwd(), 'package.json');
-        if (fs.existsSync(packageJsonPath)) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            updateNotifier({ pkg: packageJson }).notify();
-        }
+    if (options.siteTitle) {
+      this.siteTitle = options.siteTitle;
+    }
+    if (options.siteDescription) {
+      this.siteDescription = options.siteDescription;
+    }
+    if (options.siteUrl) {
+      this.siteUrl = options.siteUrl;
     }
-    async execute(process) {
-        // Check for updates
-        this.checkForUpdates();
-        const consoleProcess = this._console.parseProcessArgv(process.argv);
-        // Automatic detect singlePage option
-        this.options.singlePage = this.isSinglePageWebsite(this.options.sitePath);
-        // Update options
-        if (consoleProcess.args.sitePath) {
-            this.options.sitePath = consoleProcess.args.sitePath;
+    if (options.sections) {
+      this.sections = options.sections;
+    }
+    if (options.port) {
+      this.port = options.port;
+    }
+    if (options.singlePage !== void 0 && typeof options.singlePage === "boolean") {
+      this.singlePage = options.singlePage;
+    }
+  }
+};
+
+// src/console.ts
+import path2 from "node:path";
+import process2 from "node:process";
+var DoculaConsole = class {
+  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 arguments_ = this.getArguments(argv);
+    return {
+      argv,
+      command,
+      args: arguments_
+    };
+  }
+  getCommand(argv) {
+    let result;
+    for (const argument of argv) {
+      switch (argument) {
+        case "init": {
+          result = "init";
+          break;
         }
-        // Load the Config File
-        await this.loadConfigFile(this.options.sitePath);
-        // Parse the config file
-        if (this._configFileModule.options) {
-            this.options.parseOptions(this._configFileModule.options);
+        case "build": {
+          result = "build";
+          break;
         }
-        // Run the onPrepare function
-        if (this._configFileModule.onPrepare) {
-            try {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-                await this._configFileModule.onPrepare(this.options);
-            }
-            catch (error) {
-                this._console.error(error.message);
-            }
+        case "serve": {
+          result = "serve";
+          break;
         }
-        if (consoleProcess.args.output) {
-            this.options.outputPath = consoleProcess.args.output;
+        case "help": {
+          result = "help";
+          break;
         }
-        switch (consoleProcess.command) {
-            case 'init': {
-                this.generateInit(this.options.sitePath);
-                break;
-            }
-            case 'help': {
-                this._console.printHelp();
-                break;
-            }
-            case 'version': {
-                this._console.log(this.getVersion());
-                break;
-            }
-            case 'serve': {
-                const builder = new DoculaBuilder(this.options);
-                await builder.build();
-                await this.serve(this.options);
-                break;
-            }
-            default: {
-                const builder = new DoculaBuilder(this.options);
-                await builder.build();
-                break;
-            }
+        case "version": {
+          result = argument;
+          break;
         }
+      }
     }
-    isSinglePageWebsite(sitePath) {
-        const documentationPath = `${sitePath}/docs`;
-        if (!fs.existsSync(documentationPath)) {
-            return true;
+    return result;
+  }
+  getArguments(argv) {
+    const arguments_ = {
+      sitePath: "",
+      templatePath: "",
+      output: "",
+      watch: false,
+      port: 3e3
+    };
+    for (let i = 0; i < argv.length; i++) {
+      const argument = argv[i];
+      switch (argument) {
+        case "-p":
+        case "--port": {
+          const portString = argv[i + 1];
+          if (portString !== void 0) {
+            arguments_.port = Number.parseInt(portString, 10);
+          }
+          break;
         }
-        const files = fs.readdirSync(documentationPath);
-        return files.length === 0;
-    }
-    generateInit(sitePath) {
-        // Check if the site path exists
-        if (!fs.existsSync(sitePath)) {
-            fs.mkdirSync(sitePath);
+        case "-o":
+        case "--output": {
+          arguments_.output = argv[i + 1];
+          arguments_.output = path2.join(process2.cwd(), arguments_.output);
+          break;
         }
-        // Add the docula.config file based on js or ts
-        const doculaConfigFile = './init/docula.config.cjs';
-        fs.copyFileSync(doculaConfigFile, `${sitePath}/docula.config.cjs`);
-        // Add in the image and favicon
-        fs.copyFileSync('./init/logo.png', `${sitePath}/logo.png`);
-        fs.copyFileSync('./init/favicon.ico', `${sitePath}/favicon.ico`);
-        // Add in the variables file
-        fs.copyFileSync('./init/variables.css', `${sitePath}/variables.css`);
-        // Output the instructions
-        this._console.log(`docula initialized. Please update the ${doculaConfigFile} file with your site information. In addition, you can replace the image, favicon, and stype the site with site.css file.`);
-    }
-    getVersion() {
-        const packageJson = fs.readFileSync('./package.json', 'utf8');
-        const packageObject = JSON.parse(packageJson);
-        return packageObject.version;
-    }
-    async loadConfigFile(sitePath) {
-        if (fs.existsSync(sitePath)) {
-            const configFile = `${sitePath}/docula.config.cjs`;
-            if (fs.existsSync(configFile)) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                this._configFileModule = await import(configFile);
-            }
+        case "-w":
+        case "--watch": {
+          arguments_.watch = true;
+          break;
         }
+        case "-s":
+        case "--site": {
+          arguments_.sitePath = argv[i + 1];
+          arguments_.sitePath = path2.join(process2.cwd(), arguments_.sitePath);
+          break;
+        }
+        case "-t":
+        case "--templatePath": {
+          arguments_.templatePath = argv[i + 1];
+          arguments_.templatePath = path2.join(process2.cwd(), arguments_.templatePath);
+          break;
+        }
+      }
+    }
+    return arguments_;
+  }
+};
+
+// src/builder.ts
+import fs from "node:fs";
+import { Ecto } from "ecto";
+import * as matter from "gray-matter";
+import he from "he";
+import * as cheerio from "cheerio";
+
+// src/github.ts
+import axios from "axios";
+var Github = class {
+  options = {
+    api: "https://api.github.com",
+    author: "",
+    repo: ""
+  };
+  constructor(options) {
+    this.parseOptions(options);
+  }
+  async getData() {
+    const data = {
+      releases: {},
+      contributors: {}
+    };
+    data.releases = await this.getReleases();
+    data.contributors = await this.getContributors();
+    return data;
+  }
+  async getReleases() {
+    const url = `${this.options.api}/repos/${this.options.author}/${this.options.repo}/releases`;
+    try {
+      const result = await axios.get(url);
+      if (result && result.data.length > 0) {
+        return this.addAnchorLink(result.data);
+      }
+      return [];
+    } catch (error) {
+      const typedError = error;
+      if (typedError.response?.status === 404) {
+        throw new Error(`Repository ${this.options.author}/${this.options.repo} not found.`);
+      }
+      throw error;
+    }
+  }
+  async getContributors() {
+    const url = `${this.options.api}/repos/${this.options.author}/${this.options.repo}/contributors`;
+    try {
+      const result = await axios.get(url);
+      if (result && result.data.length > 0) {
+        return result.data;
+      }
+    } catch (error) {
+      const typedError = error;
+      if (typedError.response?.status === 404) {
+        throw new Error(`Repository ${this.options.author}/${this.options.repo} not found.`);
+      }
+      throw error;
+    }
+  }
+  parseOptions(options) {
+    if (options.api) {
+      this.options.api = options.api;
+    }
+    this.options.author = options.author;
+    this.options.repo = options.repo;
+  }
+  addAnchorLink(data) {
+    return data.map((release) => {
+      const regex = /(?<!]\()(https:\/\/[\w./]+)(?!\))/g;
+      release.body = release.body.replaceAll(regex, "[$1]($1)");
+      return release;
+    });
+  }
+};
+
+// src/builder.ts
+var DoculaBuilder = class {
+  _options = new DoculaOptions();
+  _ecto;
+  _console = new DoculaConsole();
+  constructor(options, engineOptions) {
+    if (options) {
+      this._options = options;
+    }
+    this._ecto = new Ecto(engineOptions);
+  }
+  get options() {
+    return this._options;
+  }
+  async build() {
+    const startTime = Date.now();
+    this.validateOptions(this.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,
+      sections: this.options.sections
+    };
+    doculaData.github = await this.getGithubData(this.options.githubPath);
+    doculaData.documents = this.getDocuments(`${doculaData.sitePath}/docs`, doculaData);
+    doculaData.sections = this.getSections(`${doculaData.sitePath}/docs`, this.options);
+    doculaData.hasDocuments = doculaData.documents?.length > 0;
+    doculaData.templates = await this.getTemplates(this.options, doculaData.hasDocuments);
+    await this.buildIndexPage(doculaData);
+    await this.buildReleasePage(doculaData);
+    await this.buildSiteMapPage(doculaData);
+    await this.buildRobotsPage(this.options);
+    if (doculaData.hasDocuments) {
+      await this.buildDocsPages(doculaData);
+    }
+    const siteRelativePath = this.options.sitePath;
+    if (fs.existsSync(`${siteRelativePath}/favicon.ico`)) {
+      await fs.promises.copyFile(
+        `${siteRelativePath}/favicon.ico`,
+        `${this.options.outputPath}/favicon.ico`
+      );
+    }
+    if (fs.existsSync(`${siteRelativePath}/logo.svg`)) {
+      await fs.promises.copyFile(
+        `${siteRelativePath}/logo.svg`,
+        `${this.options.outputPath}/logo.svg`
+      );
+    }
+    if (fs.existsSync(`${siteRelativePath}/logo_horizontal.png`)) {
+      await fs.promises.copyFile(
+        `${siteRelativePath}/logo_horizontal.png`,
+        `${this.options.outputPath}/logo_horizontal.png`
+      );
+    }
+    if (fs.existsSync(`${this.options.templatePath}/css`)) {
+      this.copyDirectory(
+        `${this.options.templatePath}/css`,
+        `${this.options.outputPath}/css`
+      );
+    }
+    if (fs.existsSync(`${siteRelativePath}/variables.css`)) {
+      await fs.promises.copyFile(
+        `${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, hasDocuments) {
+    const templates = {
+      index: "",
+      releases: ""
+    };
+    if (fs.existsSync(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;
+      }
+      const documentPage = hasDocuments ? await this.getTemplateFile(
+        options.templatePath,
+        "docs"
+      ) : void 0;
+      if (documentPage) {
+        templates.docPage = documentPage;
+      }
+    } else {
+      throw new Error(`No template path found at ${options.templatePath}`);
+    }
+    return templates;
+  }
+  async getTemplateFile(path4, name) {
+    let result;
+    const files = await fs.promises.readdir(path4);
+    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.promises.mkdir(outputPath, { recursive: true });
+    await (fs.existsSync(`${sitePath}/robots.txt`) ? fs.promises.copyFile(`${sitePath}/robots.txt`, robotsPath) : fs.promises.writeFile(robotsPath, "User-agent: *\nDisallow:"));
+  }
+  async buildSiteMapPage(data) {
+    const sitemapPath = `${data.outputPath}/sitemap.xml`;
+    const urls = [{ url: data.siteUrl }, { url: `${data.siteUrl}/releases` }];
+    for (const document of data.documents ?? []) {
+      let { urlPath } = document;
+      if (urlPath.endsWith("index.html")) {
+        urlPath = urlPath.slice(0, -10);
+      }
+      urls.push({ url: `${data.siteUrl}${urlPath}` });
+    }
+    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.promises.mkdir(data.outputPath, { recursive: true });
+    await fs.promises.writeFile(sitemapPath, xml, "utf8");
+  }
+  async buildIndexPage(data) {
+    if (data.templates) {
+      const indexPath = `${data.outputPath}/index.html`;
+      await fs.promises.mkdir(data.outputPath, { recursive: true });
+      const indexTemplate = `${data.templatePath}/${data.templates.index}`;
+      let content;
+      if (!data.hasDocuments) {
+        content = await this.buildReadmeSection(data);
+      }
+      const indexContent = await this._ecto.renderFromFile(
+        indexTemplate,
+        { ...data, content },
+        data.templatePath
+      );
+      await fs.promises.writeFile(indexPath, indexContent, "utf8");
+    } else {
+      throw new Error("No templates found");
     }
-    async serve(options) {
-        if (this._server) {
-            this._server.close();
+  }
+  async buildReleasePage(data) {
+    if (data.github && data.templates) {
+      const releasesPath = `${data.outputPath}/releases/index.html`;
+      const releaseOutputPath = `${data.outputPath}/releases`;
+      await fs.promises.mkdir(releaseOutputPath, { recursive: true });
+      const releasesTemplate = `${data.templatePath}/${data.templates.releases}`;
+      const releasesContent = await this._ecto.renderFromFile(
+        releasesTemplate,
+        data,
+        data.templatePath
+      );
+      await fs.promises.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.render(readmeContent, void 0, "markdown");
+    }
+    return htmlReadme;
+  }
+  async buildDocsPages(data) {
+    if (data.templates && data.documents?.length) {
+      const documentsTemplate = `${data.templatePath}/${data.templates.docPage}`;
+      await fs.promises.mkdir(`${data.outputPath}/docs`, { recursive: true });
+      data.sidebarItems = this.generateSidebarItems(data);
+      const promises = data.documents.map(async (document) => {
+        const folder = document.urlPath.split("/").slice(0, -1).join("/");
+        await fs.promises.mkdir(`${data.outputPath}/${folder}`, { recursive: true });
+        const slug = `${data.outputPath}${document.urlPath}`;
+        let documentContent = await this._ecto.renderFromFile(
+          documentsTemplate,
+          { ...data, ...document },
+          data.templatePath
+        );
+        documentContent = he.decode(documentContent);
+        return fs.promises.writeFile(slug, documentContent, "utf8");
+      });
+      await Promise.all(promises);
+    } else {
+      throw new Error("No templates found");
+    }
+  }
+  generateSidebarItems(data) {
+    let sidebarItems = [...data.sections ?? []];
+    for (const document of data.documents ?? []) {
+      if (document.isRoot) {
+        sidebarItems.unshift({
+          path: document.urlPath.replace("index.html", ""),
+          name: document.navTitle,
+          order: document.order
+        });
+      } else {
+        const relativeFilePath = document.documentPath.replace(`${data.sitePath}/docs/`, "");
+        const sectionPath = relativeFilePath.slice(0, Math.max(0, relativeFilePath.lastIndexOf("/")));
+        const documentSection = document.section ?? sectionPath;
+        const sectionIndex = sidebarItems.findIndex((section) => section.path === documentSection);
+        if (sectionIndex === -1) {
+          continue;
         }
-        const app = express();
-        const { port } = options;
-        const { outputPath } = options;
-        app.use(express.static(outputPath));
-        this._server = app.listen(port, () => {
-            this._console.log(`Docula 🦇 at http://localhost:${port}`);
+        sidebarItems[sectionIndex].children ??= [];
+        sidebarItems[sectionIndex].children.push({
+          path: document.urlPath.replace("index.html", ""),
+          name: document.navTitle,
+          order: document.order
         });
+      }
+    }
+    sidebarItems = sidebarItems.map((section) => {
+      if (section.children) {
+        section.children.sort((a, b) => (a.order ?? section.children.length) - (b.order ?? section.children.length));
+      }
+      return section;
+    });
+    sidebarItems.sort((a, b) => (a.order ?? sidebarItems.length) - (b.order ?? sidebarItems.length));
+    return sidebarItems;
+  }
+  getDocuments(sitePath, doculaData) {
+    let documents = new Array();
+    if (fs.existsSync(sitePath)) {
+      documents = this.getDocumentInDirectory(sitePath);
+      doculaData.sections = this.getSections(sitePath, this.options);
+      for (const section of doculaData.sections) {
+        const sectionPath = `${sitePath}/${section.path}`;
+        const sectionDocuments = this.getDocumentInDirectory(sectionPath);
+        documents = [...documents, ...sectionDocuments];
+      }
+    }
+    return documents;
+  }
+  getDocumentInDirectory(sitePath) {
+    const documents = new Array();
+    const documentList = fs.readdirSync(sitePath);
+    if (documentList.length > 0) {
+      for (const document of documentList) {
+        const documentPath = `${sitePath}/${document}`;
+        const stats = fs.statSync(documentPath);
+        if (stats.isFile()) {
+          const documentData = this.parseDocumentData(documentPath);
+          documents.push(documentData);
+        }
+      }
+    }
+    documents.sort((a, b) => (a.order ?? documents.length) - (b.order ?? documents.length));
+    return documents;
+  }
+  getSections(sitePath, doculaOptions) {
+    const sections = new Array();
+    if (fs.existsSync(sitePath)) {
+      const documentList = fs.readdirSync(sitePath);
+      if (documentList.length > 0) {
+        for (const document of documentList) {
+          const documentPath = `${sitePath}/${document}`;
+          const stats = fs.statSync(documentPath);
+          if (stats.isDirectory()) {
+            const section = {
+              name: document.replaceAll("-", " ").replaceAll(/\b\w/g, (l) => l.toUpperCase()),
+              path: document
+            };
+            this.mergeSectionWithOptions(section, doculaOptions);
+            sections.push(section);
+          }
+        }
+      }
+      sections.sort((a, b) => (a.order ?? sections.length) - (b.order ?? sections.length));
+    }
+    return sections;
+  }
+  mergeSectionWithOptions(section, options) {
+    if (options.sections) {
+      const sectionOptions = options.sections.find(
+        (sectionOption) => sectionOption.path === section.path
+      );
+      if (sectionOptions) {
+        section.name = sectionOptions.name;
+        section.order = sectionOptions.order;
+        section.path = sectionOptions.path;
+      }
+    }
+    return section;
+  }
+  parseDocumentData(documentPath) {
+    const documentContent = fs.readFileSync(documentPath, "utf8");
+    const matterData = matter.default(documentContent);
+    let markdownContent = this.removeFrontmatter(documentContent);
+    markdownContent = markdownContent.replace(/^# .*\n/, "");
+    const documentsFolderIndex = documentPath.lastIndexOf("/docs/");
+    let urlPath = documentPath.slice(documentsFolderIndex).replace(".md", "/index.html");
+    let isRoot = urlPath.split("/").length === 3;
+    if (!documentPath.slice(documentsFolderIndex + 6).includes("/")) {
+      isRoot = true;
+      const filePath = documentPath.slice(documentsFolderIndex + 6);
+      if (filePath === "index.md") {
+        urlPath = documentPath.slice(documentsFolderIndex).replace(".md", ".html");
+      }
+    }
+    return {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      title: matterData.data.title,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      navTitle: matterData.data.navTitle || matterData.data.title,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      description: matterData.data.description || "",
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      order: matterData.data.order || void 0,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      section: matterData.data.section || void 0,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      keywords: matterData.data.keywords || [],
+      content: documentContent,
+      markdown: markdownContent,
+      generatedHtml: this._ecto.renderSync(markdownContent, void 0, "markdown"),
+      tableOfContents: this.getTableOfContents(markdownContent),
+      documentPath,
+      urlPath,
+      isRoot
+    };
+  }
+  removeFrontmatter(markdown) {
+    return markdown.replace(/^-{3}[\s\S]*?-{3}\s*/, "");
+  }
+  getTableOfContents(markdown) {
+    markdown = `## Table of Contents
+
+${markdown}`;
+    const html = this._ecto.renderSync(markdown, void 0, "markdown");
+    const $ = cheerio.load(html);
+    const tocTitle = $("h2").first();
+    const tocContent = tocTitle.next("ul").toString();
+    if (tocContent) {
+      return tocTitle.toString() + tocContent;
+    }
+    return void 0;
+  }
+  copyDirectory(source, target) {
+    const files = fs.readdirSync(source);
+    for (const file of files) {
+      if (file.startsWith(".")) {
+        continue;
+      }
+      const sourcePath = `${source}/${file}`;
+      const targetPath = `${target}/${file}`;
+      const stat = fs.lstatSync(sourcePath);
+      if (stat.isDirectory()) {
+        fs.mkdirSync(targetPath, { recursive: true });
+        this.copyDirectory(sourcePath, targetPath);
+      } else {
+        fs.mkdirSync(target, { recursive: true });
+        fs.copyFileSync(sourcePath, targetPath);
+      }
+    }
+  }
+};
+
+// src/helpers.ts
+import fs2 from "node:fs";
+import { load as load2, dump } from "js-yaml";
+var DoculaHelpers = class {
+  createDoc(path4, destination, frontMatter, contentFunction) {
+    const content = fs2.readFileSync(path4, "utf8");
+    let newContent = this.setFrontMatterInContent(content, frontMatter);
+    if (contentFunction) {
+      newContent = contentFunction(newContent);
+    }
+    fs2.writeFileSync(destination, newContent, "utf8");
+  }
+  getFrontMatterFromFile(path4) {
+    const content = fs2.readFileSync(path4, "utf8");
+    return this.getFrontMatter(content);
+  }
+  getFrontMatter(content) {
+    const match = /^---\r?\n([\s\S]+?)\r?\n---/.exec(content);
+    if (match) {
+      const frontMatter = load2(match[1]);
+      return frontMatter;
+    }
+    return {};
+  }
+  setFrontMatterToFile(path4, frontMatter) {
+    const content = fs2.readFileSync(path4, "utf8");
+    const newContent = this.setFrontMatterInContent(content, frontMatter);
+    fs2.writeFileSync(path4, newContent, "utf8");
+  }
+  setFrontMatterInContent(content, frontMatter) {
+    if (!frontMatter) {
+      return content;
+    }
+    const match = /^---\r?\n([\s\S]+?)\r?\n---\r?\n([\s\S]*)/.exec(content);
+    if (match) {
+      let oldFrontMatter = load2(match[1]);
+      oldFrontMatter = {
+        ...oldFrontMatter,
+        ...frontMatter
+      };
+      const newYaml2 = dump(oldFrontMatter);
+      const newContent2 = `---
+${newYaml2}---
+${match[2]}`;
+      return newContent2;
+    }
+    const newYaml = dump(frontMatter);
+    const newContent = `---
+${newYaml}---
+${content}`;
+    return newContent;
+  }
+};
+
+// src/docula.ts
+var Docula = class {
+  _options = new DoculaOptions();
+  _console = new DoculaConsole();
+  _configFileModule = {};
+  _server;
+  constructor(options) {
+    if (options) {
+      this._options = options;
+    }
+  }
+  get options() {
+    return this._options;
+  }
+  set options(value) {
+    this._options = value;
+  }
+  get server() {
+    return this._server;
+  }
+  get configFileModule() {
+    return this._configFileModule;
+  }
+  checkForUpdates() {
+    const packageJsonPath = path3.join(process3.cwd(), "package.json");
+    if (fs3.existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf8"));
+      updateNotifier({ pkg: packageJson }).notify();
+    }
+  }
+  async execute(process4) {
+    this.checkForUpdates();
+    const consoleProcess = this._console.parseProcessArgv(process4.argv);
+    this.options.singlePage = this.isSinglePageWebsite(this.options.sitePath);
+    if (consoleProcess.args.sitePath) {
+      this.options.sitePath = consoleProcess.args.sitePath;
+    }
+    await this.loadConfigFile(this.options.sitePath);
+    if (this._configFileModule.options) {
+      this.options.parseOptions(this._configFileModule.options);
+    }
+    if (this._configFileModule.onPrepare) {
+      try {
+        await this._configFileModule.onPrepare(this.options);
+      } catch (error) {
+        this._console.error(error.message);
+      }
+    }
+    if (consoleProcess.args.output) {
+      this.options.outputPath = consoleProcess.args.output;
+    }
+    switch (consoleProcess.command) {
+      case "init": {
+        this.generateInit(this.options.sitePath);
+        break;
+      }
+      case "help": {
+        this._console.printHelp();
+        break;
+      }
+      case "version": {
+        this._console.log(this.getVersion());
+        break;
+      }
+      case "serve": {
+        const builder = new DoculaBuilder(this.options);
+        await builder.build();
+        await this.serve(this.options);
+        break;
+      }
+      default: {
+        const builder = new DoculaBuilder(this.options);
+        await builder.build();
+        break;
+      }
+    }
+  }
+  isSinglePageWebsite(sitePath) {
+    const documentationPath = `${sitePath}/docs`;
+    if (!fs3.existsSync(documentationPath)) {
+      return true;
+    }
+    const files = fs3.readdirSync(documentationPath);
+    return files.length === 0;
+  }
+  generateInit(sitePath) {
+    if (!fs3.existsSync(sitePath)) {
+      fs3.mkdirSync(sitePath);
+    }
+    const doculaConfigFile = "./init/docula.config.mjs";
+    fs3.copyFileSync(doculaConfigFile, `${sitePath}/docula.config.mjs`);
+    fs3.copyFileSync("./init/logo.png", `${sitePath}/logo.png`);
+    fs3.copyFileSync("./init/favicon.ico", `${sitePath}/favicon.ico`);
+    fs3.copyFileSync("./init/variables.css", `${sitePath}/variables.css`);
+    this._console.log(`docula initialized. Please update the ${doculaConfigFile} file with your site information. In addition, you can replace the image, favicon, and stype the site with site.css file.`);
+  }
+  getVersion() {
+    const packageJson = fs3.readFileSync("./package.json", "utf8");
+    const packageObject = JSON.parse(packageJson);
+    return packageObject.version;
+  }
+  async loadConfigFile(sitePath) {
+    if (fs3.existsSync(sitePath)) {
+      const configFile = `${sitePath}/docula.config.mjs`;
+      if (fs3.existsSync(configFile)) {
+        this._configFileModule = await import(configFile);
+      }
+    }
+  }
+  async serve(options) {
+    if (this._server) {
+      this._server.close();
     }
-}
-export { DoculaHelpers } from './helpers.js';
-//# sourceMappingURL=docula.js.map
+    const app = express();
+    const { port } = options;
+    const { outputPath } = options;
+    app.use(express.static(outputPath));
+    this._server = app.listen(port, () => {
+      this._console.log(`Docula \u{1F987} at http://localhost:${port}`);
+    });
+  }
+};
+export {
+  DoculaHelpers,
+  Docula as default
+};