@opra/cli 0.14.3 → 0.16.0

package/esm/api-exporter/process-resources.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processResources = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const common_1 = require("@opra/common");
+const string_utils_js_1 = require("../utils/string-utils.js");
+/**
+ *
+ * @param targetDir
+ */
+async function processResources(targetDir = '') {
+    this.logger.log(chalk_1.default.yellow('Processing resources'));
+    const { document } = this;
+    const serviceTs = this.addFile(node_path_1.default.join(targetDir, this.name + '.ts'));
+    serviceTs.addImportPackage('@opra/client', ['HttpServiceBase']);
+    const indexTs = this.addFile('/index.ts', true);
+    indexTs.addExportFile(serviceTs.filename);
+    serviceTs.content = `\nexport class ${this.name} extends HttpServiceBase {\n`;
+    for (const resource of document.resources.values()) {
+        serviceTs.content += `\n/**\n * ${(0, string_utils_js_1.wrapJSDocString)(resource.description || resource.name)}
+ * @url ${(0, common_1.joinPath)(this.client.serviceUrl, '$metadata#resources/' + resource.name)}
+ */`;
+        if (resource instanceof common_1.Collection) {
+            const typeName = resource.type.name || '';
+            serviceTs.addImportPackage('@opra/client', ['HttpCollectionNode']);
+            serviceTs.addImportFile('types/' + typeName, [typeName]);
+            const operations = Object.keys(resource.operations)
+                .map(x => `'${x}'`).join(' | ');
+            serviceTs.content += `
+  get ${resource.name}(): Pick<HttpCollectionNode<${typeName}>, ${operations}> {
+    return this.$client.collection('${resource.name}');
+  }\n`;
+        }
+        else if (resource instanceof common_1.Singleton) {
+            const typeName = resource.type.name || '';
+            serviceTs.addImportPackage('@opra/client', ['HttpSingletonNode']);
+            serviceTs.addImportFile('types/' + typeName, [typeName]);
+            const operations = Object.keys(resource.operations)
+                .map(x => `'${x}'`).join(' | ');
+            serviceTs.content += `
+  get ${resource.name}(): Pick<HttpSingletonNode<${typeName}>, ${operations}> {
+    return this.$client.singleton('${resource.name}');
+  }\n`;
+        }
+    }
+    serviceTs.content += '}';
+}
+exports.processResources = processResources;

package/esm/api-exporter/process-types.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMappedTypeDefinition = exports.generateUnionTypeDefinition = exports.generateEnumTypeDefinition = exports.generateSimpleTypeDefinition = exports.generateComplexTypeDefinition = exports.resolveTypeNameOrDef = exports.generateTypeFile = exports.processTypes = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const common_1 = require("@opra/common");
+const string_utils_js_1 = require("../utils/string-utils.js");
+const internalTypeNames = ['boolean', 'bigint', 'number', 'null', 'string'];
+/**
+ *
+ * @param targetDir
+ */
+async function processTypes(targetDir = '') {
+    this.logger.log(chalk_1.default.yellow('Processing types'));
+    const { document } = this;
+    const typesTs = this.addFile(node_path_1.default.join(targetDir, 'types.ts'));
+    for (const dataType of document.types.values()) {
+        const expFile = await this.generateTypeFile(dataType, targetDir);
+        typesTs.addExportFile(expFile.filename);
+    }
+}
+exports.processTypes = processTypes;
+/**
+ *
+ * @param dataType
+ * @param targetDir
+ */
+async function generateTypeFile(dataType, targetDir = '') {
+    const typeName = dataType.name;
+    if (!typeName)
+        throw new TypeError(`DataType has no name`);
+    let filePath;
+    if (dataType instanceof common_1.SimpleType)
+        filePath = '/simple-types.ts';
+    else if (dataType instanceof common_1.ComplexType)
+        filePath = `/types/${typeName}.ts`;
+    else if (dataType instanceof common_1.EnumType) {
+        filePath = `/enums/${typeName}.ts`;
+    }
+    else
+        throw new TypeError(`Unimplemented DataType (${dataType.kind})`);
+    const file = this.addFile(node_path_1.default.join(targetDir, filePath), true);
+    if (file.exportTypes.includes(typeName))
+        return file;
+    file.exportTypes.push(typeName);
+    const indexTs = this.addFile('/index.ts', true);
+    indexTs.addExportFile(file.filename);
+    file.content += `\n/**\n * ${(0, string_utils_js_1.wrapJSDocString)(dataType.description || typeName)}
+ * @type ${typeName}
+ * @kind ${dataType.kind}
+ * @url ${(0, common_1.joinPath)(this.client.serviceUrl, '$metadata#types/' + typeName)}
+ */\n`;
+    if (dataType instanceof common_1.SimpleType) {
+        file.content += `export type ${typeName} = ` + await this.generateSimpleTypeDefinition(file, dataType);
+    }
+    else if (dataType instanceof common_1.EnumType) {
+        file.content += `export enum ${typeName} ` + await this.generateEnumTypeDefinition(file, dataType);
+    }
+    else if (dataType instanceof common_1.ComplexType) {
+        file.content += `export class ${typeName} {
+  constructor(init?: Partial<I${typeName}>) {
+    if (init)
+     Object.assign(this, init);
+  }
+}
+
+export interface ${typeName} extends I${typeName} {
+}
+
+interface I${typeName} ${await this.generateComplexTypeDefinition(file, dataType, true)}
+`;
+    }
+    return file;
+}
+exports.generateTypeFile = generateTypeFile;
+/**
+ *
+ * @param file
+ * @param dataType
+ * @param forInterface
+ */
+async function resolveTypeNameOrDef(file, dataType, forInterface) {
+    if (dataType.name) {
+        if (internalTypeNames.includes(dataType.name))
+            return dataType.name;
+        const f = await this.generateTypeFile(dataType);
+        file.addImportFile(f.filename, [dataType.name]);
+        return dataType.name;
+    }
+    if (dataType instanceof common_1.ComplexType)
+        return this.generateComplexTypeDefinition(file, dataType, forInterface);
+    if (dataType instanceof common_1.SimpleType)
+        return this.generateSimpleTypeDefinition(file, dataType);
+    if (dataType instanceof common_1.EnumType)
+        return this.generateEnumTypeDefinition(file, dataType);
+    if (dataType instanceof common_1.UnionType)
+        return this.generateUnionTypeDefinition(file, dataType, forInterface);
+    if (dataType instanceof common_1.MappedType)
+        return this.generateMappedTypeDefinition(file, dataType, forInterface);
+    return 'xxx';
+}
+exports.resolveTypeNameOrDef = resolveTypeNameOrDef;
+/**
+ *
+ * @param file
+ * @param dataType
+ * @param forInterface
+ */
+async function generateComplexTypeDefinition(file, dataType, forInterface) {
+    let out = '';
+    if (dataType.base) {
+        const base = await this.resolveTypeNameOrDef(file, dataType.base, forInterface);
+        out += forInterface ? `extends ${base} ` : `${base} & `;
+    }
+    out += '{\n\n\t';
+    for (const field of dataType.own.fields.values()) {
+        // Print JSDoc
+        let jsDoc = '';
+        if (field.description)
+            jsDoc += ` * ${field.description}\n`;
+        if (field.default)
+            jsDoc += ` * @default ` + field.default + '\n';
+        if (field.format)
+            jsDoc += ` * @format ` + field.format + '\n';
+        if (field.exclusive)
+            jsDoc += ` * @exclusive\n`;
+        if (field.deprecated)
+            jsDoc += ` * @deprecated ` + (typeof field.deprecated === 'string' ? field.deprecated : '') + '\n';
+        if (jsDoc)
+            out += `/**\n${jsDoc}*/\n`;
+        // Print field name
+        out += `${field.name}${field.required ? '' : '?'}: `;
+        if (field.fixed)
+            out += `${field.fixed}`;
+        else {
+            out += await this.resolveTypeNameOrDef(file, field.type) +
+                `${field.isArray ? '[]' : ''};\n\n`;
+        }
+    }
+    if (dataType.additionalFields)
+        out += '[key: string]: any;\n';
+    return out + '\b}';
+}
+exports.generateComplexTypeDefinition = generateComplexTypeDefinition;
+/**
+ *
+ * @param file
+ * @param dataType
+ */
+async function generateSimpleTypeDefinition(file, dataType) {
+    if (dataType.ctor === Boolean)
+        return 'boolean';
+    if (dataType.ctor === String)
+        return 'string';
+    if (dataType.ctor === Number)
+        return 'number';
+    if (dataType.ctor === Date)
+        return 'Date';
+    if (dataType.extendsFrom('bigint'))
+        return 'Date';
+    if (dataType.extendsFrom('object'))
+        return 'object';
+    return 'any';
+}
+exports.generateSimpleTypeDefinition = generateSimpleTypeDefinition;
+/**
+ *
+ * @param file
+ * @param dataType
+ */
+async function generateEnumTypeDefinition(file, dataType) {
+    let out = '{\n\t';
+    for (const [k, v] of Object.entries(dataType.values)) {
+        // Print JSDoc
+        let jsDoc = '';
+        if (dataType.meanings[k])
+            jsDoc += ` * ${dataType.meanings[k]}\n`;
+        if (jsDoc)
+            out += `/**\n${jsDoc}*/\n`;
+        out += `${k}`;
+        if (v)
+            out += ' = ' + (typeof v === 'number' ? v : ('"' + ('' + v).replace('"', '\\"')) + '"');
+        out += ',\n\n';
+    }
+    return out + '\b}';
+}
+exports.generateEnumTypeDefinition = generateEnumTypeDefinition;
+/**
+ *
+ * @param file
+ * @param dataType
+ * @param forInterface
+ */
+async function generateUnionTypeDefinition(file, dataType, forInterface) {
+    // let out = '';
+    return (await Promise.all(dataType.types
+        .map(t => this.resolveTypeNameOrDef(file, t, forInterface)))).join(forInterface ? ', ' : ' & ');
+}
+exports.generateUnionTypeDefinition = generateUnionTypeDefinition;
+/**
+ *
+ * @param file
+ * @param dataType
+ * @param forInterface
+ */
+async function generateMappedTypeDefinition(file, dataType, forInterface) {
+    return (dataType.pick ? 'Pick<' : 'Omit<') +
+        (await this.resolveTypeNameOrDef(file, dataType.type, forInterface)) +
+        ', ' +
+        (dataType.pick || dataType.omit || [])
+            .map(x => `'${x}'`).join(' | ') +
+        '>';
+}
+exports.generateMappedTypeDefinition = generateMappedTypeDefinition;

package/esm/api-exporter/ts-file.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setExt = exports.relativePath = exports.TsFile = void 0;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const putil_flattentext_1 = tslib_1.__importDefault(require("putil-flattentext"));
+class TsFile {
+    constructor(filename) {
+        this.filename = filename;
+        this.importFiles = {};
+        this.exportFiles = {};
+        this.exportTypes = [];
+        this.header = '';
+        this.content = '';
+        this.addImportPackage = (name, types) => {
+            this.importFiles[name] = this.importFiles[name] || [];
+            types?.forEach(x => {
+                if (!this.importFiles[name].includes(x))
+                    this.importFiles[name].push(x);
+            });
+        };
+        this.addImportFile = (filename, types) => {
+            filename = path_1.default.resolve(this.dirname, filename);
+            this.importFiles[filename] = this.importFiles[filename] || [];
+            types?.forEach(x => {
+                if (!this.importFiles[filename].includes(x))
+                    this.importFiles[filename].push(x);
+            });
+        };
+        this.addExportFile = (filename, types) => {
+            filename = path_1.default.resolve(this.dirname, filename);
+            if (filename.endsWith('.ts') || filename.endsWith('.js'))
+                filename = setExt(filename, '');
+            this.exportFiles[filename] = this.exportFiles[filename] || [];
+            types?.forEach(x => {
+                if (!this.exportFiles[filename].includes(x))
+                    this.exportFiles[filename].push(x);
+            });
+        };
+        this.dirname = path_1.default.dirname(filename);
+    }
+    generate(options) {
+        const dirname = path_1.default.dirname(this.filename);
+        let output = '/* #!oprimp_auto_generated!# !! Do NOT remove this line */\n' +
+            (this.header ? (0, putil_flattentext_1.default)(this.header) + '\n\n' : '\n');
+        const importStr = Object.keys(this.importFiles)
+            .sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()))
+            .map(filename => {
+            const types = this.importFiles[filename];
+            let relFile = filename;
+            if (path_1.default.isAbsolute(filename)) {
+                relFile = relativePath(dirname, filename);
+                if (options?.importExt)
+                    relFile = setExt(relFile, options.importExt);
+            }
+            return `import ${types.length ? '{' + types.join(', ') + '} from ' : ''}'${relFile}';`;
+        })
+            .join('\n');
+        if (importStr)
+            output += (0, putil_flattentext_1.default)(importStr) + '\n';
+        output += (0, putil_flattentext_1.default)(this.content);
+        const exportStr = Object.keys(this.exportFiles)
+            .sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()))
+            .map(filename => {
+            const types = this.exportFiles[filename];
+            let relFile = filename;
+            if (path_1.default.isAbsolute(filename)) {
+                relFile = relativePath(dirname, filename);
+                if (options?.importExt)
+                    relFile = setExt(relFile, options.importExt);
+            }
+            return `export ${types.length ? '{' + types.join(', ') + '}' : '*'} from '${relFile}';`;
+        })
+            .join('\n');
+        if (exportStr)
+            output += (0, putil_flattentext_1.default)(exportStr) + '\n';
+        return output;
+    }
+}
+exports.TsFile = TsFile;
+function relativePath(from, to) {
+    const s = path_1.default.relative(from, to);
+    return s.startsWith('.') ? s : ('./' + s);
+}
+exports.relativePath = relativePath;
+function setExt(filename, ext) {
+    const e = path_1.default.extname(filename);
+    return filename.substring(0, filename.length - e.length) + (ext ? '.' + ext : '');
+}
+exports.setExt = setExt;

package/esm/index.js

@@ -1 +1,4 @@
-export * from './oprimp/index.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./api-exporter/index.js"), exports);

package/esm/interfaces/file-writer.interface.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/esm/interfaces/logger.interface.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/esm/interfaces/service-generation-context.interface.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/esm/oprimp-cli.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const commander_1 = require("commander");
+const console = tslib_1.__importStar(require("console"));
+const fs = tslib_1.__importStar(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const process = tslib_1.__importStar(require("process"));
+const api_exporter_js_1 = require("./api-exporter/api-exporter.js");
+const get_caller_file_util_js_1 = require("./utils/get-caller-file.util.js");
+const dirname = path_1.default.dirname((0, get_caller_file_util_js_1.getCallerFile)());
+const pkgJson = JSON.parse(fs.readFileSync(path_1.default.resolve(dirname, '../package.json'), 'utf-8'));
+commander_1.program
+    .version(pkgJson.version)
+    .argument('<serviceUrl>', 'OPRA service url')
+    .argument('<outDir>', 'Output directory')
+    .option('--name <name>', 'Name of the service')
+    .option('--ext', 'Adds js extension to imports')
+    .option('--no-color', 'Disables colors in logs messages')
+    .action(async (serviceUrl, outDir, options) => {
+    if (!options.color)
+        chalk_1.default.level = 0;
+    await api_exporter_js_1.ApiExporter.execute({
+        serviceUrl,
+        logger: console,
+        outDir,
+        name: options.name,
+        importExt: (options.ext ? 'js' : ''),
+        fileHeader: '/* Generated by OPRA Service Generator, Version ' + pkgJson.version + '*/\n' +
+            '/* eslint-disable import/extensions,simple-import-sort/imports */\n'
+    });
+    console.log(chalk_1.default.greenBright('Completed'));
+});
+commander_1.program.parse(process.argv);

package/esm/utils/get-caller-file.util.js

@@ -1,5 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCallerFile = void 0;
 const PATH_PATTERN = /^(?:file:\/\/)?(.+)$/;
-export function getCallerFile(position = 1) {
+function getCallerFile(position = 1) {
     if (position >= Error.stackTraceLimit) {
         throw new TypeError('getCallerFile(position) requires position be less then Error.stackTraceLimit but position was: `' +
             position + '` and Error.stackTraceLimit was: `' + Error.stackTraceLimit + '`');
@@ -18,3 +21,4 @@ export function getCallerFile(position = 1) {
     }
     return '';
 }
+exports.getCallerFile = getCallerFile;

package/esm/utils/string-utils.js

@@ -1,5 +1,9 @@
-import jsStringEscape from 'js-string-escape';
-export function wrapJSDocString(s, indent, currentColumn) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapTypeArray = exports.wrapStringArray = exports.wrapQuotedString = exports.wrapJSDocString = void 0;
+const tslib_1 = require("tslib");
+const js_string_escape_1 = tslib_1.__importDefault(require("js-string-escape"));
+function wrapJSDocString(s, indent, currentColumn) {
     const arr = (s || '')
         .split(/[ \n\r]/)
         .map((x, i, a) => i < a.length - 1 ? x + ' ' : x);
@@ -10,8 +14,9 @@ export function wrapJSDocString(s, indent, currentColumn) {
         lineEnd: ''
     });
 }
-export function wrapQuotedString(s, indent, currentColumn) {
-    const arr = jsStringEscape(s || '')
+exports.wrapJSDocString = wrapJSDocString;
+function wrapQuotedString(s, indent, currentColumn) {
+    const arr = (0, js_string_escape_1.default)(s || '')
         .split(' ')
         .map((x, i, a) => i < a.length - 1 ? x + ' ' : x);
     return '\'' + _printLines(arr, {
@@ -21,16 +26,19 @@ export function wrapQuotedString(s, indent, currentColumn) {
         lineEnd: '\' +',
     }) + '\'';
 }
-export function wrapStringArray(arr, 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 }) + ']';
 }
-export function wrapTypeArray(arr, 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/cli",
-  "version": "0.14.3",
+  "version": "0.16.0",
   "description": "Opra CLI tools",
   "author": "Panates",
   "license": "MIT",
@@ -20,24 +20,23 @@
     "copy:bin": "cp -R bin ../../build/cli/bin",
     "lint": "eslint . --max-warnings=0",
     "check": "madge --circular src/**",
-    "test": "NODE_OPTIONS=--experimental-vm-modules npx jest",
-    "cover": "NODE_OPTIONS=--experimental-vm-modules npx jest --collect-coverage",
+    "test": "jest",
+    "cover": "jest --collect-coverage",
     "clean": "npm run clean:src && npm run clean:dist && npm run clean:cover",
     "clean:src": "ts-cleanup -s src --all",
     "clean:dist": "rimraf ../../build/cli ../../build/client",
     "clean:cover": "rimraf ../../coverage/client"
   },
   "dependencies": {
-    "@opra/node-client": "^0.14.0",
+    "@opra/node-client": "^0.16.0",
     "chalk": "^5.2.0",
-    "commander": "^10.0.0",
+    "commander": "^10.0.1",
+    "js-string-escape": "^1.0.1",
     "putil-flattentext": "^2.1.1",
-    "putil-varhelpers": "^1.6.5",
-    "js-string-escape": "^1.0.1"
+    "putil-varhelpers": "^1.6.5"
   },
-  "devDependencies": {},
   "type": "module",
-  "types": "esm/index.d.ts",
+  "types": "types/index.d.ts",
   "exports": {
     ".": {
       "require": "./cjs/index.js",
@@ -55,6 +54,7 @@
     "bin/",
     "cjs/",
     "esm/",
+    "types/",
     "LICENSE",
     "README.md"
   ],
@@ -64,4 +64,4 @@
     "tool",
     "oprimp"
   ]
-}
+}

package/types/api-exporter/api-exporter.d.ts

@@ -0,0 +1,46 @@
+import { ApiDocument } from '@opra/common';
+import { OpraHttpClient } from '@opra/node-client';
+import { IFileWriter } from '../interfaces/file-writer.interface.js';
+import { ILogger } from '../interfaces/logger.interface.js';
+import { processResources } from './process-resources.js';
+import { generateComplexTypeDefinition, generateEnumTypeDefinition, generateMappedTypeDefinition, generateSimpleTypeDefinition, generateTypeFile, generateUnionTypeDefinition, processTypes, resolveTypeNameOrDef } from './process-types.js';
+import { TsFile } from './ts-file.js';
+export declare namespace ApiExporter {
+    interface Config {
+        serviceUrl: string;
+        outDir: string;
+        name?: string;
+        cwd?: string;
+        logger?: ILogger;
+        writer?: IFileWriter;
+        fileHeader?: string;
+        importExt?: string;
+    }
+}
+export declare class ApiExporter {
+    protected client: OpraHttpClient;
+    protected document: ApiDocument;
+    protected logger: ILogger;
+    protected outDir: string;
+    protected cwd: string;
+    protected name: string;
+    protected fileHeader: string;
+    protected writer: IFileWriter;
+    protected importExt: string;
+    protected files: Record<string, TsFile>;
+    protected processResources: typeof processResources;
+    protected processTypes: typeof processTypes;
+    protected generateTypeFile: typeof generateTypeFile;
+    protected generateComplexTypeDefinition: typeof generateComplexTypeDefinition;
+    protected generateSimpleTypeDefinition: typeof generateSimpleTypeDefinition;
+    protected resolveTypeNameOrDef: typeof resolveTypeNameOrDef;
+    protected generateEnumTypeDefinition: typeof generateEnumTypeDefinition;
+    protected generateUnionTypeDefinition: typeof generateUnionTypeDefinition;
+    protected generateMappedTypeDefinition: typeof generateMappedTypeDefinition;
+    protected constructor(config: ApiExporter.Config);
+    protected execute(): Promise<void>;
+    protected getFile(filePath: string): TsFile;
+    protected addFile(filePath: string, returnExists?: boolean): TsFile;
+    protected cleanDirectory(dirname: string): void;
+    static execute(config: ApiExporter.Config): Promise<void>;
+}

package/types/api-exporter/index.d.ts

@@ -0,0 +1 @@
+export * from './api-exporter.js';

package/types/api-exporter/process-resources.d.ts

@@ -0,0 +1,6 @@
+import type { ApiExporter } from './api-exporter.js';
+/**
+ *
+ * @param targetDir
+ */
+export declare function processResources(this: ApiExporter, targetDir?: string): Promise<void>;

package/types/api-exporter/process-types.d.ts

@@ -0,0 +1,54 @@
+import { ComplexType, DataType, EnumType, MappedType, SimpleType, UnionType } from '@opra/common';
+import type { ApiExporter } from './api-exporter.js';
+import { TsFile } from './ts-file.js';
+/**
+ *
+ * @param targetDir
+ */
+export declare function processTypes(this: ApiExporter, targetDir?: string): Promise<void>;
+/**
+ *
+ * @param dataType
+ * @param targetDir
+ */
+export declare function generateTypeFile(this: ApiExporter, dataType: DataType, targetDir?: string): Promise<TsFile>;
+/**
+ *
+ * @param file
+ * @param dataType
+ * @param forInterface
+ */
+export declare function resolveTypeNameOrDef(this: ApiExporter, file: TsFile, dataType: DataType, forInterface?: boolean): Promise<string>;
+/**
+ *
+ * @param file
+ * @param dataType
+ * @param forInterface
+ */
+export declare function generateComplexTypeDefinition(this: ApiExporter, file: TsFile, dataType: ComplexType, forInterface?: boolean): Promise<string>;
+/**
+ *
+ * @param file
+ * @param dataType
+ */
+export declare function generateSimpleTypeDefinition(this: ApiExporter, file: TsFile, dataType: SimpleType): Promise<string>;
+/**
+ *
+ * @param file
+ * @param dataType
+ */
+export declare function generateEnumTypeDefinition(this: ApiExporter, file: TsFile, dataType: EnumType): Promise<string>;
+/**
+ *
+ * @param file
+ * @param dataType
+ * @param forInterface
+ */
+export declare function generateUnionTypeDefinition(this: ApiExporter, file: TsFile, dataType: UnionType, forInterface?: boolean): Promise<string>;
+/**
+ *
+ * @param file
+ * @param dataType
+ * @param forInterface
+ */
+export declare function generateMappedTypeDefinition(this: ApiExporter, file: TsFile, dataType: MappedType, forInterface?: boolean): Promise<string>;

package/types/api-exporter/ts-file.d.ts

@@ -0,0 +1,18 @@
+export declare class TsFile {
+    filename: string;
+    dirname: string;
+    importFiles: Record<string, string[]>;
+    exportFiles: Record<string, string[]>;
+    exportTypes: string[];
+    header: string;
+    content: string;
+    constructor(filename: string);
+    addImportPackage: (name: string, types?: string[]) => void;
+    addImportFile: (filename: string, types?: string[]) => void;
+    addExportFile: (filename: string, types?: string[]) => void;
+    generate(options?: {
+        importExt?: string;
+    }): string;
+}
+export declare function relativePath(from: string, to: string): string;
+export declare function setExt(filename: string, ext: string): string;

package/types/index.d.ts

@@ -0,0 +1 @@
+export * from './api-exporter/index.js';