writr 1.9.12 → 2.0.1

package/dist/console.js

@@ -0,0 +1,120 @@
+import path from 'node:path';
+import process from 'node:process';
+export class WritrConsole {
+    log(message) {
+        console.log(message);
+    }
+    error(message) {
+        console.error(message);
+    }
+    warn(message) {
+        console.warn(message);
+    }
+    printHelp() {
+        console.log('   Usage: writr [command] [arguments]');
+        console.log();
+        console.log('   Commands:');
+        console.log('     init           Initialize a new project');
+        console.log('     build          Build the project. By default just npx writr 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 WritrConsole {\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: writr [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 writr 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[]): WritrConsoleProcess {\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[]): WritrConsoleArguments {\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 WritrConsoleProcess = {\n\targv: string[];\n\tcommand: string | undefined;\n\targs: WritrConsoleArguments;\n};\n\ntype WritrConsoleArguments = {\n\tsitePath: string | undefined;\n\ttemplatePath: string | undefined;\n\toutput: string | undefined;\n\twatch: boolean;\n\tport: number;\n};\n\n"]}

package/dist/github.d.ts

@@ -0,0 +1,22 @@
+export type GithubOptions = {
+    api?: string | undefined;
+    author: string;
+    repo: string;
+};
+export type GithubData = {
+    releases: Record<string, unknown>;
+    contributors: Record<string, unknown>;
+};
+export declare class Github {
+    options: {
+        api: string;
+        author: string;
+        repo: string;
+    };
+    constructor(options: GithubOptions);
+    getData(): Promise<GithubData>;
+    getReleases(): Promise<any>;
+    getContributors(): Promise<any>;
+    parseOptions(options: GithubOptions): void;
+    private addAnchorLink;
+}

package/dist/github.js

@@ -0,0 +1,74 @@
+import axios from 'axios';
+export class Github {
+    options = {
+        api: 'https://api.github.com',
+        author: '',
+        repo: '',
+    };
+    constructor(options) {
+        this.parseOptions(options);
+    }
+    async getData() {
+        const data = {
+            releases: {},
+            contributors: {},
+        };
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        data.releases = await this.getReleases();
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        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) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+                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) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+                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;
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
+            release.body = release.body.replaceAll(regex, '[$1]($1)');
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return release;
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/helpers/markdown.d.ts

@@ -0,0 +1,10 @@
+export declare const MarkdownHelper: {
+    fence(): {
+        attributes: {
+            language: {
+                type: StringConstructor;
+            };
+        };
+        transform(node: any, config: any): import("@markdoc/markdoc").Tag<"pre", {}>;
+    };
+};

package/dist/helpers/markdown.js

@@ -0,0 +1,24 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call */
+import pkg from '@markdoc/markdoc';
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const { Tag } = pkg;
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const MarkdownHelper = {
+    fence() {
+        return {
+            attributes: {
+                language: { type: String },
+            },
+            transform(node, config) {
+                const attributes = node.transformAttributes(config);
+                const processedChildren = node.transformChildren(config);
+                const languageClass = attributes.language ? `language-${attributes.language}` : '';
+                const codeAttributes = languageClass ? { class: languageClass } : {};
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                const codeTag = new Tag('code', codeAttributes, processedChildren.join(''));
+                return new Tag('pre', {}, [codeTag]);
+            },
+        };
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/helpers.d.ts

@@ -0,0 +1,7 @@
+export declare class WritrHelpers {
+    createDoc(path: string, destination: string, frontMatter?: Record<string, string>, contentFn?: (content: string) => string): void;
+    getFrontMatterFromFile(path: string): Record<string, string>;
+    getFrontMatter(content: string): Record<string, string>;
+    setFrontMatterToFile(path: string, frontMatter: Record<string, string>): void;
+    setFrontMatterInContent(content: string, frontMatter?: Record<string, string>): string;
+}

package/dist/helpers.js

@@ -0,0 +1,58 @@
+import fs from 'fs-extra';
+import yaml from 'js-yaml';
+export class WritrHelpers {
+    createDoc(path, destination, frontMatter, contentFn) {
+        const content = fs.readFileSync(path, 'utf8');
+        let newContent = this.setFrontMatterInContent(content, frontMatter);
+        if (contentFn) {
+            newContent = contentFn(newContent);
+        }
+        fs.writeFileSync(destination, newContent, 'utf8');
+    }
+    getFrontMatterFromFile(path) {
+        const content = fs.readFileSync(path, 'utf8');
+        return this.getFrontMatter(content);
+    }
+    getFrontMatter(content) {
+        // Use regular expressions to extract the FrontMatter
+        const match = /^---\r?\n([\s\S]+?)\r?\n---/.exec(content);
+        if (match) {
+            // Parse the YAML string to an object
+            const frontMatter = yaml.load(match[1]);
+            return frontMatter;
+        }
+        // Return null or some default value if no FrontMatter is found
+        return {};
+    }
+    setFrontMatterToFile(path, frontMatter) {
+        const content = fs.readFileSync(path, 'utf8');
+        const newContent = this.setFrontMatterInContent(content, frontMatter);
+        fs.writeFileSync(path, 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) {
+            // Parse the existing FrontMatter
+            let oldFrontMatter = yaml.load(match[1]);
+            // Set or replace values
+            oldFrontMatter = {
+                ...oldFrontMatter,
+                ...frontMatter,
+            };
+            // Serialize the FrontMatter back to a YAML string
+            const newYaml = yaml.dump(oldFrontMatter);
+            // Replace the old FrontMatter with the new string
+            const newContent = `---\n${newYaml}---\n${match[2]}`;
+            // Write the result back to the file
+            return newContent;
+        }
+        // No FrontMatter found, add it
+        const newYaml = yaml.dump(frontMatter);
+        const newContent = `---\n${newYaml}---\n${content}`;
+        return newContent;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/options.d.ts

@@ -0,0 +1,12 @@
+export declare class WritrOptions {
+    templatePath: string;
+    outputPath: string;
+    sitePath: string;
+    githubPath: string;
+    siteTitle: string;
+    siteDescription: string;
+    siteUrl: string;
+    port: number;
+    constructor(options?: Record<string, unknown>);
+    parseOptions(options: Record<string, any>): void;
+}

package/dist/options.js

@@ -0,0 +1,47 @@
+import path from 'node:path';
+import process from 'node:process';
+export class WritrOptions {
+    templatePath = path.join(process.cwd(), './template');
+    outputPath = path.join(process.cwd(), './dist');
+    sitePath = path.join(process.cwd(), './site');
+    githubPath = 'jaredwray/writr';
+    siteTitle = 'Writr';
+    siteDescription = 'Beautiful Website for Your Projects';
+    siteUrl = 'https://writr.org';
+    port = 3000;
+    constructor(options) {
+        if (options) {
+            this.parseOptions(options);
+        }
+    }
+    parseOptions(options) {
+        if (options.templatePath) {
+            this.templatePath = options.templatePath;
+            this.templatePath = path.join(process.cwd(), this.templatePath);
+        }
+        if (options.outputPath) {
+            this.outputPath = options.outputPath;
+            this.githubPath = path.join(process.cwd(), this.outputPath);
+        }
+        if (options.sitePath) {
+            this.sitePath = options.sitePath;
+            this.sitePath = path.join(process.cwd(), this.sitePath);
+        }
+        if (options.githubPath) {
+            this.githubPath = options.githubPath;
+        }
+        if (options.siteTitle) {
+            this.siteTitle = options.siteTitle;
+        }
+        if (options.siteDescription) {
+            this.siteDescription = options.siteDescription;
+        }
+        if (options.siteUrl) {
+            this.siteUrl = options.siteUrl;
+        }
+        if (options.port) {
+            this.port = options.port;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/writr.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type http from 'node:http';
+import { WritrOptions } from './options.js';
+export default class Writr {
+    private _options;
+    private readonly _console;
+    private _configFileModule;
+    private _server;
+    constructor(options?: WritrOptions);
+    get options(): WritrOptions;
+    set options(value: WritrOptions);
+    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: WritrOptions): Promise<void>;
+}
+export { WritrHelpers } from './helpers.js';

package/dist/writr.js

@@ -0,0 +1,153 @@
+import path from 'node:path';
+import process from 'node:process';
+import fs from 'fs-extra';
+import updateNotifier from 'update-notifier';
+import express from 'express';
+import { WritrOptions } from './options.js';
+import { WritrConsole } from './console.js';
+import { WritrBuilder } from './builder.js';
+import { MarkdownHelper } from './helpers/markdown.js';
+export default class Writr {
+    _options = new WritrOptions();
+    _console = new WritrConsole();
+    _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() {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return this._configFileModule;
+    }
+    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();
+        }
+    }
+    async execute(process) {
+        // Check for updates
+        this.checkForUpdates();
+        const consoleProcess = this._console.parseProcessArgv(process.argv);
+        // Update options
+        if (consoleProcess.args.sitePath) {
+            this.options.sitePath = consoleProcess.args.sitePath;
+        }
+        // Load the Config File
+        await this.loadConfigFile(this.options.sitePath);
+        // Parse the config file
+        if (this._configFileModule.options) {
+            this.options.parseOptions(this._configFileModule.options);
+        }
+        // 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);
+            }
+        }
+        if (consoleProcess.args.output) {
+            this.options.outputPath = consoleProcess.args.output;
+        }
+        const engineConfig = {
+            nodes: {
+                fence: MarkdownHelper.fence(),
+            },
+        };
+        switch (consoleProcess.command) {
+            case 'init': {
+                const isTypescript = fs.existsSync('./tsconfig.json') ?? false;
+                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 WritrBuilder(this.options, engineConfig);
+                await builder.build();
+                await this.serve(this.options);
+                break;
+            }
+            default: {
+                const builder = new WritrBuilder(this.options, engineConfig);
+                await builder.build();
+                break;
+            }
+        }
+    }
+    isSinglePageWebsite(sitePath) {
+        const docsPath = `${sitePath}/docs`;
+        if (!fs.existsSync(docsPath)) {
+            return true;
+        }
+        const files = fs.readdirSync(docsPath);
+        return files.length === 0;
+    }
+    generateInit(sitePath) {
+        // Check if the site path exists
+        if (!fs.existsSync(sitePath)) {
+            fs.mkdirSync(sitePath);
+        }
+        // Add the writr.config file based on js or ts
+        const writrConfigFile = './init/writr.config.cjs';
+        fs.copyFileSync(writrConfigFile, `${sitePath}/writr.config.cjs`);
+        // Add in the image and favicon
+        fs.copyFileSync('./init/logo.png', `${sitePath}/logo.png`);
+        fs.copyFileSync('./init/favicon.svg', `${sitePath}/favicon.svg`);
+        // Add in the variables file
+        fs.copyFileSync('./init/variables.css', `${sitePath}/variables.css`);
+        // Output the instructions
+        this._console.log(`Writr initialized. Please update the ${writrConfigFile} 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}/writr.config.cjs`;
+            if (fs.existsSync(configFile)) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                this._configFileModule = await import(configFile);
+            }
+        }
+    }
+    async serve(options) {
+        if (this._server) {
+            this._server.close();
+        }
+        const app = express();
+        const { port } = options;
+        const { outputPath } = options;
+        app.use(express.static(outputPath));
+        this._server = app.listen(port, () => {
+            this._console.log(`Writr listening at http://localhost:${port}`);
+        });
+    }
+}
+export { WritrHelpers } from './helpers.js';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"writr.js","sourceRoot":"","sources":["../src/writr.ts"],"names":[],"mappings":"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","sourcesContent":["import type http from 'node:http';\nimport path from 'node:path';\nimport process from 'node:process';\nimport fs from 'fs-extra';\nimport updateNotifier from 'update-notifier';\nimport express from 'express';\nimport {WritrOptions} from './options.js';\nimport {WritrConsole} from './console.js';\nimport {WritrBuilder} from './builder.js';\nimport {MarkdownHelper} from './helpers/markdown.js';\n\nexport default class Writr {\n\tprivate _options: WritrOptions = new WritrOptions();\n\tprivate readonly _console: WritrConsole = new WritrConsole();\n\tprivate _configFileModule: any = {};\n\tprivate _server: http.Server | undefined;\n\n\tconstructor(options?: WritrOptions) {\n\t\tif (options) {\n\t\t\tthis._options = options;\n\t\t}\n\t}\n\n\tpublic get options(): WritrOptions {\n\t\treturn this._options;\n\t}\n\n\tpublic set options(value: WritrOptions) {\n\t\tthis._options = value;\n\t}\n\n\tpublic get server(): http.Server | undefined {\n\t\treturn this._server;\n\t}\n\n\tpublic get configFileModule(): any {\n\t\t// eslint-disable-next-line @typescript-eslint/no-unsafe-return\n\t\treturn this._configFileModule;\n\t}\n\n\tpublic checkForUpdates(): void {\n\t\tconst packageJsonPath = path.join(process.cwd(), 'package.json');\n\t\tif (fs.existsSync(packageJsonPath)) {\n\t\t\t// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n\t\t\tconst packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));\n\t\t\t// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n\t\t\tupdateNotifier({pkg: packageJson}).notify();\n\t\t}\n\t}\n\n\tpublic async execute(process: NodeJS.Process): Promise<void> {\n\t\t// Check for updates\n\t\tthis.checkForUpdates();\n\n\t\tconst consoleProcess = this._console.parseProcessArgv(process.argv);\n\n\t\t// Update options\n\t\tif (consoleProcess.args.sitePath) {\n\t\t\tthis.options.sitePath = consoleProcess.args.sitePath;\n\t\t}\n\n\t\t// Load the Config File\n\t\tawait this.loadConfigFile(this.options.sitePath);\n\n\t\t// Parse the config file\n\t\tif (this._configFileModule.options) {\n\t\t\tthis.options.parseOptions(this._configFileModule.options as Record<string, any>);\n\t\t}\n\n\t\t// Run the onPrepare function\n\t\tif (this._configFileModule.onPrepare) {\n\t\t\ttry {\n\t\t\t\t// eslint-disable-next-line @typescript-eslint/no-unsafe-call\n\t\t\t\tawait this._configFileModule.onPrepare(this.options);\n\t\t\t} catch (error) {\n\t\t\t\tthis._console.error((error as Error).message);\n\t\t\t}\n\t\t}\n\n\t\tif (consoleProcess.args.output) {\n\t\t\tthis.options.outputPath = consoleProcess.args.output;\n\t\t}\n\n\t\tconst engineConfig = {\n\t\t\tnodes: {\n\t\t\t\tfence: MarkdownHelper.fence(),\n\t\t\t},\n\t\t};\n\n\t\tswitch (consoleProcess.command) {\n\t\t\tcase 'init': {\n\t\t\t\tconst isTypescript = fs.existsSync('./tsconfig.json') ?? false;\n\t\t\t\tthis.generateInit(this.options.sitePath);\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tcase 'help': {\n\t\t\t\tthis._console.printHelp();\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tcase 'version': {\n\t\t\t\tthis._console.log(this.getVersion());\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tcase 'serve': {\n\t\t\t\tconst builder = new WritrBuilder(this.options, engineConfig);\n\t\t\t\tawait builder.build();\n\t\t\t\tawait this.serve(this.options);\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tdefault: {\n\t\t\t\tconst builder = new WritrBuilder(this.options, engineConfig);\n\t\t\t\tawait builder.build();\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\n\tpublic isSinglePageWebsite(sitePath: string): boolean {\n\t\tconst docsPath = `${sitePath}/docs`;\n\t\tif (!fs.existsSync(docsPath)) {\n\t\t\treturn true;\n\t\t}\n\n\t\tconst files = fs.readdirSync(docsPath);\n\t\treturn files.length === 0;\n\t}\n\n\tpublic generateInit(sitePath: string): void {\n\t\t// Check if the site path exists\n\t\tif (!fs.existsSync(sitePath)) {\n\t\t\tfs.mkdirSync(sitePath);\n\t\t}\n\n\t\t// Add the writr.config file based on js or ts\n\t\tconst writrConfigFile = './init/writr.config.cjs';\n\t\tfs.copyFileSync(writrConfigFile, `${sitePath}/writr.config.cjs`);\n\n\t\t// Add in the image and favicon\n\t\tfs.copyFileSync('./init/logo.png', `${sitePath}/logo.png`);\n\t\tfs.copyFileSync('./init/favicon.svg', `${sitePath}/favicon.svg`);\n\n\t\t// Add in the variables file\n\t\tfs.copyFileSync('./init/variables.css', `${sitePath}/variables.css`);\n\n\t\t// Output the instructions\n\t\tthis._console.log(`Writr initialized. Please update the ${writrConfigFile} file with your site information. In addition, you can replace the image, favicon, and stype the site with site.css file.`);\n\t}\n\n\tpublic getVersion(): string {\n\t\tconst packageJson = fs.readFileSync('./package.json', 'utf8');\n\t\tconst packageObject = JSON.parse(packageJson) as {version: string};\n\t\treturn packageObject.version;\n\t}\n\n\tpublic async loadConfigFile(sitePath: string): Promise<void> {\n\t\tif (fs.existsSync(sitePath)) {\n\t\t\tconst configFile = `${sitePath}/writr.config.cjs`;\n\t\t\tif (fs.existsSync(configFile)) {\n\t\t\t\t// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n\t\t\t\tthis._configFileModule = await import(configFile);\n\t\t\t}\n\t\t}\n\t}\n\n\tpublic async serve(options: WritrOptions): Promise<void> {\n\t\tif (this._server) {\n\t\t\tthis._server.close();\n\t\t}\n\n\t\tconst app = express();\n\t\tconst {port} = options;\n\t\tconst {outputPath} = options;\n\n\t\tapp.use(express.static(outputPath));\n\n\t\tthis._server = app.listen(port, () => {\n\t\t\tthis._console.log(`Writr listening at http://localhost:${port}`);\n\t\t});\n\t}\n}\n\nexport {WritrHelpers} from './helpers.js';\n"]}

package/init/favicon.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 15 15"><defs><style>.a{fill:#ff690a;}.b{fill:#373232;}</style></defs><title>WRITR favicon</title><path class="a" d="M1.5,12h12v1H1.5Z"/><path class="b" d="M11.6,11H9L7.49,6h0L6,11H3.38L0,2H3.08L4.8,7.25h.06L6.38,2H8.69l1.58,5.25h0L12.05,2H15Z"/></svg>