@opra/cli 1.0.0-alpha.11 → 1.0.0-alpha.13

package/cjs/ts-generator/processors/process-data-types.js

@@ -1,116 +1,128 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveTypeNameOrDef = exports.generateMappedTypeDefinition = exports.generateMixinTypeDefinition = exports.generateSimpleTypeDefinition = exports.generateComplexTypeDefinition = exports.generateEnumTypeDefinition = exports.processDataType = void 0;
+exports.generateMappedTypeDefinition = exports.generateMixinTypeDefinition = exports.generateSimpleTypeDefinition = exports.generateComplexTypeDefinition = exports.generateEnumTypeDefinition = exports.generateTypeDefinition = exports.processDataType = void 0;
 const tslib_1 = require("tslib");
 const common_1 = require("@opra/common");
 const path_1 = tslib_1.__importDefault(require("path"));
 const code_block_js_1 = require("../../code-block.js");
 const string_utils_js_1 = require("../utils/string-utils.js");
 const internalTypeNames = ['any', 'boolean', 'bigint', 'number', 'null', 'string', 'object'];
-async function processDataType(dataType) {
+async function processDataType(dataType, currentFile, intent) {
     const doc = dataType.node.getDocument();
     if (doc.id !== this._document?.id) {
         const { generator } = await this.processDocument(doc);
-        return await generator.processDataType(dataType);
+        return await generator.processDataType(dataType, currentFile, intent);
     }
     const typeName = dataType.name;
-    if (typeName && internalTypeNames.includes(typeName))
-        return;
-    if (!typeName)
-        throw new TypeError(`DataType has no name`);
-    let file = this._filesMap.get(dataType);
-    if (file)
-        return file;
-    if (dataType instanceof common_1.SimpleType)
-        file = this.addFile(path_1.default.join(this._documentRoot, '/simple-types.ts'), true);
-    else {
-        if (dataType instanceof common_1.EnumType)
+    if (typeName) {
+        if (internalTypeNames.includes(typeName))
+            return { kind: 'internal', typeName: dataType.name };
+        let file = this._filesMap.get(dataType);
+        if (file) {
+            if (currentFile)
+                currentFile.addImport(file.filename, [typeName]);
+            return { kind: 'named', file, typeName: dataType.name };
+        }
+        if (dataType instanceof common_1.SimpleType)
+            file = this.addFile(path_1.default.join(this._documentRoot, '/simple-types.ts'), true);
+        else if (dataType instanceof common_1.EnumType)
             file = this.addFile(path_1.default.join(this._typesRoot, 'enums', typeName + '.ts'));
         else
             file = this.addFile(path_1.default.join(this._typesRoot, 'types', typeName + '.ts'));
-    }
-    this._filesMap.set(dataType, file);
-    file = this._filesMap.get(dataType);
-    if (file.exportTypes.includes(typeName))
-        return file;
-    file.exportTypes.push(typeName);
-    const typesIndexTs = this.addFile(path_1.default.join(this._typesRoot, 'index.ts'), true);
-    const indexTs = this.addFile('/index.ts', true);
-    indexTs.addExport(typesIndexTs.filename);
-    const codeBlock = (file.code['type_' + typeName] = new code_block_js_1.CodeBlock());
-    codeBlock.head = `/**\n * ${typeName}`;
-    if (dataType.description)
-        codeBlock.head += `\n * ${(0, string_utils_js_1.wrapJSDocString)(dataType.description || '')}`;
-    codeBlock.head += `
+        this._filesMap.set(dataType, file);
+        if (file.exportTypes.includes(typeName)) {
+            if (currentFile)
+                currentFile.addImport(file.filename, [typeName]);
+            return { kind: 'named', file, typeName: dataType.name };
+        }
+        file.exportTypes.push(typeName);
+        const typesIndexTs = this.addFile(path_1.default.join(this._typesRoot, 'index.ts'), true);
+        const indexTs = this.addFile('/index.ts', true);
+        indexTs.addExport(typesIndexTs.filename);
+        const codeBlock = (file.code['type_' + typeName] = new code_block_js_1.CodeBlock());
+        codeBlock.head = `/**\n * ${(0, string_utils_js_1.wrapJSDocString)(dataType.description || '')}\n *`;
+        codeBlock.head += `
  * @url ${path_1.default.posix.join(doc.url || this.serviceUrl, '$schema', '#types/' + typeName)}
  */
 export `;
-    if (dataType instanceof common_1.EnumType)
-        codeBlock.typeDef = await this.generateEnumTypeDefinition(dataType, 'scope');
-    else if (dataType instanceof common_1.ComplexType) {
-        codeBlock.typeDef = await this.generateComplexTypeDefinition(dataType, file, 'scope');
+        codeBlock.typeDef = (await this.generateTypeDefinition(file, dataType, 'root')) + '\n\n';
+        typesIndexTs.addExport(file.filename);
+        if (currentFile)
+            currentFile.addImport(file.filename, [typeName]);
+        return { kind: 'named', file, typeName };
+    }
+    if (!currentFile)
+        throw new TypeError(`You must provide currentFile to generate data type`);
+    const code = await this.generateTypeDefinition(currentFile, dataType, intent);
+    return { kind: 'embedded', code };
+}
+exports.processDataType = processDataType;
+/**
+ *
+ */
+async function generateTypeDefinition(currentFile, dataType, intent) {
+    if (intent === 'root' && !dataType.name) {
+        throw new TypeError(`Name required to generate data type code to root intent`);
+    }
+    if (dataType instanceof common_1.EnumType) {
+        return await this.generateEnumTypeDefinition(currentFile, dataType, intent);
+    }
+    if (dataType instanceof common_1.ComplexType) {
+        return await this.generateComplexTypeDefinition(currentFile, dataType, intent);
     }
-    else if (dataType instanceof common_1.SimpleType) {
-        codeBlock.typeDef = await this.generateSimpleTypeDefinition(dataType, 'scope');
+    if (dataType instanceof common_1.SimpleType) {
+        return await this.generateSimpleTypeDefinition(currentFile, dataType, intent);
     }
-    else if (dataType instanceof common_1.MappedType) {
-        codeBlock.typeDef = await this.generateMappedTypeDefinition(dataType, file, 'scope');
+    if (dataType instanceof common_1.MappedType) {
+        return await this.generateMappedTypeDefinition(currentFile, dataType, intent);
     }
-    else if (dataType instanceof common_1.MixinType) {
-        codeBlock.typeDef = await this.generateMixinTypeDefinition(dataType, file, 'scope');
+    if (dataType instanceof common_1.MixinType) {
+        return await this.generateMixinTypeDefinition(currentFile, dataType, intent);
     }
-    else
-        throw new TypeError(`${dataType.kind} data type (${typeName}) can not be directly exported`);
-    typesIndexTs.addExport(file.filename);
-    return file;
+    /* istanbul ignore next */
+    throw new TypeError(`${dataType.kind} data types can not be directly exported`);
 }
-exports.processDataType = processDataType;
+exports.generateTypeDefinition = generateTypeDefinition;
 /**
  *
  */
-async function generateEnumTypeDefinition(dataType, intent) {
-    if (intent === 'field') {
-        return ('(' +
-            Object.keys(dataType.attributes)
-                .map(t => `'${t}'`)
-                .join(' | ') +
-            ')');
-    }
-    if (intent !== 'scope')
-        throw new TypeError(`Can't generate EnumType for "${intent}" intent`);
-    if (!dataType.name)
-        throw new TypeError(`Name required to generate EnumType for "${intent}" intent`);
-    let out = `enum ${dataType.name} {\n\t`;
-    for (const [value, info] of Object.entries(dataType.attributes)) {
-        // Print JSDoc
-        let jsDoc = '';
-        if (dataType.attributes[value].description)
-            jsDoc += ` * ${dataType.attributes[value].description}\n`;
-        if (jsDoc)
-            out += `/**\n${jsDoc} */\n`;
-        out +=
-            `${info.alias || value} = ` + (typeof value === 'number' ? value : "'" + String(value).replace("'", "\\'") + "'");
-        out += ',\n\n';
+async function generateEnumTypeDefinition(currentFile, dataType, intent) {
+    if (intent === 'root') {
+        let out = `enum ${dataType.name} {\n\t`;
+        for (const [value, info] of Object.entries(dataType.attributes)) {
+            // Print JSDoc
+            let jsDoc = '';
+            if (dataType.attributes[value].description)
+                jsDoc += ` * ${dataType.attributes[value].description}\n`;
+            if (jsDoc)
+                out += `/**\n${jsDoc} */\n`;
+            out +=
+                `${info.alias || value} = ` +
+                    (typeof value === 'number' ? value : "'" + String(value).replace("'", "\\'") + "'");
+            out += ',\n\n';
+        }
+        return out + '\b}';
     }
-    return out + '\b}';
+    return ('(' +
+        Object.keys(dataType.attributes)
+            .map(t => `'${t}'`)
+            .join(' | ') +
+        ')');
 }
 exports.generateEnumTypeDefinition = generateEnumTypeDefinition;
 /**
  *
  */
-async function generateComplexTypeDefinition(dataType, file, intent) {
-    if (intent === 'scope' && !dataType.name) {
-        throw new TypeError(`Name required to generate ComplexType for "${intent}" intent`);
-    }
-    let out = intent === 'scope' ? `interface ${dataType.name} ` : '';
+async function generateComplexTypeDefinition(currentFile, dataType, intent) {
+    let out = intent === 'root' ? `interface ${dataType.name} ` : '';
     const ownFields = [...dataType.fields.values()].filter(f => f.origin === dataType);
     if (dataType.base) {
-        const base = await this.resolveTypeNameOrDef(dataType.base, file, 'extends');
-        const omitBaseFields = dataType.base ? ownFields.filter(f => dataType.base.fields.has(f.name)) : [];
-        const baseDef = omitBaseFields.length
-            ? `Omit<${base}, ${omitBaseFields.map(x => "'" + x.name + "'").join(' | ')}>`
-            : `${base}`;
-        if (intent === 'scope')
+        const base = await this.processDataType(dataType.base, currentFile, 'extends');
+        let baseDef = base.kind === 'embedded' ? base.code : base.typeName;
+        const omitBaseFields = ownFields.filter(f => dataType.base.fields.has(f.name));
+        if (omitBaseFields.length)
+            baseDef = `Omit<${baseDef}, ${omitBaseFields.map(x => "'" + x.name + "'").join(' | ')}>`;
+        if (intent === 'root')
             out += `extends ${baseDef} `;
         else {
             out += baseDef;
@@ -149,7 +161,8 @@ async function generateComplexTypeDefinition(dataType, file, intent) {
             out += `${t === 'number' || t === 'boolean' || t === 'bigint' ? field.fixed : "'" + field.fixed + "'"}\n`;
         }
         else {
-            out += (await this.resolveTypeNameOrDef(field.type, file, 'field')) + `${field.isArray ? '[]' : ''};\n`;
+            const x = await this.processDataType(field.type, currentFile);
+            out += (x.kind === 'embedded' ? x.code : x.typeName) + `${field.isArray ? '[]' : ''};\n`;
         }
     }
     if (dataType.additionalFields)
@@ -160,29 +173,39 @@ exports.generateComplexTypeDefinition = generateComplexTypeDefinition;
 /**
  *
  */
-async function generateSimpleTypeDefinition(dataType, intent) {
-    if (intent === 'scope' && !dataType.name) {
-        throw new TypeError(`Name required to generate SimpleType for "${intent}" intent`);
-    }
-    let out = intent === 'scope' ? `type ${dataType.name} = ` : '';
+async function generateSimpleTypeDefinition(currentFile, dataType, intent) {
+    let out = intent === 'root' ? `type ${dataType.name} = ` : '';
     out += dataType.nameMappings.js || 'any';
-    return intent === 'scope' ? out + ';' : out;
+    return intent === 'root' ? out + ';' : out;
 }
 exports.generateSimpleTypeDefinition = generateSimpleTypeDefinition;
 /**
  *
  */
-async function generateMixinTypeDefinition(dataType, file, intent) {
-    return (await Promise.all(dataType.types.map(t => this.resolveTypeNameOrDef(t, file, intent))))
-        .map(t => (t.includes('|') ? '(' + t + ')' : t))
-        .join(intent === 'extends' ? ', ' : ' & ');
+async function generateMixinTypeDefinition(currentFile, dataType, intent) {
+    const outArray = [];
+    for (const t of dataType.types) {
+        const x = await this.processDataType(t, currentFile);
+        if (x.kind === 'embedded') {
+            outArray.push(x.code.includes('|') ? '(' + x.code + ')' : x.code);
+        }
+        else
+            outArray.push(x.typeName);
+    }
+    if (intent === 'root')
+        return `type ${dataType.name} = ${outArray.join(' & ')}`;
+    if (intent === 'extends')
+        return outArray.join(', ');
+    return outArray.join(' & ');
 }
 exports.generateMixinTypeDefinition = generateMixinTypeDefinition;
 /**
  *
  */
-async function generateMappedTypeDefinition(dataType, file, intent) {
-    const typeDef = await this.resolveTypeNameOrDef(dataType.base, file, intent);
+async function generateMappedTypeDefinition(currentFile, dataType, intent) {
+    let out = intent === 'root' ? `type ${dataType.name} = ` : '';
+    const base = await this.processDataType(dataType.base, currentFile);
+    const typeDef = base.kind === 'embedded' ? base.code : base.typeName;
     const pick = dataType.pick?.length ? dataType.pick : undefined;
     const omit = !pick && dataType.omit?.length ? dataType.omit : undefined;
     const partial = dataType.partial === true || (Array.isArray(dataType.partial) && dataType.partial.length > 0)
@@ -193,18 +216,17 @@ async function generateMappedTypeDefinition(dataType, file, intent) {
         : undefined;
     if (!(pick || omit || partial || required))
         return typeDef;
-    let out = '';
     if (partial === true)
         out += 'Partial<';
     else if (partial) {
         out += 'PartialSome<';
-        file.addExport('ts-gems', ['PartialSome']);
+        currentFile.addExport('ts-gems', ['PartialSome']);
     }
     if (required === true)
         out += 'Partial<';
     else if (required) {
         out += 'RequiredSome<';
-        file.addExport('ts-gems', ['RequiredSome']);
+        currentFile.addExport('ts-gems', ['RequiredSome']);
     }
     if (pick)
         out += 'Pick<';
@@ -234,29 +256,3 @@ async function generateMappedTypeDefinition(dataType, file, intent) {
     return out;
 }
 exports.generateMappedTypeDefinition = generateMappedTypeDefinition;
-/**
- *
- */
-async function resolveTypeNameOrDef(dataType, file, intent) {
-    if (dataType.name && !dataType.embedded) {
-        if (internalTypeNames.includes(dataType.name))
-            return dataType.name;
-        const f = await this.processDataType(dataType);
-        if (!f)
-            return '';
-        file.addImport(f.filename, [dataType.name], true);
-        return dataType.name;
-    }
-    if (dataType instanceof common_1.SimpleType)
-        return this.generateSimpleTypeDefinition(dataType, intent);
-    if (dataType instanceof common_1.EnumType)
-        return this.generateEnumTypeDefinition(dataType, intent);
-    if (dataType instanceof common_1.MixinType)
-        return this.generateMixinTypeDefinition(dataType, file, intent);
-    if (dataType instanceof common_1.MappedType)
-        return this.generateMappedTypeDefinition(dataType, file, intent);
-    if (dataType instanceof common_1.ComplexType)
-        return this.generateComplexTypeDefinition(dataType, file, intent);
-    return '';
-}
-exports.resolveTypeNameOrDef = resolveTypeNameOrDef;

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

@@ -90,8 +90,13 @@ async function processHttpController(controller) {
         }
         let argIndex = 0;
         for (const prm of pathParams) {
-            const type = (0, locate_named_type_js_1.locateNamedType)(prm.type);
-            const typeName = type ? await this.resolveTypeNameOrDef(type, file, 'field') : 'any';
+            let typeName;
+            if (prm.type) {
+                const xt = await this.processDataType(prm.type, file);
+                typeName = xt.kind === 'embedded' ? xt.code : xt.typeName;
+            }
+            else
+                typeName = `any`;
             if (argIndex++ > 0)
                 operationBlock.head += ', ';
             operationBlock.head += `${prm.name}: ${typeName}`;
@@ -103,8 +108,10 @@ async function processHttpController(controller) {
             let typeArr = [];
             for (const content of operation.requestBody.content) {
                 if (content.type) {
-                    const typeName = await this.resolveTypeNameOrDef(content.type, file, 'field');
+                    const xt = await this.processDataType(content.type, file);
+                    const typeName = xt.kind === 'embedded' ? xt.code : xt.typeName;
                     typeArr.push(typeName);
+                    continue;
                 }
                 typeArr = [];
                 break;
@@ -131,18 +138,15 @@ async function processHttpController(controller) {
                 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;
-                    }
+                if (prm.type) {
+                    const xt = await this.processDataType(prm.type, file);
+                    const typeDef = xt.kind === 'embedded' ? xt.code : xt.typeName;
+                    operationBlock.head += `${typeDef};\n`;
                 }
-                operationBlock.head += `${type?.name || 'any'};\n`;
+                else
+                    operationBlock.head += `any;\n`;
             }
             operationBlock.head += '\b}\b';
         }
@@ -152,30 +156,39 @@ async function processHttpController(controller) {
                 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;
-                    }
+                if (prm.type) {
+                    const xt = await this.processDataType(prm.type, file);
+                    const typeDef = xt.kind === 'embedded' ? xt.code : xt.typeName;
+                    operationBlock.head += `${typeDef};\n`;
                 }
-                operationBlock.head += `${type?.name || 'any'};\n`;
+                else
+                    operationBlock.head += `any;\n`;
             }
             operationBlock.head += '\b}\b';
         }
+        /* Determine return type */
+        // let returnType = '';
+        // for (const resp of operation.responses) {
+        //   if (resp.type) {
+        //     const typeFile = await this.processDataType(resp.type);
+        //     // if (typeFile) {
+        //     //   file.addImport(typeFile.filename, [resp.type.name!]);
+        //     //   operationBlock.head += `${type.name};\n`;
+        //     //   continue;
+        //     // }
+        //   }
+        // }
         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,' : '') +
+            `\nreturn this[kClient].request(url, { method: '${operation.method}'` +
+                (hasBody ? ', body: $body' : '') +
+                (queryParams.length ? ', params: $params as any' : '') +
+                (headerParams.length ? ', headers: $headers as any' : '') +
                 '});';
         operationBlock.tail = `\b\n};\n`;
     }

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

@@ -8,11 +8,11 @@ const node_path_1 = tslib_1.__importDefault(require("node:path"));
 const node_process_1 = tslib_1.__importDefault(require("node:process"));
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 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 clean_directory_js_1 = require("./generators/clean-directory.js");
+const generate_data_type_js_1 = require("./generators/generate-data-type.js");
+const generate_document_js_1 = require("./generators/generate-document.js");
+const generate_http_api_js_1 = require("./generators/generate-http-api.js");
+const generate_http_controller_js_1 = require("./generators/generate-http-controller.js");
 const ts_file_js_1 = require("./ts-file.js");
 /**
  * @class TsGenerator
@@ -49,7 +49,7 @@ class TsGenerator extends node_events_1.EventEmitter {
             this.emit('log', chalk_1.default.cyan('Removing old files..'));
             this.cleanDirectory(this.outDir);
             this._apiPath = '/api';
-            await this.processDocument();
+            await this.generateDocument();
             const { importExt } = this.options;
             // Write files
             for (const file of Object.values(this._files)) {
@@ -95,14 +95,14 @@ class TsGenerator extends node_events_1.EventEmitter {
 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;
+    TsGenerator.prototype.generateDocument = generate_document_js_1.generateDocument;
+    TsGenerator.prototype.generateDataType = generate_data_type_js_1.generateDataType;
+    TsGenerator.prototype._generateTypeCode = generate_data_type_js_1._generateTypeCode;
+    TsGenerator.prototype._generateEnumTypeCode = generate_data_type_js_1._generateEnumTypeCode;
+    TsGenerator.prototype._generateComplexTypeCode = generate_data_type_js_1._generateComplexTypeCode;
+    TsGenerator.prototype._generateSimpleTypeCode = generate_data_type_js_1._generateSimpleTypeCode;
+    TsGenerator.prototype._generateMappedTypeCode = generate_data_type_js_1._generateMappedTypeCode;
+    TsGenerator.prototype._generateMixinTypeCode = generate_data_type_js_1._generateMixinTypeCode;
+    TsGenerator.prototype.generateHttpApi = generate_http_api_js_1.generateHttpApi;
+    TsGenerator.prototype.generateHttpController = generate_http_controller_js_1.generateHttpController;
 })();

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

@@ -0,0 +1,30 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+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);
+}