@opra/cli 0.33.11 → 1.0.0-alpha.7

package/cjs/ts-generator/processors/process-http-controller.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processHttpController = void 0;
+const tslib_1 = require("tslib");
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const putil_varhelpers_1 = require("putil-varhelpers");
+const code_block_js_1 = require("../../code-block.js");
+const locate_named_type_js_1 = require("../utils/locate-named-type.js");
+const string_utils_js_1 = require("../utils/string-utils.js");
+async function processHttpController(controller) {
+    let file = this._filesMap.get(controller);
+    if (file)
+        return file;
+    const className = (0, putil_varhelpers_1.pascalCase)(controller.name) + 'Controller';
+    file = this.addFile(node_path_1.default.join(this._apiPath, className + '.ts'));
+    file.addImport('@opra/client', ['HttpRequestObservable', 'kClient', 'OpraHttpClient']);
+    file.addImport(node_path_1.default.relative(file.dirname, '/http-controller-node.ts'), ['HttpControllerNode']);
+    const classBlock = (file.code[className] = new code_block_js_1.CodeBlock());
+    classBlock.doc = `/** 
+ * ${(0, string_utils_js_1.wrapJSDocString)(controller.description || '')}
+ * @class ${className}
+ * @url ${node_path_1.default.posix.join(this.serviceUrl, '$schema', '#resources/' + className)}
+ */`;
+    classBlock.head = `\nexport class ${className} extends HttpControllerNode {\n\t`;
+    classBlock.properties = '';
+    const classConstBlock = (classBlock.classConstBlock = new code_block_js_1.CodeBlock());
+    classConstBlock.head = `\n\nconstructor(client: OpraHttpClient) {`;
+    classConstBlock.body = `\n\tsuper(client);`;
+    classConstBlock.tail = `\b\n}\n`;
+    if (controller.controllers.size) {
+        for (const child of controller.controllers.values()) {
+            const generator = this.extend();
+            generator._apiPath = node_path_1.default.join(this._apiPath, className);
+            const f = await generator.processHttpController(child);
+            const childClassName = (0, putil_varhelpers_1.pascalCase)(child.name) + 'Controller';
+            file.addImport(f.filename, [childClassName]);
+            const property = '$' + child.name.charAt(0).toLowerCase() + (0, putil_varhelpers_1.camelCase)(child.name.substring(1));
+            classBlock.properties += `\nreadonly ${property}: ${childClassName};`;
+            classConstBlock.body += `\nthis.${property} = new ${childClassName}(client);`;
+        }
+    }
+    /** Process operations */
+    for (const operation of controller.operations.values()) {
+        const operationBlock = (classBlock['operation_' + operation.name] = new code_block_js_1.CodeBlock());
+        operationBlock.doc = `
+/** 
+ * ${(0, string_utils_js_1.wrapJSDocString)(operation.description || operation.name + ' operation')}`;
+        if (operation.parameters.length) {
+            const block = new code_block_js_1.CodeBlock();
+            block.doc = '\n *\n * RegExp parameters:';
+            let i = 0;
+            for (const prm of operation.parameters) {
+                if (!(prm.name instanceof RegExp))
+                    continue;
+                i++;
+                block.doc +=
+                    `\n *   > ${String(prm.name)} - ${prm.description || ''}` +
+                        `\n *       - location: ${prm.location}` +
+                        `\n *       - type: ${(0, locate_named_type_js_1.locateNamedType)(prm.type)?.name || 'any'}${prm.isArray ? '[' + prm.arraySeparator + ']' : ''}` +
+                        (prm.required ? `\n *      required: ${prm.required}` : '') +
+                        (prm.deprecated ? `\n *      deprecated: ${prm.deprecated}` : '');
+            }
+            if (i)
+                operationBlock.doc += block;
+        }
+        operationBlock.doc += `\n */\n`;
+        operationBlock.head = `${operation.name}(`;
+        /** Process operation parameters */
+        const mergedParams = [...controller.parameters, ...operation.parameters];
+        const pathParams = [];
+        const queryParams = [];
+        const headerParams = [];
+        if (mergedParams.length) {
+            const pathParamsMap = {};
+            const queryParamsMap = {};
+            const headerParamsMap = {};
+            for (const prm of mergedParams) {
+                if (typeof prm.name !== 'string')
+                    continue;
+                if (prm.location === 'path')
+                    pathParamsMap[prm.name] = prm;
+                if (prm.location === 'query')
+                    queryParamsMap[prm.name] = prm;
+                if (prm.location === 'header')
+                    headerParamsMap[prm.name] = prm;
+            }
+            pathParams.push(...Object.values(pathParamsMap));
+            queryParams.push(...Object.values(queryParamsMap));
+            headerParams.push(...Object.values(headerParamsMap));
+        }
+        let argIndex = 0;
+        for (const prm of pathParams) {
+            const type = (0, locate_named_type_js_1.locateNamedType)(prm.type);
+            if (argIndex++ > 0)
+                operationBlock.head += ', ';
+            operationBlock.head += `${prm.name}: ${type?.name || 'any'}`;
+        }
+        let hasBody = false;
+        if (operation.requestBody?.content.length) {
+            if (argIndex++ > 0)
+                operationBlock.head += ', ';
+            let typeArr = [];
+            for (const content of operation.requestBody.content) {
+                if (content.type) {
+                    const dtFile = this._filesMap.get(content.type);
+                    if (dtFile) {
+                        const typeName = await this.resolveTypeNameOrDef(content.type, dtFile, 'field');
+                        typeArr.push(typeName);
+                        file.addImport(dtFile.filename, [typeName]);
+                        continue;
+                    }
+                }
+                typeArr = [];
+                break;
+            }
+            if (typeArr.length) {
+                if (operation.requestBody.partial) {
+                    file.addImport('ts-gems', ['PartialDTO']);
+                    operationBlock.head += `$body: PartialDTO<${typeArr.join(' | ')}>`;
+                }
+                else {
+                    file.addImport('ts-gems', ['DTO']);
+                    operationBlock.head += `$body: DTO<${typeArr.join(' | ')}>`;
+                }
+            }
+            else
+                operationBlock.head += `$body: any`;
+            hasBody = true;
+        }
+        /** process query params */
+        const isQueryRequired = queryParams.find(p => p.required);
+        const isHeadersRequired = queryParams.find(p => p.required);
+        if (queryParams.length) {
+            if (argIndex++ > 0)
+                operationBlock.head += ', ';
+            operationBlock.head += '\n\t$params' + (isHeadersRequired || isQueryRequired ? '' : '?') + ': {\n\t';
+            for (const prm of queryParams) {
+                const type = (0, locate_named_type_js_1.locateNamedType)(prm.type);
+                operationBlock.head += `/**\n * ${prm.description || ''}\n */\n`;
+                operationBlock.head += `${prm.name}${prm.required ? '' : '?'}: `;
+                if (type?.name) {
+                    const typeFile = await this.processDataType(type);
+                    if (typeFile) {
+                        file.addImport(typeFile.filename, [type.name]);
+                        operationBlock.head += `${type.name};\n`;
+                        continue;
+                    }
+                }
+                operationBlock.head += `${type?.name || 'any'};\n`;
+            }
+            operationBlock.head += '\b}\b';
+        }
+        /** process header params */
+        if (headerParams.length) {
+            if (argIndex++ > 0)
+                operationBlock.head += ', \n';
+            operationBlock.head += '\t$headers' + (isHeadersRequired ? '' : '?') + ': {\n\t';
+            for (const prm of headerParams) {
+                const type = (0, locate_named_type_js_1.locateNamedType)(prm.type);
+                operationBlock.head += `/**\n * ${prm.description || ''}\n */\n`;
+                operationBlock.head += `${prm.name}${prm.required ? '' : '?'}: `;
+                if (type?.name) {
+                    const typeFile = await this.processDataType(type);
+                    if (typeFile) {
+                        file.addImport(typeFile.filename, [type.name]);
+                        operationBlock.head += `${type.name};\n`;
+                        continue;
+                    }
+                }
+                operationBlock.head += `${type?.name || 'any'};\n`;
+            }
+            operationBlock.head += '\b}\b';
+        }
+        operationBlock.head += `\n): HttpRequestObservable<any>{`;
+        operationBlock.body = `\n\t`;
+        operationBlock.body +=
+            `const url = this._prepareUrl('${operation.getFullUrl()}', {` + pathParams.map(p => p.name).join(', ') + '});';
+        operationBlock.body +=
+            `\nreturn this[kClient].request(url, {` +
+                (hasBody ? ' body: $body,' : '') +
+                (queryParams.length ? ' params: $params as any,' : '') +
+                (headerParams.length ? ' headers: $headers as any,' : '') +
+                '});';
+        operationBlock.tail = `\b\n};\n`;
+    }
+    classBlock.tail = `\b}`;
+    return file;
+}
+exports.processHttpController = processHttpController;

package/cjs/ts-generator/ts-file.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TsFile = void 0;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const putil_flattentext_1 = tslib_1.__importDefault(require("putil-flattentext"));
+const code_block_js_1 = require("../code-block.js");
+class TsFile {
+    constructor(filename) {
+        this.filename = filename;
+        this.imports = {};
+        this.exportFiles = {};
+        this.exportTypes = [];
+        this.code = new code_block_js_1.CodeBlock();
+        this.dirname = path_1.default.dirname(filename);
+        this.code.header = '';
+        this.code.imports = '';
+        this.code.exports = '';
+    }
+    addImport(filename, items, typeImport) {
+        if (isLocalFile(filename)) {
+            filename = path_1.default.relative(this.dirname, path_1.default.resolve(this.dirname, filename));
+            if (!filename.startsWith('.'))
+                filename = './' + filename;
+        }
+        if (filename.endsWith('.d.ts'))
+            filename = filename.substring(0, filename.length - 5);
+        if (filename.endsWith('.ts') || filename.endsWith('.js'))
+            filename = filename.substring(0, filename.length - 3);
+        const imp = (this.imports[filename] = this.imports[filename] || { items: [], typeImport });
+        if (!typeImport)
+            imp.typeImport = false;
+        items?.forEach(x => {
+            if (!imp.items.includes(x))
+                imp.items.push(x);
+        });
+    }
+    addExport(filename, types) {
+        if (isLocalFile(filename)) {
+            filename = path_1.default.relative(this.dirname, path_1.default.resolve(this.dirname, filename));
+            if (!filename.startsWith('.'))
+                filename = './' + filename;
+        }
+        if (filename.endsWith('.d.ts'))
+            filename = filename.substring(0, filename.length - 5);
+        if (filename.endsWith('.ts') || filename.endsWith('.js'))
+            filename = filename.substring(0, filename.length - 3);
+        this.exportFiles[filename] = this.exportFiles[filename] || [];
+        types?.forEach(x => {
+            if (!this.exportFiles[filename].includes(x))
+                this.exportFiles[filename].push(x);
+        });
+    }
+    generate(options) {
+        this.code.imports = Object.keys(this.imports)
+            .sort((a, b) => {
+            if (a.startsWith('@'))
+                return -1;
+            if (b.startsWith('@'))
+                return 1;
+            if (!a.startsWith('.'))
+                return -1;
+            if (!b.startsWith('.'))
+                return 1;
+            return a.toLowerCase().localeCompare(b.toLowerCase());
+        })
+            .map(filename => {
+            const imp = this.imports[filename];
+            let relFile = filename;
+            if (!isPackageName(filename)) {
+                if (options?.importExt)
+                    relFile += '.js';
+            }
+            return `import${imp.typeImport ? ' type' : ''} ${imp.items.length ? '{ ' + imp.items.join(', ') + ' } from ' : ''}'${relFile}';`;
+        })
+            .join('\n');
+        this.code.exports = Object.keys(this.exportFiles)
+            .sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()))
+            .map(filename => {
+            const types = this.exportFiles[filename];
+            if (!isPackageName(filename)) {
+                if (options?.importExt)
+                    filename += '.js';
+            }
+            return `export ${types.length ? '{ ' + types.join(', ') + ' }' : '*'} from '${filename}';`;
+        })
+            .join('\n');
+        if (this.code.imports || this.code.exports)
+            this.code.exports += '\n\n';
+        return ('/* #!oprimp_auto_generated!# !! Do NOT remove this line */\n/* eslint-disable */\n' +
+            (0, putil_flattentext_1.default)(String(this.code)));
+    }
+}
+exports.TsFile = TsFile;
+function isLocalFile(s) {
+    return typeof s === 'string' && (s.startsWith('.') || s.startsWith('/'));
+}
+const PACKAGENAME_PATTERN = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+function isPackageName(s) {
+    return PACKAGENAME_PATTERN.test(s);
+}

package/cjs/ts-generator/ts-generator.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TsGenerator = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const node_events_1 = require("node:events");
+const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const node_process_1 = tslib_1.__importDefault(require("node:process"));
+const file_writer_js_1 = require("../file-writer.js");
+const clean_directory_js_1 = require("./processors/clean-directory.js");
+const process_data_types_js_1 = require("./processors/process-data-types.js");
+const process_document_js_1 = require("./processors/process-document.js");
+const process_http_api_js_1 = require("./processors/process-http-api.js");
+const process_http_controller_js_1 = require("./processors/process-http-controller.js");
+const ts_file_js_1 = require("./ts-file.js");
+/**
+ * @class TsGenerator
+ */
+class TsGenerator extends node_events_1.EventEmitter {
+    /**
+     *
+     * @constructor
+     */
+    constructor(init) {
+        super();
+        this._started = false;
+        this._files = {};
+        this.serviceUrl = init.serviceUrl;
+        this.cwd = init.cwd || node_process_1.default.cwd();
+        this.outDir = init.outDir ? node_path_1.default.resolve(this.cwd, init.outDir) : this.cwd;
+        this.fileHeader = init.fileHeader || '';
+        this.writer = init.writer || new file_writer_js_1.FileWriter();
+        this.options = { importExt: !!init.importExt };
+        this._documentsMap = new Map();
+        this._filesMap = new WeakMap();
+        this.on('log', (message, ...args) => init.logger?.log?.(message, ...args));
+        this.on('error', (message, ...args) => init.logger?.error?.(message, ...args));
+        this.on('debug', (message, ...args) => init.logger?.debug?.(message, ...args));
+        this.on('warn', (message, ...args) => init.logger?.warn?.(message, ...args));
+        this.on('verbose', (message, ...args) => init.logger?.verbose?.(message, ...args));
+    }
+    async generate() {
+        if (this._started)
+            return;
+        this.emit('start');
+        try {
+            this._started = true;
+            this.emit('log', chalk_1.default.cyan('Removing old files..'));
+            this.cleanDirectory(this.outDir);
+            this._apiPath = '/api';
+            await this.processDocument();
+            const { importExt } = this.options;
+            // Write files
+            for (const file of Object.values(this._files)) {
+                const filename = node_path_1.default.join(this.outDir, file.filename);
+                const targetDir = node_path_1.default.dirname(filename);
+                node_fs_1.default.mkdirSync(targetDir, { recursive: true });
+                await this.writer.writeFile(filename, file.generate({ importExt }));
+            }
+        }
+        catch (e) {
+            this.emit('error', e);
+            throw e;
+        }
+        finally {
+            this.emit('finish');
+        }
+    }
+    getFile(filePath) {
+        return this._files[filePath];
+    }
+    addFile(filePath, returnExists) {
+        if (!(filePath.startsWith('.') || filePath.startsWith('/')))
+            filePath = './' + filePath;
+        let file = this.getFile(filePath);
+        if (file) {
+            if (returnExists)
+                return file;
+            throw new Error(`File "${filePath}" already exists`);
+        }
+        file = new ts_file_js_1.TsFile(filePath);
+        file.code.header = this.fileHeader + (this._fileHeaderDocInfo ? '\n' + this._fileHeaderDocInfo : '') + '\n\n';
+        this._files[file.filename] = file;
+        return file;
+    }
+    extend() {
+        const instance = {
+            options: { ...this.options },
+        };
+        Object.setPrototypeOf(instance, this);
+        return instance;
+    }
+}
+exports.TsGenerator = TsGenerator;
+(() => {
+    TsGenerator.prototype.cleanDirectory = clean_directory_js_1.cleanDirectory;
+    TsGenerator.prototype.processDocument = process_document_js_1.processDocument;
+    TsGenerator.prototype.processDataType = process_data_types_js_1.processDataType;
+    TsGenerator.prototype.processHttpApi = process_http_api_js_1.processHttpApi;
+    TsGenerator.prototype.processHttpController = process_http_controller_js_1.processHttpController;
+    TsGenerator.prototype.generateEnumTypeDefinition = process_data_types_js_1.generateEnumTypeDefinition;
+    TsGenerator.prototype.generateComplexTypeDefinition = process_data_types_js_1.generateComplexTypeDefinition;
+    TsGenerator.prototype.generateSimpleTypeDefinition = process_data_types_js_1.generateSimpleTypeDefinition;
+    TsGenerator.prototype.generateMappedTypeDefinition = process_data_types_js_1.generateMappedTypeDefinition;
+    TsGenerator.prototype.generateMixinTypeDefinition = process_data_types_js_1.generateMixinTypeDefinition;
+    TsGenerator.prototype.resolveTypeNameOrDef = process_data_types_js_1.resolveTypeNameOrDef;
+})();

package/cjs/ts-generator/utils/locate-named-type.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.locateNamedType = void 0;
+const common_1 = require("@opra/common");
+function locateNamedType(type) {
+    if (!type)
+        return;
+    if (type.name)
+        return type;
+    if (type instanceof common_1.SimpleType ||
+        type instanceof common_1.ComplexType ||
+        type instanceof common_1.EnumType ||
+        type instanceof common_1.MappedType)
+        return locateNamedType(type.base);
+}
+exports.locateNamedType = locateNamedType;

package/cjs/{utils → ts-generator/utils}/string-utils.js

@@ -6,36 +6,36 @@ const js_string_escape_1 = tslib_1.__importDefault(require("js-string-escape"));
 function wrapJSDocString(s, indent, currentColumn) {
     const arr = (s || '')
         .split(/[ \n\r]/)
-        .map((x, i, a) => i < a.length - 1 ? x + ' ' : x);
+        .map((x, i, a) => (i < a.length - 1 ? x + ' ' : x));
     return _printLines(arr, {
         indent,
         currentColumn,
         lineStart: '* ',
-        lineEnd: ''
+        lineEnd: '',
     });
 }
 exports.wrapJSDocString = wrapJSDocString;
 function wrapQuotedString(s, indent, currentColumn) {
     const arr = (0, js_string_escape_1.default)(s || '')
         .split(' ')
-        .map((x, i, a) => i < a.length - 1 ? x + ' ' : x);
-    return '\'' + _printLines(arr, {
-        indent,
-        currentColumn,
-        lineStart: '\'',
-        lineEnd: '\' +',
-    }) + '\'';
+        .map((x, i, a) => (i < a.length - 1 ? x + ' ' : x));
+    return ("'" +
+        _printLines(arr, {
+            indent,
+            currentColumn,
+            lineStart: "'",
+            lineEnd: "' +",
+        }) +
+        "'");
 }
 exports.wrapQuotedString = wrapQuotedString;
 function wrapStringArray(arr, indent, currentColumn) {
-    const ar1 = arr
-        .map((x, i, a) => ('\'' + x + '\'') + (i < a.length - 1 ? ', ' : ''));
+    const ar1 = arr.map((x, i, a) => "'" + x + "'" + (i < a.length - 1 ? ', ' : ''));
     return '[' + _printLines(ar1, { indent, currentColumn }) + ']';
 }
 exports.wrapStringArray = wrapStringArray;
 function wrapTypeArray(arr, indent, currentColumn) {
-    const ar1 = arr
-        .map((x, i, a) => x + (i < a.length - 1 ? ' | ' : ''));
+    const ar1 = arr.map((x, i, a) => x + (i < a.length - 1 ? ' | ' : ''));
     return _printLines(ar1, { indent, currentColumn });
 }
 exports.wrapTypeArray = wrapTypeArray;
@@ -46,9 +46,10 @@ function _printLines(arr, opts = {}) {
     let lineWidth = (opts.lineWidth || 90) - (opts.currentColumn || 0);
     const l = arr.length;
     const printLine = (eof) => {
-        s += (s ? '\n' + ' '.repeat(indent || 0) + (opts.lineStart ? opts.lineStart : '') : '') +
-            line +
-            (!eof ? (opts.lineEnd ? opts.lineEnd : '') : '');
+        s +=
+            (s ? '\n' + ' '.repeat(indent || 0) + (opts.lineStart ? opts.lineStart : '') : '') +
+                line +
+                (!eof ? (opts.lineEnd ? opts.lineEnd : '') : '');
         line = '';
     };
     for (let i = 0; i < l; i++) {

package/esm/code-block.js

@@ -0,0 +1,13 @@
+export class CodeBlock {
+    toString() {
+        // if (this.content) return this.content;
+        let out = '';
+        for (const x of Object.values(this)) {
+            out += String(x);
+        }
+        return out;
+    }
+    [Symbol.toStringTag]() {
+        return this.toString();
+    }
+}

package/esm/index.js

@@ -1 +1 @@
-export * from './api-exporter/api-exporter.js';
+export * from './ts-generator/index.js';

package/esm/oprimp-cli.js

@@ -4,29 +4,29 @@ import * as console from 'console';
 import * as fs from 'fs';
 import path from 'path';
 import * as process from 'process';
-import { ApiExporter } from './api-exporter/api-exporter.js';
-import { getCallerFile } from './utils/get-caller-file.util.js';
-const dirname = path.dirname(getCallerFile());
+import { getStackFileName } from '@opra/common';
+import { TsGenerator } from './ts-generator/ts-generator.js';
+const dirname = path.dirname(getStackFileName());
 const pkgJson = JSON.parse(fs.readFileSync(path.resolve(dirname, '../package.json'), 'utf-8'));
 program
     .version(pkgJson.version)
     .argument('<serviceUrl>', 'OPRA service url')
     .argument('<outDir>', 'Output directory')
-    .option('--name <name>', 'Name of the service')
     .option('--ext', 'Adds js extension to imports')
     .option('--no-color', 'Disables colors in logs messages')
     .action(async (serviceUrl, outDir, options) => {
     if (!options.color)
         chalk.level = 0;
-    await ApiExporter.execute({
+    const generator = new TsGenerator({
         serviceUrl,
         logger: console,
         outDir,
-        name: options.name,
         importExt: options.ext,
-        fileHeader: '/* Generated by OPRA Service Generator, Version ' + pkgJson.version + '*/\n' +
-            '/* eslint-disable */\n'
-    }).then(() => console.log(chalk.greenBright('Completed')))
+        fileHeader: `/* Generated by OPRA Code Generator, Version ${pkgJson.version} */`,
+    });
+    await generator
+        .generate()
+        .then(() => console.log(chalk.greenBright('Completed')))
         .catch(e => console.error(e.message));
 });
 if (process.argv.length < 3)

package/esm/ts-generator/http-controller-node.js

@@ -0,0 +1,18 @@
+export const httpControllerNodeScript = `import { kClient, OpraHttpClient } from '@opra/client';
+
+const PARAM_PATTERN = /:\\w+/g;
+
+export class HttpControllerNode {
+  readonly [kClient]: OpraHttpClient;
+
+  constructor(client: OpraHttpClient) {
+    this[kClient] = client;
+  }
+  
+  protected _prepareUrl(url: string, params: Record<string, any>): string {
+    return url.replace(PARAM_PATTERN, s => {
+      return params[s.substring(1)] || '';
+    });
+  }
+}
+`;

package/esm/ts-generator/index.js

@@ -0,0 +1 @@
+export * from './ts-generator.js';

package/esm/ts-generator/processors/clean-directory.js

@@ -0,0 +1,30 @@
+import chalk from 'chalk';
+import fs from 'node:fs';
+import path from 'node:path';
+export function cleanDirectory(dirname) {
+    const rootDir = dirname;
+    const _cleanDirectory = (targetDir) => {
+        if (!fs.existsSync(targetDir))
+            return;
+        const files = fs.readdirSync(targetDir);
+        for (const f of files) {
+            const absolutePath = path.join(targetDir, f);
+            if (fs.statSync(absolutePath).isDirectory()) {
+                _cleanDirectory(absolutePath);
+                if (!fs.readdirSync(absolutePath).length) {
+                    this.emit('verbose', chalk.cyan(`Removing directory ${path.relative(absolutePath, rootDir)}`));
+                    fs.rmdirSync(absolutePath);
+                }
+                continue;
+            }
+            if (path.extname(f) === '.ts') {
+                const contents = fs.readFileSync(absolutePath, 'utf-8');
+                if (contents.includes('#!oprimp_auto_generated!#')) {
+                    this.emit('verbose', chalk.cyan(`Removing file ${path.relative(absolutePath, rootDir)}`));
+                    fs.unlinkSync(absolutePath);
+                }
+            }
+        }
+    };
+    _cleanDirectory(dirname);
+}