@ts-for-gir/cli 3.0.0-beta.8 → 3.0.0

package/src/injection/injector.ts

@@ -1,184 +0,0 @@
-import type {
-    GirClassElement,
-    GirRecordElement,
-    GirUnionElement,
-    GirInterfaceElement,
-    GirCallbackElement,
-    GirCallableParamElement,
-    Environment,
-} from '../types/index.js'
-import { Logger } from '../logger.js'
-
-import { classesAll, classesGjs, classesNode, callbacksGjs, callbacksNode, callbacksAll } from './index.js'
-import { GirFactory } from '../gir-factory.js'
-
-/**
- * Inject additional methods, properties, etc
- */
-export class Injector {
-    girFactory = new GirFactory()
-    log: Logger
-
-    constructor(private readonly environment: Environment) {
-        this.log = new Logger(environment, true, 'ConflictResolver')
-    }
-
-    /** Inject additional generics, methods, properties, etc to a existing class */
-    toClass(girClass: GirClassElement | GirUnionElement | GirInterfaceElement | GirRecordElement) {
-        if (!girClass._tsData) {
-            return
-        }
-
-        const classes = this.environment === 'gjs' ? [...classesAll, ...classesGjs] : [...classesAll, ...classesNode]
-
-        const toClass = classes.find((cls) => {
-            return (
-                girClass._tsData &&
-                cls.qualifiedName === girClass._tsData.qualifiedName &&
-                cls.versions.includes(girClass._tsData.version)
-            )
-        })
-
-        if (toClass) {
-            if (toClass.staticFunctions) {
-                girClass._tsData.staticFunctions.push(
-                    ...this.girFactory.newGirFunctions(toClass.staticFunctions, girClass._tsData, { isInjected: true }),
-                )
-            }
-            if (toClass.properties) {
-                girClass._tsData.properties.push(
-                    ...this.girFactory.newGirProperties(toClass.properties, { isInjected: true }),
-                )
-            }
-            if (toClass.constructors) {
-                girClass._tsData.constructors.push(
-                    ...this.girFactory.newGirFunctions(toClass.constructors, girClass._tsData, { isInjected: true }),
-                )
-            }
-            if (toClass.methods) {
-                girClass._tsData.methods.push(
-                    ...this.girFactory.newGirFunctions(toClass.methods, girClass._tsData, { isInjected: true }),
-                )
-            }
-            if (toClass.virtualMethods) {
-                girClass._tsData.virtualMethods.push(
-                    ...this.girFactory.newGirFunctions(toClass.virtualMethods, girClass._tsData, { isInjected: true }),
-                )
-            }
-            if (toClass.propertySignalMethods) {
-                for (const propertySignalMethod of toClass.propertySignalMethods) {
-                    propertySignalMethod.isInjected = true
-                    girClass._tsData.propertySignalMethods.push(propertySignalMethod)
-                }
-            }
-
-            if (toClass.generics) {
-                girClass._tsData.generics.push(...this.girFactory.newGenerics(toClass.generics))
-            }
-        }
-
-        return girClass
-    }
-
-    /** Inject additional generics to existing callback interfaces */
-    toCallback(girCallback: GirCallbackElement) {
-        const callbacks =
-            this.environment === 'gjs' ? [...callbacksAll, ...callbacksGjs] : [...callbacksAll, ...callbacksNode]
-
-        if (!girCallback._module || !girCallback._tsData) {
-            return girCallback
-        }
-
-        const toCallback = callbacks.find((injectCallback) => {
-            return (
-                girCallback._module &&
-                girCallback._tsData &&
-                injectCallback.name === girCallback._tsData.name &&
-                girCallback._module.namespace === injectCallback.namespace &&
-                injectCallback.versions.includes(girCallback._module.version)
-            )
-        })
-
-        // if (toCallback?.generics) {
-        //     girCallback._tsData.generics.push(...this.girFactory.newGenerics(toCallback.generics))
-        // }
-
-        // NOTICE: We merge the in parameters here
-        // TODO: Unify injections, merges and overrides
-        if (toCallback?.inParams) {
-            for (let i = 0; i < girCallback._tsData.inParams.length; i++) {
-                const newInParam = toCallback.inParams[i]
-                const oldInParam = girCallback._tsData.inParams[i]
-                if (newInParam && oldInParam && oldInParam._tsData?.name === newInParam.name) {
-                    oldInParam._tsData.type = this.girFactory.newTsTypes(newInParam.type)
-                }
-            }
-        }
-
-        if (toCallback?.tsCallbackInterface) {
-            if (toCallback?.tsCallbackInterface.generics) {
-                girCallback._tsData.tsCallbackInterface?.generics.push(
-                    ...this.girFactory.newGenerics(toCallback.tsCallbackInterface.generics),
-                )
-            }
-        }
-
-        return girCallback
-    }
-
-    toParameterType(girParam: GirCallableParamElement) {
-        const tsTypes = girParam._tsData?.type
-
-        const callbacks =
-            this.environment === 'gjs' ? [...callbacksAll, ...callbacksGjs] : [...callbacksAll, ...callbacksNode]
-
-        if (!girParam._module || !girParam._tsData) {
-            return girParam
-        }
-
-        // Use the the callback generic injections also for the type of the callback parameters
-        if (tsTypes) {
-            for (const tsType of tsTypes) {
-                const toCallback = callbacks.find((injectCallback) => {
-                    return (
-                        girParam._module &&
-                        girParam._tsData &&
-                        // TODO: compare versions
-                        `${injectCallback.namespace}.${injectCallback.name}` === tsType.type
-                    )
-                })
-
-                if (toCallback?.generics) {
-                    const tsFunc = girParam._tsData.parent
-                    const tsClass = tsFunc.parent
-                    for (const generic of toCallback.generics) {
-                        // Currently only used for `Gio.AsyncReadyCallback`
-                        if (generic.value === 'this') {
-                            if (tsFunc.isStatic && tsClass) {
-                                tsType.generics.push({
-                                    ...generic,
-                                    value: `${tsClass.namespace}.${tsClass.name}`,
-                                })
-                            } else if (tsFunc.isGlobal) {
-                                // Add generic parameter to global function
-                                tsFunc.generics.push({
-                                    name: 'Z',
-                                    value: 'unknown',
-                                })
-                                tsType.generics.push({
-                                    value: 'Z',
-                                })
-                            } else {
-                                tsType.generics.push(generic)
-                            }
-                        } else {
-                            tsType.generics.push(generic)
-                        }
-                    }
-                }
-            }
-        }
-
-        return girParam
-    }
-}

package/src/logger.ts

@@ -1,134 +0,0 @@
-/**
- * A logger that displays information in different colors on the console.
- * In addition, the environment or the module currently being processed is also included as prepended to the logging string
- */
-
-import { blue, yellow, yellowBright, green, red, white } from 'colorette'
-import { Environment } from './types/index.js'
-
-export class Logger {
-    constructor(
-        private readonly environment: Environment | '',
-        private readonly verbose: boolean,
-        private readonly moduleName: string,
-    ) {}
-    private static prepend(args: unknown[], prepend: string): unknown[] {
-        if (typeof args[0] === 'string') {
-            args[0] = `${prepend}${args[0]}`
-        }
-        return args
-    }
-    /**
-     * Returns something like '[node][Gda-5.0] Could not find type 'Gda.SqlExpr' for 'expr''
-     * @param args
-     * @param logLevel
-     */
-    private prependInfos(args: unknown[], logLevel?: 'WARN:' | 'ERROR:' | 'INFO:' | 'DEBUG:'): unknown[] {
-        if (logLevel || this.moduleName.length > 0 || this.environment.length > 0) {
-            args = Logger.prepend(args, ' ')
-        }
-        if (logLevel) {
-            if (this.moduleName.length > 0 || this.environment.length > 0) {
-                args = Logger.prepend(args, ' ' + logLevel)
-            } else {
-                args = Logger.prepend(args, logLevel)
-            }
-        }
-        if (this.moduleName.length > 0) {
-            args = Logger.prepend(args, `[${this.moduleName}]`)
-        }
-        if (this.environment.length > 0) {
-            args = Logger.prepend(args, `[${this.environment}]`)
-        }
-
-        return args
-    }
-
-    public log(...args: unknown[]): void {
-        if (!this.verbose) {
-            return
-        }
-        return console.log(...args)
-    }
-    public dir(...args: unknown[]): void {
-        if (!this.verbose) {
-            return
-        }
-        args.forEach((arg) => {
-            console.dir(arg)
-        })
-        return
-    }
-    public info(txt: string | number, ...args: unknown[]): void {
-        if (!this.verbose) {
-            return
-        }
-        return console.info(blue(txt), ...args)
-    }
-    public warn(txt: string | number, ...args: unknown[]): void {
-        if (!this.verbose) {
-            return
-        }
-        args = this.prependInfos([txt], 'WARN:')
-        return console.warn(yellow(txt), ...args)
-    }
-    public debug(txt: string | number, ...args: unknown[]): void {
-        if (!this.verbose) {
-            return
-        }
-        args = this.prependInfos([txt], 'DEBUG:')
-        return console.debug(yellowBright(txt), ...args)
-    }
-    public error(txt: string | number, ...args: unknown[]): void {
-        args = this.prependInfos([txt], 'ERROR:')
-        return this.danger(txt, args)
-    }
-    public success(txt: string | number, ...args: unknown[]): void {
-        if (!this.verbose) {
-            return
-        }
-        this.log(green(txt), ...args)
-    }
-    public danger(txt: string | number, ...args: unknown[]): void {
-        this.log(red(txt), ...args)
-    }
-
-    // Static versions (Here it must be ensured that Verbose is activated)
-    public static log(...args: unknown[]): void {
-        return console.log(...args)
-    }
-    public static dir(...args: unknown[]): void {
-        args.forEach((arg) => {
-            console.dir(arg)
-        })
-        return
-    }
-    public static info(txt: string | number, ...args: unknown[]): void {
-        ;[txt, ...args] = this.prepend([txt, ...args], 'INFO: ') as [string, ...unknown[]]
-        return console.info(blue(txt), ...args)
-    }
-    public static warn(txt: string | number, ...args: unknown[]): void {
-        ;[txt, ...args] = this.prepend([txt, ...args], 'WARN: ') as [string, ...unknown[]]
-        return console.warn(yellow(txt), ...args)
-    }
-    public static debug(txt: string | number, ...args: unknown[]): void {
-        ;[txt, ...args] = this.prepend([txt, ...args], 'DEBUG: ') as [string, ...unknown[]]
-        return console.debug(yellowBright(txt), ...args)
-    }
-    public static error(txt: string | number, ...args: unknown[]): void {
-        ;[txt, ...args] = this.prepend([txt, ...args], 'ERROR: ') as [string, ...unknown[]]
-        return this.danger(txt, args)
-    }
-    public static success(txt: string | number, ...args: unknown[]): void {
-        this.log(green(txt), ...args)
-    }
-    public static danger(txt: string | number, ...args: unknown[]): void {
-        this.log(red(txt), ...args)
-    }
-    public static white(txt: string | number, ...args: unknown[]): void {
-        this.log(white(txt), ...args)
-    }
-    public static yellow(txt: string | number, ...args: unknown[]): void {
-        this.log(yellow(txt), ...args)
-    }
-}

package/src/messages.ts

@@ -1,68 +0,0 @@
-import type { Environment, BuildType } from './types/index.js'
-
-export const NO_TSDATA = (namespace?: string) => {
-    let message = 'You need to set the tsData first!'
-    if (namespace) message = `[${namespace}] ${message}`
-    return message
-}
-
-// Error messages
-
-export const ERROR_NO_MODULES_FOUND = (girDirectories: string[]) => `No module found in ${girDirectories.join(', ')}!
-Please make sure that you have installed the necessary gir files.
-For example with "sudo apt install libgtk-3-dev" for Gtk3 on Ubuntu or "sudo dnf install gtk3-devel" on Fedora.`
-export const ERROR_CONFIG_EXTENSION_UNSUPPORTED =
-    'Only configs with the extension .js and .json are currently supported. Do nothing'
-export const ERROR_NO_MODULE_SPECIFIED = 'Need to specify modules!'
-
-// Warn messages
-
-export const WARN_NO_GIR_FILE_FOUND_FOR_PACKAGE = (packageName: string) =>
-    `No gir file found for '${packageName}', this module will be ignored`
-export const WARN_CONSTANT_ALREADY_EXPORTED = (name: string) => `The constant '${name}' has already been exported`
-export const WARN_USE_NAMESPACE_ON_TYPES = "useNamespace must be 'true' if buildType is 'types'"
-export const WARN_USE_NAMESPACE_ON_ESM = "useNamespace must be 'true' on moduleType 'esm'"
-export const WARN_PRETTIFY_ERROR = (filepath: string) => `Can't prettify file: "${filepath}".`
-
-export const WARN_IGNORE_MULTIPLE_CALLBACKS = 'Multiple callbacks are ignored!'
-export const WARN_IGNORE_MULTIPLE_FUNC_DESC = 'Ignore multiline function description!'
-
-export const WARN_DUPLICATE_ENUM_IDENTIFIER = (name: string, renamed: string) =>
-    `Enum has a duplicate identifier '${name}', renamed to '${renamed}'!`
-export const WARN_DUPLICATE_SYMBOL = (symbol: string) => `Duplicate symbol: ${symbol}`
-export const WARN_DUPLICATE_PARAMETER = (paramName: string, namespace?: string) => {
-    let message = `Duplicate parameter name "${paramName}" found!`
-    if (namespace) message = `[${namespace}] ${message}`
-    return message
-}
-
-export const WARN_NOT_FOUND_TYPE = (logName: string) => `Could not find type for "${logName}"`
-export const WARN_NOT_FOUND_PACKAGE_NAME = (namespace: string, implementation: string) =>
-    `Package name for namespace ${namespace} not found! (${implementation})`
-export const WARN_NOT_FOUND_DEPENDENCY_GIR_FILE = (girFilename: string) =>
-    `Dependency gir file not found: '${girFilename}'`
-
-export const WARN_RENAMED_PROPERTY = (originalName: string, newName: string) =>
-    `Property name renamed from '${originalName}' to '${newName}'`
-export const WARN_RENAMED_FUNCTION = (originalName: string, newName: string) =>
-    `Function name renamed from '${originalName}' to '${newName}'`
-export const WARN_RENAMED_CLASS = (originalName: string, newName: string) =>
-    `Class name renamed from '${originalName}' to '${newName}'`
-export const WARN_RENAMED_CONSTANT = (originalName: string, newName: string) =>
-    `Constant name renamed from '${originalName}' to '${newName}'`
-export const WARN_RENAMED_FIELD = (originalName: string, newName: string) =>
-    `Field name renamed from '${originalName}' to '${newName}'`
-export const WARN_RENAMED_ENUM = (originalName: string, newName: string) =>
-    `Enum name renamed from '${originalName}' to '${newName}'`
-export const WARN_RENAMED_PARAMETER = (originalName: string, newName: string) =>
-    `Parameter name renamed from '${originalName}' to '${newName}'`
-
-// Info messages
-
-export const DANGER_HTML_DOC_GENERATOR_NOT_IMPLEMENTED =
-    'The HtmlDocGenerator is currently not implemented. Do nothing...'
-export const START_MODULE = (environment: Environment, buildType?: BuildType) =>
-    `Start to generate .d.ts files for '${environment}' as '${buildType || 'unknown'}'.`
-export const FILE_PARSING_DONE = 'Files parsed, loading types...'
-export const TSDATA_PARSING_DONE = 'Typescript data loaded, generating .d.ts...'
-export const GENERATING_TYPES_DONE = 'Done.'

package/src/symtable.ts

@@ -1,70 +0,0 @@
-import type { SymTableItems, GenerateConfig, GirAnyElement } from './types/index.js'
-import { Logger } from './logger.js'
-import { WARN_NOT_FOUND_PACKAGE_NAME } from './messages.js'
-
-/**
- * The SymTable is used to get any Type from any dependency to compare or to get information from
- */
-export class SymTable {
-    /**
-     * The items are static because any GirModule has the same items to be able to access the types of dependencies as well
-     */
-    private static items: SymTableItems = {}
-    private log: Logger
-
-    public constructor(
-        private readonly config: GenerateConfig,
-        private readonly modPackageName: string,
-        private readonly modNamespace: string,
-    ) {
-        this.log = new Logger(this.config.environment, this.config.verbose, 'SymTable')
-    }
-
-    /**
-     * Get symTable key, we use this method to prepend the package version to each key to prevent version conflicts e.g. in 'Gtk-3.0' and 'Gtk-4.0'
-     * @param implementation E.g. Gtk.Window
-     * @returns E.g. 'Gtk-3.0.Gtk.Window'
-     */
-    public getKey(dependencies: string[], implementation: string): string | null {
-        if (implementation.startsWith(this.modPackageName + '.')) {
-            return implementation
-        }
-
-        if (implementation.startsWith(this.modNamespace + '.')) {
-            return this.modPackageName + '.' + implementation
-        }
-
-        if (!implementation.includes('.')) {
-            return this.modPackageName + '.' + this.modNamespace + '.' + implementation
-        }
-
-        const split = implementation.split('.')
-        const namespace = split[0]
-        const packageName = dependencies.find((dependency) => dependency.startsWith(namespace + '-'))
-        if (!packageName) {
-            this.log.warn(WARN_NOT_FOUND_PACKAGE_NAME(namespace, implementation))
-            return null
-        }
-        return packageName + '.' + implementation
-    }
-
-    public get<T>(dependencies: string[], fullTypeName: string): T | null {
-        const key = this.getKey(dependencies, fullTypeName)
-        if (!key || !SymTable.items[key]) {
-            return null
-        }
-        const result = SymTable.items[key] || null
-        return result as unknown as T | null
-    }
-
-    public getByHand<T = GirAnyElement>(key: string): T | null {
-        return (SymTable.items[key] || null) as unknown as T | null
-    }
-
-    public set(dependencies: string[], fullTypeName: string, GirElement: GirAnyElement): void {
-        const key = this.getKey(dependencies, fullTypeName)
-        if (key) {
-            SymTable.items[key] = GirElement
-        }
-    }
-}

package/src/template-processor.ts

@@ -1,233 +0,0 @@
-/**
- * The TemplateProcessor is used generate strings from templates files or template strings
- * For example, the signal methods are generated here
- */
-
-import { existsSync } from 'fs'
-import { readFile, writeFile, mkdir, readdir } from 'fs/promises'
-import Path from 'path'
-import ejs from 'ejs'
-import { Logger } from './logger.js'
-import { APP_NAME, APP_USAGE, APP_SOURCE } from './constants.js'
-import type { GenerateConfig } from './types/index.js'
-import prettier from 'prettier'
-import { __dirname, getEnvironmentDir, getDestPath } from './utils.js'
-import { WARN_PRETTIFY_ERROR } from './messages.js'
-
-const TEMPLATE_DIR = Path.join(__dirname, '../templates')
-
-export class TemplateProcessor {
-    protected environmentTemplateDir: string
-    protected log: Logger
-    constructor(
-        protected readonly data: ejs.Data | undefined,
-        protected readonly packageName: string,
-        protected readonly config: GenerateConfig,
-    ) {
-        this.data = {
-            ...this.data,
-            APP_NAME,
-            APP_USAGE,
-            APP_SOURCE,
-        }
-        this.environmentTemplateDir = getEnvironmentDir(config.environment, TEMPLATE_DIR)
-        this.log = new Logger(config.environment, config.verbose, this.packageName)
-    }
-
-    /**
-     * Loads and renders a template and gets the rendered templates back
-     * @param templateFilename
-     */
-    public async load(templateFilename: string): Promise<string> {
-        const fileContent = await this.read(templateFilename)
-        return await this.render(fileContent)
-    }
-
-    /**
-     * Loads and renders all templates in a directory and gets the rendered templates back
-     * @param templateDirname
-     */
-    public async loadAll(templateDirname: string, fileExtension: string): Promise<{ [path: string]: string }> {
-        const fileContents = await this.readAll(templateDirname, fileExtension)
-        for (const file of Object.keys(fileContents)) {
-            fileContents[file] = await this.render(fileContents[file])
-        }
-        return fileContents
-    }
-
-    /**
-     * Loads an template, render the template and write the template to the filesystem
-     * @param templateFilename
-     * @param outputDir
-     * @param outputFilename
-     * @param append
-     * @return The rendered (and if possible prettified) template string
-     */
-    public async create(
-        templateFilename: string,
-        outputDir: string,
-        outputFilename: string,
-        append = '',
-    ): Promise<string> {
-        const renderedTpl = await this.load(templateFilename)
-        const destPath = getDestPath(this.config.environment, outputDir, outputFilename)
-        const prettifiedCode = this.config.pretty ? this.prettifySource(renderedTpl, destPath) : null
-        const code = (prettifiedCode || renderedTpl) + append
-        await this.write(code, outputDir, outputFilename)
-        return code
-    }
-
-    /**
-     * Loads all templates with file extension in dir, render the templates and write the template to the filesystem
-     * @param fileExtension
-     * @param templateDirname
-     * @param outputDir
-     * @param outputDirname
-     * @return The rendered (and if possible prettified) templates
-     */
-    public async createAll(
-        fileExtension: string,
-        templateDirname: string,
-        outputDir: string,
-        outputDirname: string,
-        append = '',
-    ) {
-        const renderedTpls = await this.loadAll(templateDirname, fileExtension)
-        const result: { [path: string]: string } = {}
-        for (const filename of Object.keys(renderedTpls)) {
-            const destPath = getDestPath(this.config.environment, outputDir, outputDirname, filename)
-            const prettifiedCode = this.config.pretty ? this.prettifySource(renderedTpls[filename], destPath) : null
-            result[destPath] = (prettifiedCode || renderedTpls[filename]) + append
-            await this.write(result[destPath], outputDir, Path.join(outputDirname, filename))
-        }
-
-        return result
-    }
-
-    protected async write(content: string, outputDir: string, outputFilename: string): Promise<string> {
-        const destPath = getDestPath(this.config.environment, outputDir, outputFilename)
-
-        // write template result file
-        await mkdir(Path.dirname(destPath), { recursive: true })
-        await writeFile(destPath, content, { encoding: 'utf8', flag: 'w' })
-
-        return Promise.resolve(destPath)
-    }
-
-    protected async render(templateString: string, additionalData: Partial<ejs.Options> = {}): Promise<string> {
-        try {
-            const renderedTpl = ejs.render(templateString, {
-                async: true,
-                ...this.config,
-                ...this.data,
-                ...additionalData,
-            })
-            return Promise.resolve(renderedTpl)
-        } catch (error) {
-            this.log.error('Error on render', error)
-            return ''
-        }
-    }
-
-    /**
-     * Checks if the template file or directory exists and returns the path if found
-     * Tries first to load the file / directory from the environment-specific template folder and otherwise looks for it in the general template folder
-     * @param templateFilename
-     */
-    public exists(templateFilename: string): string | null {
-        const fullEnvironmentTemplatePath = Path.join(this.environmentTemplateDir, templateFilename)
-        const fullGeneralTemplatePath = Path.join(TEMPLATE_DIR, templateFilename)
-        if (existsSync(fullEnvironmentTemplatePath)) {
-            return fullEnvironmentTemplatePath
-        }
-        if (existsSync(fullGeneralTemplatePath)) {
-            return fullGeneralTemplatePath
-        }
-        return null
-    }
-
-    public prettifySource(source: string, filepath: string) {
-        let prettyCode: string | null = null
-        this.log.info(`   Prettify ${Path.basename(filepath)}...`)
-        let parser: prettier.LiteralUnion<prettier.BuiltInParserName, string> | prettier.CustomParser | undefined =
-            undefined
-        if (filepath.endsWith('.ts')) {
-            parser = 'typescript'
-        } else if (filepath.endsWith('.js')) {
-            parser = 'espree'
-        }
-        try {
-            prettyCode = prettier.format(source, { parser })
-        } catch (error) {
-            this.log.warn(WARN_PRETTIFY_ERROR(filepath))
-            this.log.warn('Error on prettifySource', error)
-        }
-
-        return prettyCode
-    }
-
-    public async prettify(path: string, changeFile = false): Promise<string | null> {
-        let hasError = false
-        let prettyCode: string | null = null
-        const filename = Path.basename(path)
-        this.log.info(`   Prettify ${filename}...`)
-        try {
-            const source = await readFile(Path.resolve('.', path), 'utf8')
-            prettyCode = this.prettifySource(source, path)
-        } catch (error) {
-            this.log.warn('Error on prettify', error)
-            hasError = true
-        }
-
-        if (hasError) {
-            if (!prettyCode) {
-                this.log.warn(WARN_PRETTIFY_ERROR(path))
-            }
-        } else {
-            if (prettyCode && changeFile) {
-                await this.write(prettyCode, Path.dirname(path), Path.basename(path))
-            }
-        }
-
-        return prettyCode
-    }
-
-    /**
-     * Reads a template file from filesystem and gets the raw string back
-     * @param templateFilename
-     * @return The raw template content
-     */
-    protected async read(templateFilename: string) {
-        const path = this.exists(templateFilename)
-        if (path) {
-            return await readFile(path, 'utf8')
-        }
-        throw new Error(`Template '${templateFilename}' not found'`)
-    }
-
-    /**
-     * Reads all template files from a directory and gets the raw strings back
-     * @param templateDirname
-     * @param fileExtension
-     * @return The raw template contents
-     * @throws Error if the template directory does not exist
-     * @throws Error if the template directory is empty
-     */
-    protected async readAll(templateDirname: string, fileExtension: string) {
-        const path = this.exists(templateDirname)
-        if (path) {
-            const files = (await readdir(path)).filter((file) => file.endsWith(fileExtension))
-            if (files.length === 0) {
-                throw new Error(`Template directory '${templateDirname}' is empty'`)
-            }
-            const results: { [path: string]: string } = {}
-            for (const file of files) {
-                results[file] = await readFile(Path.join(path, file), 'utf8')
-            }
-            return results
-        }
-        throw new Error(`Template directory '${templateDirname}' not found'`)
-    }
-}
-
-export default TemplateProcessor