@opra/cli 1.22.0 → 1.22.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/cli",
-  "version": "1.22.0",
+  "version": "1.22.2",
   "description": "Opra CLI tools",
   "author": "Panates",
   "license": "MIT",
@@ -14,8 +14,8 @@
     "tslib": "^2.8.1"
   },
   "peerDependencies": {
-    "@opra/client": "^1.22.0",
-    "@opra/common": "^1.22.0"
+    "@opra/client": "^1.22.2",
+    "@opra/common": "^1.22.2"
   },
   "type": "module",
   "module": "./index.js",

package/ts-generator/generators/generate-data-type.d.ts

@@ -1,4 +1,5 @@
 import { ArrayType, ComplexType, DataType, EnumType, MappedType, MixinType, SimpleType, UnionType } from '@opra/common';
+import { CodeBlock } from '../../code-block.js';
 import { TsFile } from '../ts-file.js';
 import type { TsGenerator } from '../ts-generator';
 type Intent = 'root' | 'extends' | 'typeDef';
@@ -17,33 +18,33 @@ export declare function generateDataType(this: TsGenerator, dataType: DataType,
 /**
  *
  */
-export declare function _generateTypeCode(this: TsGenerator, currentFile: TsFile, dataType: DataType, intent?: Intent): Promise<string>;
+export declare function _generateTypeCode(this: TsGenerator, currentFile: TsFile, dataType: DataType, codeBlock: CodeBlock, intent?: Intent): Promise<void>;
 /**
  *
  */
-export declare function _generateArrayTypeCode(this: TsGenerator, currentFile: TsFile, dataType: ArrayType, intent?: Intent): Promise<string>;
+export declare function _generateArrayTypeCode(this: TsGenerator, currentFile: TsFile, dataType: ArrayType, codeBlock: CodeBlock, intent?: Intent): Promise<void>;
 /**
  *
  */
-export declare function _generateComplexTypeCode(this: TsGenerator, currentFile: TsFile, dataType: ComplexType, intent?: Intent): Promise<string>;
+export declare function _generateComplexTypeCode(this: TsGenerator, currentFile: TsFile, dataType: ComplexType, codeBlock: CodeBlock, intent?: Intent): Promise<void>;
 /**
  *
  */
-export declare function _generateEnumTypeCode(this: TsGenerator, currentFile: TsFile, dataType: EnumType, intent?: Intent): Promise<string>;
+export declare function _generateEnumTypeCode(this: TsGenerator, currentFile: TsFile, dataType: EnumType, codeBlock: CodeBlock, intent?: Intent): Promise<void>;
 /**
  *
  */
-export declare function _generateMappedTypeCode(this: TsGenerator, currentFile: TsFile, dataType: MappedType, intent?: Intent): Promise<string>;
+export declare function _generateMappedTypeCode(this: TsGenerator, currentFile: TsFile, dataType: MappedType, codeBlock: CodeBlock, intent?: Intent): Promise<void>;
 /**
  *
  */
-export declare function _generateMixinTypeCode(this: TsGenerator, currentFile: TsFile, dataType: MixinType, intent?: Intent): Promise<string>;
+export declare function _generateMixinTypeCode(this: TsGenerator, currentFile: TsFile, dataType: MixinType, codeBlock: CodeBlock, intent?: Intent): Promise<void>;
 /**
  *
  */
-export declare function _generateSimpleTypeCode(this: TsGenerator, currentFile: TsFile, dataType: SimpleType, intent?: Intent): Promise<string>;
+export declare function _generateSimpleTypeCode(this: TsGenerator, currentFile: TsFile, dataType: SimpleType, codeBlock: CodeBlock, intent?: Intent): Promise<void>;
 /**
  *
  */
-export declare function _generateUnionTypeCode(this: TsGenerator, currentFile: TsFile, dataType: UnionType, intent?: Intent): Promise<string>;
+export declare function _generateUnionTypeCode(this: TsGenerator, currentFile: TsFile, dataType: UnionType, codeBlock: CodeBlock, intent?: Intent): Promise<void>;
 export {};

package/ts-generator/generators/generate-data-type.js

@@ -46,13 +46,13 @@ export async function generateDataType(dataType, intent, currentFile) {
             const indexTs = this.addFile('/index.ts', true);
             indexTs.addExport(typesIndexTs.filename, undefined, this._typesNamespace);
             const codeBlock = (file.code['type_' + typeName] = new CodeBlock());
-            codeBlock.head = `/**\n * ${wrapJSDocString(dataType.description || '')}\n *`;
-            codeBlock.head += `
- * @url ${path.posix.join(doc.url || this.serviceUrl, '$schema', '#types/' + typeName)}
- */
-export `;
-            codeBlock.typeDef =
-                (await this._generateTypeCode(file, dataType, 'root')) + '\n\n';
+            codeBlock.header_start = `/**\n`;
+            codeBlock.header = ` * ${wrapJSDocString(dataType.description || '')}\n`;
+            codeBlock.header += ` * @url ${path.posix.join(doc.url || this.serviceUrl, '$schema', '#types/' + typeName)}\n`;
+            codeBlock.header_end = `*/\n`;
+            codeBlock.type_start = `export `;
+            await this._generateTypeCode(file, dataType, codeBlock, 'root');
+            codeBlock.type_end = '\n\n';
             typesIndexTs.addExport(file.filename);
             if (currentFile)
                 currentFile.addImport(file.filename, [typeName]);
@@ -60,8 +60,9 @@ export `;
         }
         if (!currentFile)
             throw new TypeError(`You must provide currentFile to generate data type`);
-        const code = await this._generateTypeCode(currentFile, dataType, intent);
-        return { kind: 'embedded', code };
+        const codeBlock = new CodeBlock();
+        await this._generateTypeCode(currentFile, dataType, codeBlock, intent);
+        return { kind: 'embedded', code: codeBlock.toString() };
     }
     catch (e) {
         e.message = `(${dataType.name}) ` + e.message;
@@ -71,30 +72,32 @@ export `;
 /**
  *
  */
-export async function _generateTypeCode(currentFile, dataType, intent) {
+export async function _generateTypeCode(currentFile, dataType, codeBlock, intent) {
     if (intent === 'root' && !dataType.name) {
         throw new TypeError(`Name required to generate data type code to root intent`);
     }
     if (dataType instanceof ArrayType) {
-        return await this._generateArrayTypeCode(currentFile, dataType, intent);
+        await this._generateArrayTypeCode(currentFile, dataType, codeBlock, intent);
+        return;
     }
     if (dataType instanceof ComplexType) {
-        return await this._generateComplexTypeCode(currentFile, dataType, intent);
+        await this._generateComplexTypeCode(currentFile, dataType, codeBlock, intent);
+        return;
     }
     if (dataType instanceof EnumType) {
-        return await this._generateEnumTypeCode(currentFile, dataType, intent);
+        return await this._generateEnumTypeCode(currentFile, dataType, codeBlock, intent);
     }
     if (dataType instanceof MappedType) {
-        return await this._generateMappedTypeCode(currentFile, dataType, intent);
+        return await this._generateMappedTypeCode(currentFile, dataType, codeBlock, intent);
     }
     if (dataType instanceof MixinType) {
-        return await this._generateMixinTypeCode(currentFile, dataType, intent);
+        return await this._generateMixinTypeCode(currentFile, dataType, codeBlock, intent);
     }
     if (dataType instanceof SimpleType) {
-        return await this._generateSimpleTypeCode(currentFile, dataType, intent);
+        return await this._generateSimpleTypeCode(currentFile, dataType, codeBlock, intent);
     }
     if (dataType instanceof UnionType) {
-        return await this._generateUnionTypeCode(currentFile, dataType, intent);
+        return await this._generateUnionTypeCode(currentFile, dataType, codeBlock, intent);
     }
     /* istanbul ignore next */
     throw new TypeError(`${dataType.kind} data types can not be directly exported`);
@@ -102,7 +105,7 @@ export async function _generateTypeCode(currentFile, dataType, intent) {
 /**
  *
  */
-export async function _generateArrayTypeCode(currentFile, dataType, intent) {
+export async function _generateArrayTypeCode(currentFile, dataType, codeBlock, intent) {
     if (intent === 'extends')
         throw new TypeError('Array types can not be extended');
     let out = '';
@@ -115,14 +118,13 @@ export async function _generateArrayTypeCode(currentFile, dataType, intent) {
     }
     else
         out = x.typeName;
-    if (intent === 'root')
-        return `type ${dataType.name} = ${out}[]`;
-    return `${out}[]`;
+    codeBlock.typeDef =
+        intent === 'root' ? `type ${dataType.name} = ${out}[]` : `${out}[]`;
 }
 /**
  *
  */
-export async function _generateComplexTypeCode(currentFile, dataType, intent) {
+export async function _generateComplexTypeCode(currentFile, dataType, codeBlock, intent) {
     let out = intent === 'root' ? `interface ${dataType.name} ` : '';
     const ownFields = [...dataType.fields('*')].filter(f => f.origin === dataType);
     if (dataType.base) {
@@ -135,39 +137,56 @@ export async function _generateComplexTypeCode(currentFile, dataType, intent) {
             out += `extends ${baseDef} `;
         else {
             out += baseDef;
-            if (!ownFields.length)
-                return out;
+            if (!ownFields.length) {
+                codeBlock.typeDef = out;
+                return;
+            }
             out += ' & ';
         }
     }
     out += '{\n\t';
     let i = 0;
     for (const field of ownFields) {
+        const fieldCode = new CodeBlock();
         if (i++)
             out += '\n';
         // Print JSDoc
-        out += `/**\n * ${field.description || ''}\n`;
+        fieldCode.header_start = '/**\n';
+        fieldCode.header = '';
+        if (field.description)
+            fieldCode.header += ` * ${wrapJSDocString(field.description)}\n`;
+        fieldCode.header_attr = '';
         if (field.default)
-            out += ` * @default ` + field.default + '\n';
+            fieldCode.header_attr += ` * @default ` + field.default + '\n';
         // if (field.format)
         //   jsDoc += ` * @format ` + field.format + '\n';
         if (field.exclusive)
-            out += ` * @exclusive\n`;
+            fieldCode.header_attr += ` * @exclusive\n`;
         if (field.readonly)
-            out += ` * @readonly\n`;
+            fieldCode.header_attr += ` * @readonly\n`;
         if (field.writeonly)
-            out += ` * @writeonly\n`;
+            fieldCode.header_attr += ` * @writeonly\n`;
         if (field.deprecated) {
-            out +=
+            fieldCode.header_attr +=
                 ` * @deprecated ` +
                     (typeof field.deprecated === 'string' ? field.deprecated : '') +
                     '\n';
         }
-        out += ' */\n';
+        fieldCode.header_end = ' */\n';
+        if (field.type instanceof SimpleType && field.type.properties) {
+            let s = '';
+            for (const [k, v] of Object.entries(field.type.properties)) {
+                if (v != null)
+                    s += ` *   ${k}: ${v}\n`;
+            }
+            if (s)
+                fieldCode.header += ' * Attributes:\n' + s;
+        }
         // Print field name
+        fieldCode.def = '';
         if (field.readonly)
-            out += 'readonly ';
-        out += `${field.name}${field.required ? '' : '?'}: `;
+            fieldCode.def += 'readonly ';
+        fieldCode.def += `${field.name}${field.required ? '' : '?'}: `;
         let typ = '';
         if (field.fixed) {
             const t = typeof field.fixed;
@@ -178,19 +197,22 @@ export async function _generateComplexTypeCode(currentFile, dataType, intent) {
             typ = x.kind === 'embedded' ? x.code : x.typeName;
         }
         if (field.isArray && !(field.type instanceof ArrayType)) {
-            out += /[a-zA-Z]\w*/.test(typ) ? typ + '[];\n' : '(' + typ + ')[];\n';
+            fieldCode.def += /[a-zA-Z]\w*/.test(typ)
+                ? typ + '[];\n'
+                : '(' + typ + ')[];\n';
         }
         else
-            out += typ + ';\n';
+            fieldCode.def += typ + ';\n';
+        out += fieldCode.toString();
     }
     if (dataType.additionalFields)
         out += '[key: string]: any;\n';
-    return out + '\b}';
+    codeBlock.typeDef = out + '\b}';
 }
 /**
  *
  */
-export async function _generateEnumTypeCode(currentFile, dataType, intent) {
+export async function _generateEnumTypeCode(currentFile, dataType, codeBlock, intent) {
     if (intent === 'root') {
         let out = `enum ${dataType.name} {\n\t`;
         for (const [value, info] of Object.entries(dataType.attributes)) {
@@ -207,18 +229,20 @@ export async function _generateEnumTypeCode(currentFile, dataType, intent) {
                         : "'" + String(value).replace("'", "\\'") + "'");
             out += ',\n\n';
         }
-        return out + '\b}';
+        codeBlock.typeDef = out + '\b}';
+        return;
     }
-    return ('(' +
-        Object.keys(dataType.attributes)
-            .map(t => `'${t}'`)
-            .join(' | ') +
-        ')');
+    codeBlock.typeDef =
+        '(' +
+            Object.keys(dataType.attributes)
+                .map(t => `'${t}'`)
+                .join(' | ') +
+            ')';
 }
 /**
  *
  */
-export async function _generateMappedTypeCode(currentFile, dataType, intent) {
+export async function _generateMappedTypeCode(currentFile, dataType, codeBlock, intent) {
     let out = intent === 'root' ? `type ${dataType.name} = ` : '';
     const base = await this.generateDataType(dataType.base, 'typeDef', currentFile);
     const typeDef = base.kind === 'embedded' ? base.code : base.typeName;
@@ -232,8 +256,10 @@ export async function _generateMappedTypeCode(currentFile, dataType, intent) {
         (Array.isArray(dataType.required) && dataType.required.length > 0)
         ? dataType.required
         : undefined;
-    if (!(pick || omit || partial || required))
-        return typeDef;
+    if (!(pick || omit || partial || required)) {
+        codeBlock.typeDef = typeDef;
+        return;
+    }
     if (partial === true)
         out += 'Partial<';
     else if (partial) {
@@ -271,12 +297,12 @@ export async function _generateMappedTypeCode(currentFile, dataType, intent) {
         }
         out += '>';
     }
-    return out;
+    codeBlock.typeDef = out;
 }
 /**
  *
  */
-export async function _generateMixinTypeCode(currentFile, dataType, intent) {
+export async function _generateMixinTypeCode(currentFile, dataType, codeBlock, intent) {
     const outArray = [];
     for (const t of dataType.types) {
         const x = await this.generateDataType(t, 'typeDef', currentFile);
@@ -288,25 +314,37 @@ export async function _generateMixinTypeCode(currentFile, dataType, intent) {
         else
             outArray.push(x.typeName);
     }
-    if (intent === 'root')
-        return `type ${dataType.name} = ${outArray.join(' & ')}`;
-    if (intent === 'extends')
-        return outArray.join(', ');
-    return outArray.join(' & ');
+    if (intent === 'root') {
+        codeBlock.typeDef = `type ${dataType.name} = ${outArray.join(' & ')}`;
+    }
+    else if (intent === 'extends') {
+        codeBlock.typeDef = outArray.join(', ');
+    }
+    else
+        codeBlock.typeDef = outArray.join(' & ');
 }
 /**
  *
  */
-export async function _generateSimpleTypeCode(currentFile, dataType, intent) {
+export async function _generateSimpleTypeCode(currentFile, dataType, codeBlock, intent) {
+    let s = '';
+    if (dataType.properties) {
+        for (const [k, v] of Object.entries(dataType.properties)) {
+            if (v != null)
+                s += ` *   ${k}: ${v}\n`;
+        }
+        if (s)
+            codeBlock.header += ' * Attributes:\n' + s;
+    }
     let out = intent === 'root' ? `type ${dataType.name} = ` : '';
     const nameMapping = dataType.nameMappings.js || 'any';
     out += nameMapping === 'Date' ? 'string' : nameMapping;
-    return intent === 'root' ? out + ';' : out;
+    codeBlock.typeDef = intent === 'root' ? out + ';' : out;
 }
 /**
  *
  */
-export async function _generateUnionTypeCode(currentFile, dataType, intent) {
+export async function _generateUnionTypeCode(currentFile, dataType, codeBlock, intent) {
     if (intent === 'extends')
         throw new TypeError('Union types can not be extended');
     const outArray = [];
@@ -321,6 +359,7 @@ export async function _generateUnionTypeCode(currentFile, dataType, intent) {
             outArray.push(x.typeName);
     }
     if (intent === 'root')
-        return `type ${dataType.name} = ${outArray.join(' | ')}`;
-    return outArray.join(' | ');
+        codeBlock.typeDef = `type ${dataType.name} = ${outArray.join(' | ')}`;
+    else
+        codeBlock.typeDef = outArray.join(' | ');
 }

package/ts-generator/ts-generator.js

@@ -41,6 +41,7 @@ export class TsGenerator extends EventEmitter {
             referenceNamespaces: init.referenceNamespaces,
         };
         this._documentsMap = new Map();
+        this._documentRoot = './';
         this._filesMap = new WeakMap();
         this.on('log', (message, ...args) => init.logger?.log?.(message, ...args));
         this.on('error', (message, ...args) => init.logger?.error?.(message, ...args));