@opra/cli 1.0.0-alpha.9 → 1.0.0-beta.1

package/cjs/ts-generator/generators/generate-http-controller.js

@@ -0,0 +1,296 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateHttpController = generateHttpController;
+const tslib_1 = require("tslib");
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const type_is_1 = tslib_1.__importDefault(require("@browsery/type-is"));
+const common_1 = require("@opra/common");
+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 generateHttpController(controller) {
+    let file = this._filesMap.get(controller);
+    if (file)
+        return file;
+    const generateParamDoc = async (name, type, options) => {
+        let typeDef;
+        if (type) {
+            const xt = await this.generateDataType(type, 'typeDef', file);
+            typeDef = xt.kind === 'embedded' ? 'object' : xt.typeName;
+        }
+        else
+            typeDef = 'any';
+        if (options?.isArray)
+            typeDef += '[]';
+        let out = `\n * @param {${typeDef}} ` + (options?.required ? name : `[${name}]`);
+        if (options?.description)
+            out += `  - ${(0, string_utils_js_1.wrapJSDocString)(options?.description)}`;
+        if (type instanceof common_1.ComplexType && type.embedded) {
+            for (const f of type.fields.values()) {
+                out += await generateParamDoc(name + '.' + f.name, f.type, f);
+            }
+        }
+        return out;
+    };
+    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}
+ * @apiUrl ${node_path_1.default.posix.join(this.serviceUrl, controller.getFullUrl())}
+ */`;
+    classBlock.head = `\nexport class ${className} extends HttpControllerNode {\n\t`;
+    classBlock.properties = '';
+    const classConstBlock = (classBlock.classConstBlock = new code_block_js_1.CodeBlock());
+    classConstBlock.head = `\n/**
+ * @param {OpraHttpClient} client - OpraHttpClient instance to operate
+ * @constructor
+ */  
+constructor(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.generateHttpController(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 */
+    const mergedControllerParams = [...controller.parameters];
+    let _base = controller;
+    while (_base.owner instanceof common_1.HttpController) {
+        _base = _base.owner;
+        mergedControllerParams.unshift(..._base?.parameters);
+    }
+    for (const operation of controller.operations.values()) {
+        const mergedParams = [...mergedControllerParams, ...operation.parameters];
+        const operationBlock = (classBlock['operation_' + operation.name] = new code_block_js_1.CodeBlock());
+        operationBlock.doc = new code_block_js_1.CodeBlock();
+        operationBlock.doc.header = `
+/** 
+ * ${(0, string_utils_js_1.wrapJSDocString)(operation.description || operation.name + ' operation')}`;
+        operationBlock.doc.parameters = new code_block_js_1.CodeBlock();
+        if (mergedParams.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.regExParameters = block;
+        }
+        operationBlock.doc.tail = `
+ * @apiUrl ${node_path_1.default.posix.join(this.serviceUrl, operation.getFullUrl())}    
+ */\n`;
+        operationBlock.head = `${operation.name}(`;
+        /** Process 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));
+        }
+        /** Process path parameters and add as function arguments */
+        let argIndex = 0;
+        for (const prm of pathParams) {
+            let typeDef;
+            if (prm.type) {
+                const xt = await this.generateDataType(prm.type, 'typeDef', file);
+                typeDef = xt.kind === 'embedded' ? xt.code : xt.typeName;
+            }
+            else
+                typeDef = `any`;
+            if (prm.isArray)
+                typeDef += '[]';
+            if (argIndex++ > 0)
+                operationBlock.head += ', ';
+            operationBlock.head += `${prm.name}: ${typeDef}`;
+            operationBlock.doc.parameters +=
+                `\n * @param {${typeDef}} ` +
+                    (prm.required ? prm.name : `[${prm.name}]`) +
+                    (prm.description ? ' - ' + (0, string_utils_js_1.wrapJSDocString)(prm.description || '') : '');
+        }
+        /** Process requestBody and add as function argument ($body) */
+        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) {
+                    /** Generate JSDoc for parameter */
+                    operationBlock.doc.parameters += await generateParamDoc('$body', content.type, {
+                        required: operation.requestBody.required,
+                        description: content.description || content.type.description,
+                    });
+                    /**  */
+                    const xt = await this.generateDataType(content.type, 'typeDef', file);
+                    let typeDef = xt.kind === 'embedded' ? xt.code : xt.typeName;
+                    if (typeDef === 'any') {
+                        typeArr = [];
+                        break;
+                    }
+                    if (xt.kind === 'named') {
+                        if (operation.requestBody.partial) {
+                            file.addImport('ts-gems', ['PartialDTO']);
+                            typeDef = `PartialDTO<${typeDef}>`;
+                        }
+                        else {
+                            file.addImport('ts-gems', ['DTO']);
+                            typeDef = `DTO<${typeDef}>`;
+                        }
+                    }
+                    if (typeDef && content.isArray)
+                        typeDef += '[]';
+                    typeDef = typeDef || 'undefined';
+                    if (!typeArr.includes(typeDef))
+                        typeArr.push(typeDef);
+                    continue;
+                }
+                else if (content.contentType && type_is_1.default.is(String(content.contentType), ['multipart/*'])) {
+                    const typeDef = 'FormData';
+                    if (!typeArr.includes(typeDef))
+                        typeArr.push(typeDef);
+                    continue;
+                }
+                typeArr = [];
+                break;
+            }
+            const typeDef = typeArr.join(' | ') || 'any';
+            operationBlock.head += `$body: ${typeDef}`;
+            // operationBlock.doc.parameters += `\n * @param {${typeDef}} $body - Http body` + bodyFields;
+            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';
+            operationBlock.doc.parameters += '\n * @param {object} $params - Available parameters for the operation';
+            let hasAdditionalFields = false;
+            for (const prm of queryParams) {
+                if (typeof prm.name !== 'string') {
+                    hasAdditionalFields = true;
+                    continue;
+                }
+                operationBlock.doc.parameters += await generateParamDoc('$params.' + prm.name, prm.type, prm);
+                operationBlock.head += `${prm.name}${prm.required ? '' : '?'}: `;
+                if (prm.type) {
+                    const xt = await this.generateDataType(prm.type, 'typeDef', file);
+                    let typeDef = xt.kind === 'embedded' ? xt.code : xt.typeName;
+                    if (prm.isArray)
+                        typeDef += '[]';
+                    operationBlock.head += `${typeDef};\n`;
+                }
+                else
+                    operationBlock.head += `any;\n`;
+            }
+            if (hasAdditionalFields) {
+                operationBlock.head += '[index: string]: 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) {
+                operationBlock.head += `/**\n * ${prm.description || ''}\n */\n`;
+                operationBlock.head += `${prm.name}${prm.required ? '' : '?'}: `;
+                if (prm.type) {
+                    const xt = await this.generateDataType(prm.type, 'typeDef', file);
+                    let typeDef = xt.kind === 'embedded' ? xt.code : xt.typeName;
+                    if (prm.isArray)
+                        typeDef += '[]';
+                    operationBlock.head += `${typeDef};\n`;
+                }
+                else
+                    operationBlock.head += `any;\n`;
+            }
+            operationBlock.head += '\b}\b';
+        }
+        /* Determine return type */
+        const returnTypes = [];
+        let typeDef = '';
+        for (const resp of operation.responses) {
+            if (!resp.statusCode.find(r => r.intersects(200, 299)))
+                continue;
+            typeDef = '';
+            if (resp.type) {
+                const xt = await this.generateDataType(resp.type, 'typeDef', file);
+                typeDef = xt.kind === 'embedded' ? xt.code : xt.typeName;
+            }
+            if (typeDef) {
+                if (typeDef !== 'OperationResult') {
+                    if (resp.partial) {
+                        file.addImport('ts-gems', ['PartialDTO']);
+                        typeDef = `PartialDTO<${typeDef}>`;
+                    }
+                    else {
+                        file.addImport('ts-gems', ['DTO']);
+                        typeDef = `DTO<${typeDef}>`;
+                    }
+                }
+            }
+            if (typeDef && resp.isArray)
+                typeDef += '[]';
+            if (resp.contentType && type_is_1.default.is(String(resp.contentType), [common_1.MimeTypes.opra_response_json])) {
+                file.addImport('@opra/common', ['OperationResult']);
+                typeDef = typeDef ? `OperationResult<${typeDef}>` : 'OperationResult';
+            }
+            typeDef = typeDef || 'undefined';
+            if (!returnTypes.includes(typeDef))
+                returnTypes.push(typeDef);
+        }
+        operationBlock.head += `\n): HttpRequestObservable<${returnTypes.join(' | ') || '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, { method: '${operation.method}'` +
+                (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;
+}

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TsFile = void 0;
 const tslib_1 = require("tslib");
-const path_1 = tslib_1.__importDefault(require("path"));
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
 const putil_flattentext_1 = tslib_1.__importDefault(require("putil-flattentext"));
 const code_block_js_1 = require("../code-block.js");
 class TsFile {
@@ -12,14 +12,14 @@ class TsFile {
         this.exportFiles = {};
         this.exportTypes = [];
         this.code = new code_block_js_1.CodeBlock();
-        this.dirname = path_1.default.dirname(filename);
+        this.dirname = node_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));
+            filename = node_path_1.default.relative(this.dirname, node_path_1.default.resolve(this.dirname, filename));
             if (!filename.startsWith('.'))
                 filename = './' + filename;
         }
@@ -35,9 +35,9 @@ class TsFile {
                 imp.items.push(x);
         });
     }
-    addExport(filename, types) {
+    addExport(filename, types, namespace) {
         if (isLocalFile(filename)) {
-            filename = path_1.default.relative(this.dirname, path_1.default.resolve(this.dirname, filename));
+            filename = node_path_1.default.relative(this.dirname, node_path_1.default.resolve(this.dirname, filename));
             if (!filename.startsWith('.'))
                 filename = './' + filename;
         }
@@ -45,10 +45,11 @@ class TsFile {
             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] || [];
+        const key = (namespace ? namespace + ':' : '') + filename;
+        this.exportFiles[key] = this.exportFiles[key] || { filename, items: [], namespace };
         types?.forEach(x => {
-            if (!this.exportFiles[filename].includes(x))
-                this.exportFiles[filename].push(x);
+            if (!this.exportFiles[filename].items.includes(x))
+                this.exportFiles[filename].items.push(x);
         });
     }
     generate(options) {
@@ -76,18 +77,23 @@ class TsFile {
             .join('\n');
         this.code.exports = Object.keys(this.exportFiles)
             .sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()))
-            .map(filename => {
-            const types = this.exportFiles[filename];
+            .map(key => {
+            const exportFile = this.exportFiles[key];
+            const types = exportFile.items;
+            let filename = exportFile.filename;
             if (!isPackageName(filename)) {
                 if (options?.importExt)
                     filename += '.js';
             }
-            return `export ${types.length ? '{ ' + types.join(', ') + ' }' : '*'} from '${filename}';`;
+            let out = `export ${types.length ? '{ ' + types.join(', ') + ' }' : '*'}`;
+            if (exportFile.namespace)
+                out += ` as ${exportFile.namespace}`;
+            return out + ` 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' +
+        return ('/* #!oprimp_auto_generated!# !! Do NOT remove this line */\n/* eslint-disable */\n// noinspection SpellCheckingInspection\n\n' +
             (0, putil_flattentext_1.default)(String(this.code)));
     }
 }

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

@@ -6,13 +6,13 @@ 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 chalk_1 = tslib_1.__importDefault(require("chalk"));
+const ansi_colors_1 = tslib_1.__importDefault(require("ansi-colors"));
 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
@@ -24,14 +24,14 @@ class TsGenerator extends node_events_1.EventEmitter {
      */
     constructor(init) {
         super();
-        this._started = false;
         this._files = {};
+        this._started = false;
         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.options = { importExt: !!init.importExt, referenceNamespaces: init.referenceNamespaces };
         this._documentsMap = new Map();
         this._filesMap = new WeakMap();
         this.on('log', (message, ...args) => init.logger?.log?.(message, ...args));
@@ -46,10 +46,10 @@ class TsGenerator extends node_events_1.EventEmitter {
         this.emit('start');
         try {
             this._started = true;
-            this.emit('log', chalk_1.default.cyan('Removing old files..'));
+            this.emit('log', ansi_colors_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/cjs/ts-generator/utils/locate-named-type.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.locateNamedType = void 0;
+exports.locateNamedType = locateNamedType;
 const common_1 = require("@opra/common");
 function locateNamedType(type) {
     if (!type)
@@ -14,4 +14,3 @@ function locateNamedType(type) {
         return locateNamedType(type.base);
     }
 }
-exports.locateNamedType = locateNamedType;

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

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapTypeArray = exports.wrapStringArray = exports.wrapQuotedString = exports.wrapJSDocString = void 0;
+exports.wrapJSDocString = wrapJSDocString;
+exports.wrapQuotedString = wrapQuotedString;
+exports.wrapStringArray = wrapStringArray;
+exports.wrapTypeArray = wrapTypeArray;
 const tslib_1 = require("tslib");
 const js_string_escape_1 = tslib_1.__importDefault(require("js-string-escape"));
 function wrapJSDocString(s, indent, currentColumn) {
@@ -14,7 +17,6 @@ function wrapJSDocString(s, indent, currentColumn) {
         lineEnd: '',
     });
 }
-exports.wrapJSDocString = wrapJSDocString;
 function wrapQuotedString(s, indent, currentColumn) {
     const arr = (0, js_string_escape_1.default)(s || '')
         .split(' ')
@@ -28,17 +30,14 @@ function wrapQuotedString(s, indent, currentColumn) {
         }) +
         "'");
 }
-exports.wrapQuotedString = wrapQuotedString;
 function wrapStringArray(arr, indent, currentColumn) {
     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 ? ' | ' : ''));
     return _printLines(ar1, { indent, currentColumn });
 }
-exports.wrapTypeArray = wrapTypeArray;
 function _printLines(arr, opts = {}) {
     let s = '';
     let line = '';

package/esm/file-writer.js

@@ -1,4 +1,4 @@
-import fs from 'fs';
+import fs from 'node:fs';
 export class FileWriter {
     writeFile(filename, contents) {
         fs.writeFileSync(filename, contents, 'utf-8');

package/esm/oprimp-cli.js

@@ -1,10 +1,10 @@
+import * as console from 'node:console';
+import * as fs from 'node:fs';
+import path from 'node:path';
+import * as process from 'node:process';
 import { getStackFileName } from '@opra/common';
-import chalk from 'chalk';
+import colors from 'ansi-colors';
 import { program } from 'commander';
-import * as console from 'console';
-import * as fs from 'fs';
-import path from 'path';
-import * as process from 'process';
 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'));
@@ -13,20 +13,22 @@ program
     .argument('<serviceUrl>', 'OPRA service url')
     .argument('<outDir>', 'Output directory')
     .option('--ext', 'Adds js extension to imports')
+    .option('--refns', 'Exports references with namespaces')
     .option('--no-color', 'Disables colors in logs messages')
     .action(async (serviceUrl, outDir, options) => {
     if (!options.color)
-        chalk.level = 0;
+        colors.enabled = false;
     const generator = new TsGenerator({
         serviceUrl,
         logger: console,
         outDir,
         importExt: options.ext,
+        referenceNamespaces: options.refns,
         fileHeader: `/* Generated by OPRA Code Generator, Version ${pkgJson.version} */`,
     });
     await generator
         .generate()
-        .then(() => console.log(chalk.greenBright('Completed')))
+        .then(() => console.log(colors.greenBright('Completed')))
         .catch(e => console.error(e.message));
 });
 if (process.argv.length < 3)

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/ts-generator/{processors → generators}/clean-directory.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import chalk from 'chalk';
+import colors from 'ansi-colors';
 export function cleanDirectory(dirname) {
     const rootDir = dirname;
     const _cleanDirectory = (targetDir) => {
@@ -12,7 +12,7 @@ export function cleanDirectory(dirname) {
             if (fs.statSync(absolutePath).isDirectory()) {
                 _cleanDirectory(absolutePath);
                 if (!fs.readdirSync(absolutePath).length) {
-                    this.emit('verbose', chalk.cyan(`Removing directory ${path.relative(absolutePath, rootDir)}`));
+                    this.emit('verbose', colors.cyan(`Removing directory ${path.relative(absolutePath, rootDir)}`));
                     fs.rmdirSync(absolutePath);
                 }
                 continue;
@@ -20,7 +20,7 @@ export function cleanDirectory(dirname) {
             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)}`));
+                    this.emit('verbose', colors.cyan(`Removing file ${path.relative(absolutePath, rootDir)}`));
                     fs.unlinkSync(absolutePath);
                 }
             }