@opra/cli 0.33.13 → 1.0.0-alpha.7

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

@@ -0,0 +1,241 @@
+import path from 'path';
+import { ComplexType, EnumType, MappedType, MixinType, SimpleType } from '@opra/common';
+import { CodeBlock } from '../../code-block.js';
+import { wrapJSDocString } from '../utils/string-utils.js';
+const internalTypeNames = ['any', 'boolean', 'bigint', 'number', 'null', 'string', 'object'];
+export 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 SimpleType)
+        file = this.addFile(path.join(this._documentRoot, '/simple-types.ts'), true);
+    else {
+        if (dataType instanceof EnumType)
+            file = this.addFile(path.join(this._typesRoot, 'enums', typeName + '.ts'));
+        else
+            file = this.addFile(path.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.join(this._typesRoot, 'index.ts'), true);
+    const indexTs = this.addFile('/index.ts', true);
+    indexTs.addExport(typesIndexTs.filename);
+    const codeBlock = (file.code['type_' + typeName] = new CodeBlock());
+    codeBlock.head = `/**\n * ${typeName}`;
+    if (dataType.description)
+        codeBlock.head += `\n * ${wrapJSDocString(dataType.description || '')}`;
+    codeBlock.head += `
+ * @url ${path.posix.join(doc.url || this.serviceUrl, '$schema', '#types/' + typeName)}
+ */
+export `;
+    if (dataType instanceof EnumType)
+        codeBlock.typeDef = await this.generateEnumTypeDefinition(dataType, 'scope');
+    else if (dataType instanceof ComplexType)
+        codeBlock.typeDef = await this.generateComplexTypeDefinition(dataType, file, 'scope');
+    else if (dataType instanceof SimpleType)
+        codeBlock.typeDef = await this.generateSimpleTypeDefinition(dataType, 'scope');
+    else if (dataType instanceof MappedType)
+        codeBlock.typeDef = await this.generateMappedTypeDefinition(dataType, file, 'scope');
+    else if (dataType instanceof 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;
+}
+/**
+ *
+ */
+export 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}';
+}
+/**
+ *
+ */
+export 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}';
+}
+/**
+ *
+ */
+export 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;
+}
+/**
+ *
+ */
+export 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' ? ', ' : ' & ');
+}
+/**
+ *
+ */
+export 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;
+}
+/**
+ *
+ */
+export 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 SimpleType)
+        return this.generateSimpleTypeDefinition(dataType, intent);
+    if (dataType instanceof EnumType)
+        return this.generateEnumTypeDefinition(dataType, intent);
+    if (dataType instanceof MixinType)
+        return this.generateMixinTypeDefinition(dataType, file, intent);
+    if (dataType instanceof MappedType)
+        return this.generateMappedTypeDefinition(dataType, file, intent);
+    if (dataType instanceof ComplexType)
+        return this.generateComplexTypeDefinition(dataType, file, intent);
+    return '';
+}

package/esm/ts-generator/processors/process-document.js

@@ -0,0 +1,55 @@
+import chalk from 'chalk';
+import path from 'path';
+import { pascalCase } from 'putil-varhelpers';
+import { OpraHttpClient } from '@opra/client';
+import { HttpApi } from '@opra/common';
+export async function processDocument(document, options) {
+    if (!document || typeof document === 'string') {
+        if (document) {
+            const out = this._documentsMap.get(document);
+            if (out)
+                return out;
+        }
+        this.emit('log', chalk.cyan('Fetching document schema from ') + chalk.blueBright(this.serviceUrl));
+        const client = new OpraHttpClient(this.serviceUrl);
+        document = await client.fetchDocument({ documentId: document });
+    }
+    this._document = document;
+    let out = this._documentsMap.get(document.id);
+    if (out)
+        return out;
+    out = {
+        document,
+        generator: this,
+    };
+    this._documentsMap.set(document.id, out);
+    this.emit('log', chalk.white('[' + document.id + '] ') + chalk.cyan('Processing document ') + chalk.magenta(document.info.title));
+    if (document.references.size) {
+        this.emit('log', chalk.white('[' + document.id + '] ') + chalk.cyan(`Processing references`));
+        for (const ref of document.references.values()) {
+            const generator = this.extend();
+            generator._document = ref;
+            generator._documentRoot = '/references/' + (ref.info.title ? pascalCase(ref.info.title) : ref.id);
+            generator._typesRoot = path.join(generator._documentRoot, 'models');
+            await generator.processDocument(ref, { typesOnly: true });
+        }
+    }
+    this._fileHeaderDocInfo = `/*
+ * ${document.info.title}
+ * Id: ${document.id}
+ * Version: ${document.info.version}
+ * ${this.serviceUrl}
+ */`;
+    if (document.types.size) {
+        this.emit('log', chalk.white('[' + document.id + ']'), chalk.cyan(`Processing data types`));
+        for (const t of document.types.values()) {
+            await this.processDataType(t);
+        }
+    }
+    if (options?.typesOnly)
+        return out;
+    if (document.api instanceof HttpApi) {
+        await this.processHttpApi(document.api);
+    }
+    return out;
+}

package/esm/ts-generator/processors/process-http-api.js

@@ -0,0 +1,40 @@
+import path from 'node:path';
+import { camelCase, pascalCase } from 'putil-varhelpers';
+import { CodeBlock } from '../../code-block.js';
+import { httpControllerNodeScript } from '../http-controller-node.js';
+import { wrapJSDocString } from '../utils/string-utils.js';
+export async function processHttpApi(api) {
+    let file = this._filesMap.get(api);
+    if (file)
+        return file;
+    const className = api.name ? pascalCase(api.name) : 'Api';
+    file = this.addFile(className + '.ts');
+    file.addImport('@opra/client', ['kClient', 'OpraHttpClient']);
+    const indexTs = this.addFile('/index.ts', true);
+    indexTs.addExport('.' + file.filename);
+    const httpApiNodeFile = this.addFile('./http-controller-node.ts');
+    httpApiNodeFile.code.content = httpControllerNodeScript;
+    const classBlock = (file.code[className] = new CodeBlock());
+    classBlock.doc = `/** 
+ * ${wrapJSDocString(api.description || '')}
+ * @class ${className}
+ * @url ${path.posix.join(this.serviceUrl, '$schema')}
+ */`;
+    classBlock.head = `\nexport class ${className} {\n\t`;
+    classBlock.properties = 'readonly [kClient]: OpraHttpClient;';
+    const classConstBlock = (classBlock.classConstBlock = new CodeBlock());
+    classConstBlock.head = `\n\nconstructor(client: OpraHttpClient) {`;
+    classConstBlock.body = `\n\tthis[kClient] = client;`;
+    classConstBlock.tail = `\b\n}\n`;
+    for (const controller of api.controllers.values()) {
+        const generator = this.extend();
+        const f = await generator.processHttpController(controller);
+        const childClassName = pascalCase(controller.name) + 'Controller';
+        file.addImport('.' + f.filename, [childClassName]);
+        const property = '$' + controller.name.charAt(0).toLowerCase() + camelCase(controller.name.substring(1));
+        classBlock.properties += `\nreadonly ${property}: ${childClassName};`;
+        classConstBlock.body += `\nthis.${property} = new ${childClassName}(client);`;
+    }
+    classBlock.tail = `\b}`;
+    return file;
+}

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

@@ -0,0 +1,184 @@
+import path from 'node:path';
+import { camelCase, pascalCase } from 'putil-varhelpers';
+import { CodeBlock } from '../../code-block.js';
+import { locateNamedType } from '../utils/locate-named-type.js';
+import { wrapJSDocString } from '../utils/string-utils.js';
+export async function processHttpController(controller) {
+    let file = this._filesMap.get(controller);
+    if (file)
+        return file;
+    const className = pascalCase(controller.name) + 'Controller';
+    file = this.addFile(path.join(this._apiPath, className + '.ts'));
+    file.addImport('@opra/client', ['HttpRequestObservable', 'kClient', 'OpraHttpClient']);
+    file.addImport(path.relative(file.dirname, '/http-controller-node.ts'), ['HttpControllerNode']);
+    const classBlock = (file.code[className] = new CodeBlock());
+    classBlock.doc = `/** 
+ * ${wrapJSDocString(controller.description || '')}
+ * @class ${className}
+ * @url ${path.posix.join(this.serviceUrl, '$schema', '#resources/' + className)}
+ */`;
+    classBlock.head = `\nexport class ${className} extends HttpControllerNode {\n\t`;
+    classBlock.properties = '';
+    const classConstBlock = (classBlock.classConstBlock = new CodeBlock());
+    classConstBlock.head = `\n\nconstructor(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 = path.join(this._apiPath, className);
+            const f = await generator.processHttpController(child);
+            const childClassName = pascalCase(child.name) + 'Controller';
+            file.addImport(f.filename, [childClassName]);
+            const property = '$' + child.name.charAt(0).toLowerCase() + camelCase(child.name.substring(1));
+            classBlock.properties += `\nreadonly ${property}: ${childClassName};`;
+            classConstBlock.body += `\nthis.${property} = new ${childClassName}(client);`;
+        }
+    }
+    /** Process operations */
+    for (const operation of controller.operations.values()) {
+        const operationBlock = (classBlock['operation_' + operation.name] = new CodeBlock());
+        operationBlock.doc = `
+/** 
+ * ${wrapJSDocString(operation.description || operation.name + ' operation')}`;
+        if (operation.parameters.length) {
+            const block = new 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: ${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 += block;
+        }
+        operationBlock.doc += `\n */\n`;
+        operationBlock.head = `${operation.name}(`;
+        /** Process operation parameters */
+        const mergedParams = [...controller.parameters, ...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));
+        }
+        let argIndex = 0;
+        for (const prm of pathParams) {
+            const type = locateNamedType(prm.type);
+            if (argIndex++ > 0)
+                operationBlock.head += ', ';
+            operationBlock.head += `${prm.name}: ${type?.name || 'any'}`;
+        }
+        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) {
+                    const dtFile = this._filesMap.get(content.type);
+                    if (dtFile) {
+                        const typeName = await this.resolveTypeNameOrDef(content.type, dtFile, 'field');
+                        typeArr.push(typeName);
+                        file.addImport(dtFile.filename, [typeName]);
+                        continue;
+                    }
+                }
+                typeArr = [];
+                break;
+            }
+            if (typeArr.length) {
+                if (operation.requestBody.partial) {
+                    file.addImport('ts-gems', ['PartialDTO']);
+                    operationBlock.head += `$body: PartialDTO<${typeArr.join(' | ')}>`;
+                }
+                else {
+                    file.addImport('ts-gems', ['DTO']);
+                    operationBlock.head += `$body: DTO<${typeArr.join(' | ')}>`;
+                }
+            }
+            else
+                operationBlock.head += `$body: any`;
+            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';
+            for (const prm of queryParams) {
+                const type = locateNamedType(prm.type);
+                operationBlock.head += `/**\n * ${prm.description || ''}\n */\n`;
+                operationBlock.head += `${prm.name}${prm.required ? '' : '?'}: `;
+                if (type?.name) {
+                    const typeFile = await this.processDataType(type);
+                    if (typeFile) {
+                        file.addImport(typeFile.filename, [type.name]);
+                        operationBlock.head += `${type.name};\n`;
+                        continue;
+                    }
+                }
+                operationBlock.head += `${type?.name || '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) {
+                const type = locateNamedType(prm.type);
+                operationBlock.head += `/**\n * ${prm.description || ''}\n */\n`;
+                operationBlock.head += `${prm.name}${prm.required ? '' : '?'}: `;
+                if (type?.name) {
+                    const typeFile = await this.processDataType(type);
+                    if (typeFile) {
+                        file.addImport(typeFile.filename, [type.name]);
+                        operationBlock.head += `${type.name};\n`;
+                        continue;
+                    }
+                }
+                operationBlock.head += `${type?.name || 'any'};\n`;
+            }
+            operationBlock.head += '\b}\b';
+        }
+        operationBlock.head += `\n): HttpRequestObservable<any>{`;
+        operationBlock.body = `\n\t`;
+        operationBlock.body +=
+            `const url = this._prepareUrl('${operation.getFullUrl()}', {` + pathParams.map(p => p.name).join(', ') + '});';
+        operationBlock.body +=
+            `\nreturn this[kClient].request(url, {` +
+                (hasBody ? ' body: $body,' : '') +
+                (queryParams.length ? ' params: $params as any,' : '') +
+                (headerParams.length ? ' headers: $headers as any,' : '') +
+                '});';
+        operationBlock.tail = `\b\n};\n`;
+    }
+    classBlock.tail = `\b}`;
+    return file;
+}

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

@@ -0,0 +1,96 @@
+import path from 'path';
+import flattenText from 'putil-flattentext';
+import { CodeBlock } from '../code-block.js';
+export class TsFile {
+    constructor(filename) {
+        this.filename = filename;
+        this.imports = {};
+        this.exportFiles = {};
+        this.exportTypes = [];
+        this.code = new CodeBlock();
+        this.dirname = path.dirname(filename);
+        this.code.header = '';
+        this.code.imports = '';
+        this.code.exports = '';
+    }
+    addImport(filename, items, typeImport) {
+        if (isLocalFile(filename)) {
+            filename = path.relative(this.dirname, path.resolve(this.dirname, filename));
+            if (!filename.startsWith('.'))
+                filename = './' + filename;
+        }
+        if (filename.endsWith('.d.ts'))
+            filename = filename.substring(0, filename.length - 5);
+        if (filename.endsWith('.ts') || filename.endsWith('.js'))
+            filename = filename.substring(0, filename.length - 3);
+        const imp = (this.imports[filename] = this.imports[filename] || { items: [], typeImport });
+        if (!typeImport)
+            imp.typeImport = false;
+        items?.forEach(x => {
+            if (!imp.items.includes(x))
+                imp.items.push(x);
+        });
+    }
+    addExport(filename, types) {
+        if (isLocalFile(filename)) {
+            filename = path.relative(this.dirname, path.resolve(this.dirname, filename));
+            if (!filename.startsWith('.'))
+                filename = './' + filename;
+        }
+        if (filename.endsWith('.d.ts'))
+            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] || [];
+        types?.forEach(x => {
+            if (!this.exportFiles[filename].includes(x))
+                this.exportFiles[filename].push(x);
+        });
+    }
+    generate(options) {
+        this.code.imports = Object.keys(this.imports)
+            .sort((a, b) => {
+            if (a.startsWith('@'))
+                return -1;
+            if (b.startsWith('@'))
+                return 1;
+            if (!a.startsWith('.'))
+                return -1;
+            if (!b.startsWith('.'))
+                return 1;
+            return a.toLowerCase().localeCompare(b.toLowerCase());
+        })
+            .map(filename => {
+            const imp = this.imports[filename];
+            let relFile = filename;
+            if (!isPackageName(filename)) {
+                if (options?.importExt)
+                    relFile += '.js';
+            }
+            return `import${imp.typeImport ? ' type' : ''} ${imp.items.length ? '{ ' + imp.items.join(', ') + ' } from ' : ''}'${relFile}';`;
+        })
+            .join('\n');
+        this.code.exports = Object.keys(this.exportFiles)
+            .sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()))
+            .map(filename => {
+            const types = this.exportFiles[filename];
+            if (!isPackageName(filename)) {
+                if (options?.importExt)
+                    filename += '.js';
+            }
+            return `export ${types.length ? '{ ' + types.join(', ') + ' }' : '*'} 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' +
+            flattenText(String(this.code)));
+    }
+}
+function isLocalFile(s) {
+    return typeof s === 'string' && (s.startsWith('.') || s.startsWith('/'));
+}
+const PACKAGENAME_PATTERN = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+function isPackageName(s) {
+    return PACKAGENAME_PATTERN.test(s);
+}