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

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

@@ -1,4 +1,4 @@
-import path from 'path';
+import path from 'node:path';
 import flattenText from 'putil-flattentext';
 import { CodeBlock } from '../code-block.js';
 export class TsFile {
@@ -31,7 +31,7 @@ export class TsFile {
                 imp.items.push(x);
         });
     }
-    addExport(filename, types) {
+    addExport(filename, types, namespace) {
         if (isLocalFile(filename)) {
             filename = path.relative(this.dirname, path.resolve(this.dirname, filename));
             if (!filename.startsWith('.'))
@@ -41,10 +41,11 @@ export 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) {
@@ -72,18 +73,23 @@ export 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' +
             flattenText(String(this.code)));
     }
 }

package/esm/ts-generator/ts-generator.js

@@ -2,13 +2,13 @@ import { EventEmitter } from 'node:events';
 import fs from 'node:fs';
 import path from 'node:path';
 import process from 'node:process';
-import chalk from 'chalk';
+import colors from 'ansi-colors';
 import { FileWriter } from '../file-writer.js';
-import { cleanDirectory } from './processors/clean-directory.js';
-import { generateComplexTypeDefinition, generateEnumTypeDefinition, generateMappedTypeDefinition, generateMixinTypeDefinition, generateSimpleTypeDefinition, processDataType, resolveTypeNameOrDef, } from './processors/process-data-types.js';
-import { processDocument } from './processors/process-document.js';
-import { processHttpApi } from './processors/process-http-api.js';
-import { processHttpController } from './processors/process-http-controller.js';
+import { cleanDirectory } from './generators/clean-directory.js';
+import { _generateComplexTypeCode, _generateEnumTypeCode, _generateMappedTypeCode, _generateMixinTypeCode, _generateSimpleTypeCode, _generateTypeCode, generateDataType, } from './generators/generate-data-type.js';
+import { generateDocument } from './generators/generate-document.js';
+import { generateHttpApi } from './generators/generate-http-api.js';
+import { generateHttpController } from './generators/generate-http-controller.js';
 import { TsFile } from './ts-file.js';
 /**
  * @class TsGenerator
@@ -20,14 +20,14 @@ export class TsGenerator extends EventEmitter {
      */
     constructor(init) {
         super();
-        this._started = false;
         this._files = {};
+        this._started = false;
         this.serviceUrl = init.serviceUrl;
         this.cwd = init.cwd || process.cwd();
         this.outDir = init.outDir ? path.resolve(this.cwd, init.outDir) : this.cwd;
         this.fileHeader = init.fileHeader || '';
         this.writer = init.writer || new 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));
@@ -42,10 +42,10 @@ export class TsGenerator extends EventEmitter {
         this.emit('start');
         try {
             this._started = true;
-            this.emit('log', chalk.cyan('Removing old files..'));
+            this.emit('log', colors.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)) {
@@ -90,14 +90,14 @@ export class TsGenerator extends EventEmitter {
 }
 (() => {
     TsGenerator.prototype.cleanDirectory = cleanDirectory;
-    TsGenerator.prototype.processDocument = processDocument;
-    TsGenerator.prototype.processDataType = processDataType;
-    TsGenerator.prototype.processHttpApi = processHttpApi;
-    TsGenerator.prototype.processHttpController = processHttpController;
-    TsGenerator.prototype.generateEnumTypeDefinition = generateEnumTypeDefinition;
-    TsGenerator.prototype.generateComplexTypeDefinition = generateComplexTypeDefinition;
-    TsGenerator.prototype.generateSimpleTypeDefinition = generateSimpleTypeDefinition;
-    TsGenerator.prototype.generateMappedTypeDefinition = generateMappedTypeDefinition;
-    TsGenerator.prototype.generateMixinTypeDefinition = generateMixinTypeDefinition;
-    TsGenerator.prototype.resolveTypeNameOrDef = resolveTypeNameOrDef;
+    TsGenerator.prototype.generateDocument = generateDocument;
+    TsGenerator.prototype.generateDataType = generateDataType;
+    TsGenerator.prototype._generateTypeCode = _generateTypeCode;
+    TsGenerator.prototype._generateEnumTypeCode = _generateEnumTypeCode;
+    TsGenerator.prototype._generateComplexTypeCode = _generateComplexTypeCode;
+    TsGenerator.prototype._generateSimpleTypeCode = _generateSimpleTypeCode;
+    TsGenerator.prototype._generateMappedTypeCode = _generateMappedTypeCode;
+    TsGenerator.prototype._generateMixinTypeCode = _generateMixinTypeCode;
+    TsGenerator.prototype.generateHttpApi = generateHttpApi;
+    TsGenerator.prototype.generateHttpController = generateHttpController;
 })();

package/package.json

@@ -1,51 +1,46 @@
 {
   "name": "@opra/cli",
-  "version": "1.0.0-alpha.8",
+  "version": "1.0.0-beta.1",
   "description": "Opra CLI tools",
   "author": "Panates",
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/panates/opra.git",
-    "directory": "packages/client"
-  },
-  "scripts": {
-    "compile": "tsc",
-    "prebuild": "npm run check && npm run lint && npm run clean",
-    "build": "npm run build:cjs && npm run build:esm",
-    "build:cjs": "tsc -b tsconfig-build-cjs.json",
-    "build:esm": "tsc -b tsconfig-build-esm.json",
-    "postbuild": "npm run copy:files && npm run copy:bin",
-    "copy:files": "cp README.md package.json ../../LICENSE ../../build/cli && cp ../../package.cjs.json ../../build/cli/cjs/package.json",
-    "copy:bin": "cp -R bin ../../build/cli/bin",
-    "lint": "eslint . --max-warnings=0",
-    "lint:fix": "eslint . --max-warnings=0 --fix",
-    "format": "prettier . --write --log-level=warn",
-    "check": "madge --circular src/**",
-    "test": "jest --passWithNoTests",
-    "cover": "jest --passWithNoTests --collect-coverage",
-    "clean": "npm run clean:src && npm run clean:test && npm run clean:dist && npm run clean:cover",
-    "clean:src": "ts-cleanup -s src --all",
-    "clean:test": "ts-cleanup -s test --all",
-    "clean:dist": "rimraf ../../build/client",
-    "clean:cover": "rimraf ../../coverage/client"
-  },
   "dependencies": {
-    "@opra/client": "^1.0.0-alpha.8",
-    "@opra/common": "^1.0.0-alpha.8",
-    "chalk": "^5.3.0",
+    "@browsery/type-is": "^1.6.18-r5",
+    "@opra/client": "^1.0.0-beta.1",
+    "@opra/common": "^1.0.0-beta.1",
+    "ansi-colors": "^4.1.3",
     "commander": "^12.0.0",
     "js-string-escape": "^1.0.1",
     "putil-flattentext": "^2.1.1",
-    "putil-varhelpers": "^1.6.5"
+    "putil-varhelpers": "^1.6.5",
+    "tslib": "^2.7.0"
   },
   "type": "module",
-  "module": "./esm/index.js",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./types/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "require": {
+        "types": "./types/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "default": "./esm/index.js"
+    },
+    "./package.json": "./package.json"
+  },
   "main": "./cjs/index.js",
+  "module": "./esm/index.js",
   "types": "./types/index.d.ts",
   "bin": {
     "oprimp": "bin/oprimp.mjs"
   },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/panates/opra.git",
+    "directory": "packages/client"
+  },
   "engines": {
     "node": ">=18.0",
     "npm": ">=7.0.0"
@@ -64,4 +59,4 @@
     "tool",
     "oprimp"
   ]
-}
+}

package/types/file-writer.d.ts

@@ -1,4 +1,4 @@
-import { IFileWriter } from './interfaces/file-writer.interface.js';
+import type { IFileWriter } from './interfaces/file-writer.interface.js';
 export declare class FileWriter implements IFileWriter {
     writeFile(filename: string, contents: string): void;
 }

package/types/index.d.cts

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

package/types/interfaces/service-generation-context.interface.d.ts

@@ -1,6 +1,6 @@
 import { ApiDocument } from '@opra/common';
-import { IFileWriter } from './file-writer.interface.js';
-import { ILogger } from './logger.interface.js';
+import type { IFileWriter } from './file-writer.interface.js';
+import type { ILogger } from './logger.interface.js';
 export interface ServiceGenerationContext {
     serviceUrl: string;
     document: ApiDocument;

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

@@ -0,0 +1,41 @@
+import { ComplexType, DataType, EnumType, MappedType, MixinType, SimpleType } from '@opra/common';
+import { TsFile } from '../ts-file.js';
+import type { TsGenerator } from '../ts-generator';
+type Intent = 'root' | 'extends' | 'typeDef';
+export type generateDataTypeResult = {
+    kind: 'internal';
+    typeName: string;
+} | {
+    kind: 'named';
+    typeName: string;
+    file: TsFile;
+} | {
+    kind: 'embedded';
+    code: string;
+};
+export declare function generateDataType(this: TsGenerator, dataType: DataType, intent: Intent, currentFile?: TsFile): Promise<generateDataTypeResult>;
+/**
+ *
+ */
+export declare function _generateTypeCode(this: TsGenerator, currentFile: TsFile, dataType: DataType, intent?: Intent): Promise<string>;
+/**
+ *
+ */
+export declare function _generateEnumTypeCode(this: TsGenerator, currentFile: TsFile, dataType: EnumType, intent?: Intent): Promise<string>;
+/**
+ *
+ */
+export declare function _generateComplexTypeCode(this: TsGenerator, currentFile: TsFile, dataType: ComplexType, intent?: Intent): Promise<string>;
+/**
+ *
+ */
+export declare function _generateSimpleTypeCode(this: TsGenerator, currentFile: TsFile, dataType: SimpleType, intent?: Intent): Promise<string>;
+/**
+ *
+ */
+export declare function _generateMixinTypeCode(this: TsGenerator, currentFile: TsFile, dataType: MixinType, intent?: Intent): Promise<string>;
+/**
+ *
+ */
+export declare function _generateMappedTypeCode(this: TsGenerator, currentFile: TsFile, dataType: MappedType, intent?: Intent): Promise<string>;
+export {};

package/types/ts-generator/{processors/process-document.d.ts → generators/generate-document.d.ts}

@@ -1,6 +1,6 @@
 import { ApiDocument } from '@opra/common';
 import type { TsGenerator } from '../ts-generator';
-export declare function processDocument(this: TsGenerator, document?: string | ApiDocument, options?: {
+export declare function generateDocument(this: TsGenerator, document?: string | ApiDocument, options?: {
     typesOnly?: boolean;
 }): Promise<{
     document: ApiDocument;

package/types/ts-generator/generators/generate-http-api.d.ts

@@ -0,0 +1,3 @@
+import { HttpApi } from '@opra/common';
+import type { TsGenerator } from '../ts-generator';
+export declare function generateHttpApi(this: TsGenerator, api: HttpApi): Promise<import("../ts-file.js").TsFile>;

package/types/ts-generator/generators/generate-http-controller.d.ts

@@ -0,0 +1,3 @@
+import { HttpController } from '@opra/common';
+import type { TsGenerator } from '../ts-generator';
+export declare function generateHttpController(this: TsGenerator, controller: HttpController): Promise<import("../ts-file.js").TsFile>;

package/types/ts-generator/ts-file.d.ts

@@ -6,12 +6,16 @@ export declare class TsFile {
         items: string[];
         typeImport?: boolean;
     }>;
-    exportFiles: Record<string, string[]>;
+    exportFiles: Record<string, {
+        filename: string;
+        items: string[];
+        namespace?: string;
+    }>;
     exportTypes: string[];
     code: CodeBlock;
     constructor(filename: string);
     addImport(filename: string, items?: string[], typeImport?: boolean): void;
-    addExport(filename: string, types?: string[]): void;
+    addExport(filename: string, types?: string[], namespace?: string): void;
     generate(options?: {
         importExt?: boolean;
     }): string;

package/types/ts-generator/ts-generator.d.ts

@@ -1,13 +1,12 @@
-/// <reference types="node" />
 import { EventEmitter } from 'node:events';
 import { ApiDocument } from '@opra/common';
-import { IFileWriter } from '../interfaces/file-writer.interface.js';
-import { ILogger } from '../interfaces/logger.interface.js';
-import { cleanDirectory } from './processors/clean-directory.js';
-import { generateComplexTypeDefinition, generateEnumTypeDefinition, generateMappedTypeDefinition, generateMixinTypeDefinition, generateSimpleTypeDefinition, processDataType, resolveTypeNameOrDef } from './processors/process-data-types.js';
-import { processDocument } from './processors/process-document.js';
-import { processHttpApi } from './processors/process-http-api.js';
-import { processHttpController } from './processors/process-http-controller.js';
+import type { IFileWriter } from '../interfaces/file-writer.interface.js';
+import type { ILogger } from '../interfaces/logger.interface.js';
+import { cleanDirectory } from './generators/clean-directory.js';
+import { _generateComplexTypeCode, _generateEnumTypeCode, _generateMappedTypeCode, _generateMixinTypeCode, _generateSimpleTypeCode, _generateTypeCode, generateDataType } from './generators/generate-data-type.js';
+import { generateDocument } from './generators/generate-document.js';
+import { generateHttpApi } from './generators/generate-http-api.js';
+import { generateHttpController } from './generators/generate-http-controller.js';
 import { TsFile } from './ts-file.js';
 /**
  * @namespace TsGenerator
@@ -21,6 +20,7 @@ export declare namespace TsGenerator {
         writer?: IFileWriter;
         fileHeader?: string;
         importExt?: boolean;
+        referenceNamespaces?: boolean;
     }
 }
 /**
@@ -28,23 +28,24 @@ export declare namespace TsGenerator {
  */
 export declare class TsGenerator extends EventEmitter {
     protected cleanDirectory: typeof cleanDirectory;
-    protected processDocument: typeof processDocument;
-    protected processDataType: typeof processDataType;
-    protected processHttpApi: typeof processHttpApi;
-    protected processHttpController: typeof processHttpController;
-    protected generateEnumTypeDefinition: typeof generateEnumTypeDefinition;
-    protected generateComplexTypeDefinition: typeof generateComplexTypeDefinition;
-    protected generateSimpleTypeDefinition: typeof generateSimpleTypeDefinition;
-    protected generateMappedTypeDefinition: typeof generateMappedTypeDefinition;
-    protected generateMixinTypeDefinition: typeof generateMixinTypeDefinition;
-    protected resolveTypeNameOrDef: typeof resolveTypeNameOrDef;
-    protected _started: boolean;
-    protected _document?: ApiDocument;
+    protected generateDocument: typeof generateDocument;
+    protected generateDataType: typeof generateDataType;
+    protected _generateTypeCode: typeof _generateTypeCode;
+    protected _generateEnumTypeCode: typeof _generateEnumTypeCode;
+    protected _generateComplexTypeCode: typeof _generateComplexTypeCode;
+    protected _generateSimpleTypeCode: typeof _generateSimpleTypeCode;
+    protected _generateMappedTypeCode: typeof _generateMappedTypeCode;
+    protected _generateMixinTypeCode: typeof _generateMixinTypeCode;
+    protected generateHttpApi: typeof generateHttpApi;
+    protected generateHttpController: typeof generateHttpController;
     protected _documentRoot: string;
     protected _typesRoot: string;
+    protected _typesNamespace: string;
     protected _apiPath: string;
     protected _fileHeaderDocInfo: string;
     protected _files: Record<string, TsFile>;
+    protected _started: boolean;
+    protected _document?: ApiDocument;
     protected _documentsMap: Map<string, {
         document: ApiDocument;
         generator: TsGenerator;
@@ -56,6 +57,7 @@ export declare class TsGenerator extends EventEmitter {
     readonly writer: IFileWriter;
     readonly options: {
         importExt: boolean;
+        referenceNamespaces?: boolean;
     };
     fileHeader: string;
     /**

package/bin/bin/oprimp.mjs

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-/* eslint-disable import-x/no-unresolved */
-import '../esm/oprimp-cli.js';

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

@@ -1,262 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveTypeNameOrDef = exports.generateMappedTypeDefinition = exports.generateMixinTypeDefinition = exports.generateSimpleTypeDefinition = exports.generateComplexTypeDefinition = exports.generateEnumTypeDefinition = 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) {
-    const doc = dataType.node.getDocument();
-    if (doc.id !== this._document?.id) {
-        const { generator } = await this.processDocument(doc);
-        return await generator.processDataType(dataType);
-    }
-    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)
-            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 += `
- * @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');
-    }
-    else if (dataType instanceof common_1.SimpleType) {
-        codeBlock.typeDef = await this.generateSimpleTypeDefinition(dataType, 'scope');
-    }
-    else if (dataType instanceof common_1.MappedType) {
-        codeBlock.typeDef = await this.generateMappedTypeDefinition(dataType, file, 'scope');
-    }
-    else if (dataType instanceof common_1.MixinType) {
-        codeBlock.typeDef = await this.generateMixinTypeDefinition(dataType, file, 'scope');
-    }
-    else
-        throw new TypeError(`${dataType.kind} data type (${typeName}) can not be directly exported`);
-    typesIndexTs.addExport(file.filename);
-    return file;
-}
-exports.processDataType = processDataType;
-/**
- *
- */
-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';
-    }
-    return out + '\b}';
-}
-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} ` : '';
-    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')
-            out += `extends ${baseDef} `;
-        else {
-            out += baseDef;
-            if (!ownFields.length)
-                return out;
-            out += ' & ';
-        }
-    }
-    out += '{\n\t';
-    let i = 0;
-    for (const field of ownFields) {
-        if (i++)
-            out += '\n';
-        // Print JSDoc
-        out += `/**\n * ${field.description || ''}\n`;
-        if (field.default)
-            out += ` * @default ` + field.default + '\n';
-        // if (field.format)
-        //   jsDoc += ` * @format ` + field.format + '\n';
-        if (field.exclusive)
-            out += ` * @exclusive\n`;
-        if (field.readonly)
-            out += ` * @readonly\n`;
-        if (field.writeonly)
-            out += ` * @writeonly\n`;
-        if (field.deprecated) {
-            out += ` * @deprecated ` + (typeof field.deprecated === 'string' ? field.deprecated : '') + '\n';
-        }
-        out += ' */\n';
-        // Print field name
-        if (field.readonly)
-            out += 'readonly ';
-        out += `${field.name}${field.required ? '' : '?'}: `;
-        if (field.fixed) {
-            const t = typeof field.fixed;
-            out += `${t === 'number' || t === 'boolean' || t === 'bigint' ? field.fixed : "'" + field.fixed + "'"}\n`;
-        }
-        else {
-            out += (await this.resolveTypeNameOrDef(field.type, file, 'field')) + `${field.isArray ? '[]' : ''};\n`;
-        }
-    }
-    if (dataType.additionalFields)
-        out += '[key: string]: any;\n';
-    return out + '\b}';
-}
-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} = ` : '';
-    out += dataType.nameMappings.js || 'any';
-    return intent === 'scope' ? 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' ? ', ' : ' & ');
-}
-exports.generateMixinTypeDefinition = generateMixinTypeDefinition;
-/**
- *
- */
-async function generateMappedTypeDefinition(dataType, file, intent) {
-    const typeDef = await this.resolveTypeNameOrDef(dataType.base, file, intent);
-    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)
-        ? dataType.partial
-        : undefined;
-    const required = dataType.required === true || (Array.isArray(dataType.required) && dataType.required.length > 0)
-        ? dataType.required
-        : 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']);
-    }
-    if (required === true)
-        out += 'Partial<';
-    else if (required) {
-        out += 'RequiredSome<';
-        file.addExport('ts-gems', ['RequiredSome']);
-    }
-    if (pick)
-        out += 'Pick<';
-    else if (omit)
-        out += 'Omit<';
-    out += typeDef;
-    if (omit || pick) {
-        out +=
-            ', ' +
-                (omit || pick)
-                    .filter(x => !!x)
-                    .map(x => `'${x}'`)
-                    .join(' | ') +
-                '>';
-    }
-    if (partial) {
-        if (Array.isArray(partial)) {
-            out +=
-                ', ' +
-                    partial
-                        .filter(x => !!x)
-                        .map(x => `'${x}'`)
-                        .join(' | ');
-        }
-        out += '>';
-    }
-    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;