@gjsify/cli 0.0.1-b → 0.0.2

package/lib/actions/build.d.ts

@@ -1,8 +1,112 @@
-import webpack from 'webpack';
-import { BuildOptions } from '../types';
+import type { ConfigData } from '../types/index.js';
+import type { App } from '@gjsify/esbuild-plugin-gjsify';
+import { BuildOptions, BuildResult } from 'esbuild';
 export declare class BuildAction {
-    compiler: webpack.Compiler;
-    constructor(options: BuildOptions);
-    build(): Promise<webpack.Stats>;
-    watch(watchOptions?: webpack.ICompiler.WatchOptions): Promise<webpack.Stats>;
+    readonly configData: ConfigData;
+    constructor(configData?: ConfigData);
+    getEsBuildDefaults(): BuildOptions;
+    /** Library mode */
+    buildLibrary(): Promise<BuildResult<BuildOptions>[]>;
+    /** Application mode */
+    buildApp(app?: App): Promise<BuildResult<{
+        format: "cjs" | "esm";
+        plugins: import("esbuild").Plugin[];
+        bundle?: boolean | undefined;
+        splitting?: boolean | undefined;
+        preserveSymlinks?: boolean | undefined;
+        outfile?: string | undefined;
+        metafile?: boolean | undefined;
+        outdir?: string | undefined;
+        outbase?: string | undefined;
+        external?: string[] | undefined;
+        packages?: "external" | undefined;
+        alias?: Record<string, string> | undefined;
+        loader?: {
+            [ext: string]: import("esbuild").Loader;
+        } | undefined;
+        resolveExtensions?: string[] | undefined;
+        mainFields?: string[] | undefined;
+        conditions?: string[] | undefined;
+        write?: boolean | undefined;
+        allowOverwrite?: boolean | undefined;
+        tsconfig?: string | undefined;
+        outExtension?: {
+            [ext: string]: string;
+        } | undefined;
+        publicPath?: string | undefined;
+        entryNames?: string | undefined;
+        chunkNames?: string | undefined;
+        assetNames?: string | undefined;
+        inject?: string[] | undefined;
+        banner?: {
+            [type: string]: string;
+        } | undefined;
+        footer?: {
+            [type: string]: string;
+        } | undefined;
+        entryPoints?: string[] | Record<string, string> | {
+            in: string;
+            out: string;
+        }[] | undefined;
+        stdin?: import("esbuild").StdinOptions | undefined;
+        absWorkingDir?: string | undefined;
+        nodePaths?: string[] | undefined;
+        sourcemap?: boolean | "inline" | "both" | "external" | "linked" | undefined;
+        legalComments?: "inline" | "none" | "external" | "linked" | "eof" | undefined;
+        sourceRoot?: string | undefined;
+        sourcesContent?: boolean | undefined;
+        globalName?: string | undefined;
+        target?: string | string[] | undefined;
+        supported?: Record<string, boolean> | undefined;
+        platform?: import("esbuild").Platform | undefined;
+        mangleProps?: RegExp | undefined;
+        reserveProps?: RegExp | undefined;
+        mangleQuoted?: boolean | undefined;
+        mangleCache?: Record<string, string | false> | undefined;
+        drop?: import("esbuild").Drop[] | undefined;
+        minify?: boolean | undefined;
+        minifyWhitespace?: boolean | undefined;
+        minifyIdentifiers?: boolean | undefined;
+        minifySyntax?: boolean | undefined;
+        charset?: import("esbuild").Charset | undefined;
+        treeShaking?: boolean | undefined;
+        ignoreAnnotations?: boolean | undefined;
+        jsx?: "transform" | "preserve" | "automatic" | undefined;
+        jsxFactory?: string | undefined;
+        jsxFragment?: string | undefined;
+        jsxImportSource?: string | undefined;
+        jsxDev?: boolean | undefined;
+        jsxSideEffects?: boolean | undefined;
+        define?: {
+            [key: string]: string;
+        } | undefined;
+        pure?: string[] | undefined;
+        keepNames?: boolean | undefined;
+        color?: boolean | undefined;
+        logLevel?: import("esbuild").LogLevel | undefined;
+        logLimit?: number | undefined;
+        logOverride?: Record<string, import("esbuild").LogLevel> | undefined;
+        tsconfigRaw?: string | {
+            compilerOptions?: {
+                alwaysStrict?: boolean | undefined;
+                baseUrl?: boolean | undefined;
+                experimentalDecorators?: boolean | undefined;
+                importsNotUsedAsValues?: "error" | "remove" | "preserve" | undefined;
+                jsx?: "preserve" | "react" | "react-jsx" | "react-jsxdev" | "react-native" | undefined;
+                jsxFactory?: string | undefined;
+                jsxFragmentFactory?: string | undefined;
+                jsxImportSource?: string | undefined;
+                paths?: Record<string, string[]> | undefined;
+                preserveValueImports?: boolean | undefined;
+                strict?: boolean | undefined;
+                target?: string | undefined;
+                useDefineForClassFields?: boolean | undefined;
+                verbatimModuleSyntax?: boolean | undefined;
+            } | undefined;
+        } | undefined;
+    }>[]>;
+    start(buildType?: {
+        library?: boolean;
+        app?: App;
+    }): Promise<BuildResult<BuildOptions>[]>;
 }

package/lib/actions/build.js

@@ -1,27 +1,98 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const util_1 = require("util");
-const webpack_1 = tslib_1.__importDefault(require("webpack"));
-const webpack_config_default_1 = require("../webpack.config.default");
-const terser_webpack_plugin_1 = tslib_1.__importDefault(require("terser-webpack-plugin"));
-const path_1 = require("path");
-class BuildAction {
-    constructor(options) {
-        webpack_config_default_1.webpackConfigDefault.entry = options.entry || webpack_config_default_1.webpackConfigDefault.entry;
-        webpack_config_default_1.webpackConfigDefault.output.filename = options.output.filename || webpack_config_default_1.webpackConfigDefault.output.filename;
-        webpack_config_default_1.webpackConfigDefault.output.path = options.output.path ? path_1.resolve(process.cwd(), options.output.path) : webpack_config_default_1.webpackConfigDefault.output.path;
-        webpack_config_default_1.webpackConfigDefault.optimization.minimize = typeof options.minimize === 'boolean' ? options.minimize : webpack_config_default_1.webpackConfigDefault.optimization.minimize;
-        webpack_config_default_1.minimizerConfigDefault.terserOptions.output.beautify = typeof options.beautify === 'boolean' ? options.beautify : webpack_config_default_1.minimizerConfigDefault.terserOptions.output.beautify;
-        webpack_config_default_1.minimizerConfigDefault.terserOptions.mangle = typeof options.mangle === 'boolean' ? options.mangle : webpack_config_default_1.minimizerConfigDefault.terserOptions.mangle;
-        webpack_config_default_1.webpackConfigDefault.optimization.minimizer.push(new terser_webpack_plugin_1.default(webpack_config_default_1.minimizerConfigDefault));
-        this.compiler = webpack_1.default(webpack_config_default_1.webpackConfigDefault);
+import { build } from 'esbuild';
+import { gjsifyPlugin } from '@gjsify/esbuild-plugin-gjsify';
+import { dirname, extname } from 'path';
+export class BuildAction {
+    configData;
+    constructor(configData = {}) {
+        this.configData = configData;
     }
-    build() {
-        return util_1.promisify(this.compiler.run.bind(this.compiler))();
+    getEsBuildDefaults() {
+        const defaults = {
+            allowOverwrite: true
+        };
+        return defaults;
     }
-    watch(watchOptions = {}) {
-        return util_1.promisify(this.compiler.watch.bind(this.compiler, watchOptions))();
+    /** Library mode */
+    async buildLibrary() {
+        let { verbose, library, esbuild, typescript, exclude } = this.configData;
+        library ||= {};
+        esbuild ||= {};
+        typescript ||= {};
+        const moduleOutdir = library?.module ? dirname(library.module) : undefined;
+        const mainOutdir = library?.main ? dirname(library.main) : undefined;
+        const moduleOutExt = library.module ? extname(library.module) : '.js';
+        const mainOutExt = library.main ? extname(library.main) : '.js';
+        const multipleBuilds = moduleOutdir && mainOutdir && (moduleOutdir !== mainOutdir);
+        const results = [];
+        if (multipleBuilds) {
+            const moduleFormat = moduleOutdir.includes('/cjs') || moduleOutExt === '.cjs' ? 'cjs' : 'esm';
+            results.push(await build({
+                ...this.getEsBuildDefaults(),
+                ...esbuild,
+                format: moduleFormat,
+                outdir: moduleOutdir,
+                plugins: [
+                    gjsifyPlugin({ debug: verbose, library: moduleFormat, exclude, reflection: typescript?.reflection, jsExtension: moduleOutExt }),
+                ]
+            }));
+            const mainFormat = mainOutdir.includes('/cjs') || mainOutExt === '.cjs' ? 'cjs' : 'esm';
+            results.push(await build({
+                ...this.getEsBuildDefaults(),
+                ...esbuild,
+                format: moduleFormat,
+                outdir: mainOutdir,
+                plugins: [
+                    gjsifyPlugin({ debug: verbose, library: mainFormat, exclude, reflection: typescript?.reflection, jsExtension: mainOutdir })
+                ]
+            }));
+        }
+        else {
+            const outfilePath = esbuild?.outfile || library?.module || library?.main;
+            const outExt = outfilePath ? extname(outfilePath) : '.js';
+            const outdir = esbuild?.outdir || (outfilePath ? dirname(outfilePath) : undefined);
+            const format = esbuild?.format || outdir?.includes('/cjs') || outExt === '.cjs' ? 'cjs' : 'esm';
+            results.push(await build({
+                ...this.getEsBuildDefaults(),
+                ...esbuild,
+                format,
+                outdir,
+                plugins: [
+                    gjsifyPlugin({ debug: verbose, library: format, exclude, reflection: typescript?.reflection, jsExtension: outExt })
+                ]
+            }));
+        }
+        return results;
+    }
+    /** Application mode */
+    async buildApp(app = 'gjs') {
+        const { verbose, esbuild, typescript, exclude } = this.configData;
+        const format = esbuild?.format || esbuild?.outfile?.endsWith('.cjs') ? 'cjs' : 'esm';
+        const result = await build({
+            ...this.getEsBuildDefaults(),
+            ...esbuild,
+            format,
+            plugins: [
+                gjsifyPlugin({ debug: verbose, app, format, exclude, reflection: typescript?.reflection }),
+            ]
+        });
+        // See https://esbuild.github.io/api/#metafile
+        // TODO add cli options for this 
+        // if(result.metafile) {
+        //     const outFile = esbuild?.outfile ? esbuild.outfile + '.meta.json' : 'meta.json';
+        //     await writeFile(outFile, JSON.stringify(result.metafile));
+        //     let text = await analyzeMetafile(result.metafile)
+        //     console.log(text)
+        // }
+        return [result];
+    }
+    async start(buildType = { app: 'gjs' }) {
+        const results = [];
+        if (buildType.library) {
+            results.push(...(await this.buildLibrary()));
+        }
+        else {
+            results.push(...(await this.buildApp(buildType.app)));
+        }
+        return results;
     }
 }
-exports.BuildAction = BuildAction;

package/lib/commands/build.d.ts

@@ -1,17 +1,2 @@
-import { Command, flags } from '@oclif/command';
-export default class Build extends Command {
-    static description: string;
-    static examples: string[];
-    static flags: {
-        help: import("@oclif/parser/lib/flags").IBooleanFlag<void>;
-        outputFilename: flags.IOptionFlag<string>;
-        outputPath: flags.IOptionFlag<string>;
-        beautify: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
-        minimize: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
-        mangle: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
-    };
-    static args: {
-        name: string;
-    }[];
-    run(): Promise<void>;
-}
+import type { Command, CliBuildOptions } from '../types/index.js';
+export declare const buildCommand: Command<any, CliBuildOptions>;

package/lib/commands/build.js

@@ -1,65 +1,78 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const command_1 = require("@oclif/command");
-const build_1 = require("../actions/build");
-const defaults_1 = require("../defaults");
-class Build extends command_1.Command {
-    async run() {
-        const { argv, flags } = this.parse(Build);
-        const buildOptions = {
-            output: {},
-        };
-        buildOptions.entry = argv;
-        buildOptions.output.filename = flags.outputFilename;
-        buildOptions.output.path = flags.outputPath;
-        buildOptions.beautify = flags.beautify;
-        const action = new build_1.BuildAction(buildOptions);
-        action.build()
-            .then(stats => {
-            this.log(stats.toString());
+import { Config } from '../config.js';
+import { BuildAction } from '../actions/build.js';
+export const buildCommand = {
+    command: 'build [entryPoints..]',
+    description: 'Build and bundle your Gjs project',
+    builder: (yargs) => {
+        return yargs
+            .option('entry-points', {
+            description: "The entry points you want to bundle",
+            array: true,
+            type: 'string',
+            normalize: true,
+            default: ['src/index.ts'],
+            coerce: (arg) => {
+                // Removes duplicates
+                return [...new Set(arg)];
+            }
         })
-            .catch(error => {
-            this.error(error);
+            .option('exclude', {
+            description: "An array of glob patterns to exclude entry-points and aliases",
+            array: true,
+            type: 'string',
+            normalize: true,
+            default: []
+        })
+            .option('verbose', {
+            description: "Switch on the verbose mode",
+            type: 'boolean',
+            normalize: true,
+            default: false
+        })
+            .option('app', {
+            description: "Use this if you want to build a application, the application platforms node and deno are usually only used for tests",
+            type: 'string',
+            choices: ['gjs', 'node', 'deno', 'browser'],
+            normalize: true,
+            default: 'gjs'
+        })
+            .option('library', {
+            description: "Use this if you want to build a library for Gjsify",
+            type: 'boolean',
+            normalize: true,
+            default: false
+        })
+            .option('outfile', {
+            description: "Sets the output file name for the build operation. If no outfile is specified, the outfile will be parsed from the package.json. Only used if application mode is active",
+            type: 'string',
+            normalize: true,
+        })
+            .option('outdir', {
+            description: "Sets the output directory for the build operation. If no outdir is specified, the outdir will be parsed from the package.json. Only used if library mode is active",
+            type: 'string',
+            normalize: true,
+        })
+            .option('reflection', {
+            description: "Enables TypeScript types on runtime using Deepkit's type compiler",
+            type: 'boolean',
+            normalize: true,
+            default: false
+        })
+            .option('log-level', {
+            description: "The log level can be changed to prevent esbuild from printing warning and/or error messages to the terminal",
+            type: 'string',
+            choices: ['silent', 'error', 'warning', 'info', 'debug', 'verbose'],
+            normalize: true,
+            default: 'warning'
+        });
+    },
+    handler: async (args) => {
+        const config = new Config();
+        const configData = await config.forBuild(args);
+        const action = new BuildAction(configData);
+        await action.start({
+            library: args.library,
+            app: args.app,
         });
     }
-}
-exports.default = Build;
-Build.description = 'describe the command here';
-Build.examples = [
-    '$ gjsify build ./src/hello.ts',
-];
-Build.flags = {
-    help: command_1.flags.help({ char: 'h' }),
-    outputFilename: command_1.flags.string({
-        char: 'o',
-        description: 'File name of the output bundle',
-        required: false,
-        multiple: false,
-        default: defaults_1.flags.outputFilename,
-    }),
-    outputPath: command_1.flags.string({
-        char: 'p',
-        description: 'Output destination path',
-        required: false,
-        multiple: false,
-        default: defaults_1.flags.outputPath,
-    }),
-    beautify: command_1.flags.boolean({
-        char: 'b',
-        description: 'Beautify build output',
-        required: false,
-        default: defaults_1.flags.beautify,
-    }),
-    minimize: command_1.flags.boolean({
-        char: 'm',
-        description: 'Minimize build output',
-        required: false,
-        default: defaults_1.flags.minimize,
-    }),
-    mangle: command_1.flags.boolean({
-        description: 'Mangle build output',
-        required: false,
-        default: defaults_1.flags.mangle,
-    }),
 };
-Build.args = [{ name: 'file' }];

package/lib/commands/index.d.ts

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

package/lib/commands/index.js

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

package/lib/config.d.ts

@@ -0,0 +1,14 @@
+import { Options as LoadOptions } from 'cosmiconfig';
+import type { CliBuildOptions, ConfigData } from './types/index.js';
+import type { ArgumentsCamelCase } from 'yargs';
+export declare class Config {
+    readonly loadOptions: LoadOptions;
+    constructor(loadOptions?: LoadOptions);
+    /** Loads gjsify config file, e.g `gjsify.js` */
+    private load;
+    /** Loads package.json of the current project */
+    private readPackageJSON;
+    /** Loads tsconfig.json of the current project */
+    private readTSConfig;
+    forBuild(cliArgs: ArgumentsCamelCase<CliBuildOptions>): Promise<ConfigData>;
+}

package/lib/config.js

@@ -0,0 +1,63 @@
+import { APP_NAME } from './constants.js';
+import { cosmiconfig } from 'cosmiconfig';
+import { readPackageJSON, resolvePackageJSON } from 'pkg-types';
+import { getTsconfig } from 'get-tsconfig';
+import lodash from "lodash";
+const { merge } = lodash;
+export class Config {
+    loadOptions = {
+        searchPlaces: [APP_NAME]
+    };
+    constructor(loadOptions = {}) {
+        if (Object.keys(loadOptions).length) {
+            this.loadOptions = loadOptions;
+        }
+    }
+    /** Loads gjsify config file, e.g `gjsify.js` */
+    async load(searchFrom) {
+        let configFile = await cosmiconfig(APP_NAME, this.loadOptions).search(searchFrom);
+        configFile ||= {
+            config: {},
+            filepath: '',
+            isEmpty: true,
+        };
+        configFile.config ||= {};
+        configFile.config.esbuild ||= {};
+        configFile.config.library ||= {};
+        configFile.config.typescript ||= {};
+        return configFile;
+    }
+    /** Loads package.json of the current project */
+    async readPackageJSON(dirPath) {
+        dirPath = await resolvePackageJSON(dirPath);
+        const pkg = await readPackageJSON(dirPath);
+        return pkg;
+    }
+    /** Loads tsconfig.json of the current project */
+    async readTSConfig(dirPath) {
+        const tsconfig = getTsconfig(dirPath)?.config || {};
+        return tsconfig;
+    }
+    async forBuild(cliArgs) {
+        const configFile = await this.load(process.cwd());
+        const configData = { ...configFile.config };
+        const configFilePath = configFile.filepath || process.cwd();
+        const pkg = await this.readPackageJSON(configFilePath);
+        const tsConfig = await this.readTSConfig(configFilePath);
+        tsConfig.reflection ||= cliArgs.reflection;
+        // TODO replace with `cliArgs.logLevel`
+        configData.verbose = cliArgs.verbose || false;
+        configData.exclude = cliArgs.exclude || [];
+        merge(configData.library, pkg, configData.library);
+        merge(configData.typescript, tsConfig, configData.typescript);
+        merge(configData.esbuild, {
+            entryPoints: cliArgs.entryPoints,
+            outfile: cliArgs.outfile,
+            outdir: cliArgs.outdir,
+            logLevel: cliArgs.logLevel || 'warning'
+        });
+        if (configData.verbose)
+            console.debug("configData", configData);
+        return configData;
+    }
+}

package/lib/constants.d.ts

@@ -0,0 +1 @@
+export declare const APP_NAME = "gjsify";

package/lib/constants.js

@@ -0,0 +1 @@
+export const APP_NAME = 'gjsify';

package/lib/index.d.ts

@@ -1,2 +1,2 @@
-export * from './commands/build';
-export { run } from '@oclif/command';
+#!/usr/bin/env node
+export {};

package/lib/index.js

@@ -1,6 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./commands/build"), exports);
-var command_1 = require("@oclif/command");
-exports.run = command_1.run;
+#!/usr/bin/env node
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { buildCommand as build } from './commands/index.js';
+import { APP_NAME } from './constants.js';
+void yargs(hideBin(process.argv))
+    .scriptName(APP_NAME)
+    .strict()
+    // .usage(Config.usage)
+    .command(build.command, build.description, build.builder, build.handler)
+    .demandCommand(1)
+    .help().argv;

package/lib/types/cli-build-options.d.ts

@@ -0,0 +1,35 @@
+import type { App } from '@gjsify/esbuild-plugin-gjsify';
+export interface CliBuildOptions {
+    /**
+     * This is an array of files that each serve as an input to the bundling algorithm.
+     * @see https://esbuild.github.io/api/#entry-points
+     */
+    entryPoints?: string[];
+    /** Switch on the verbose mode */
+    verbose?: boolean;
+    /** Use this if you want to build a application or test, the platforms node and deno are usually only used internally to build the tests for Gjsify */
+    app?: App;
+    /** Use this if you want to build a library for Gjsify */
+    library?: boolean;
+    /**
+     * This option sets the output file name for the build operation.
+     * This is only applicable if there is a single entry point.
+     * If there are multiple entry points, you must use the outdir option instead to specify an output directory.
+     * @see https://esbuild.github.io/api/#outfile
+     */
+    outfile?: string;
+    /**
+     * This option sets the output directory for the build operation.
+     * @see https://esbuild.github.io/api/#outdir
+     */
+    outdir?: string;
+    /** Enables TypeScript types on runtime using Deepkit's type compiler */
+    reflection?: boolean;
+    /**
+     * The log level can be changed to prevent esbuild from printing warning and/or error messages to the terminal
+     * @see https://esbuild.github.io/api/#log-level
+     */
+    logLevel: 'silent' | 'error' | 'warning' | 'info' | 'debug' | 'verbose';
+    /** An array of glob patterns to exclude matches and aliases */
+    exclude?: string[];
+}

package/lib/types/cli-build-options.js

@@ -0,0 +1 @@
+export {};

package/lib/types/command.d.ts

@@ -0,0 +1,9 @@
+import type { ArgumentsCamelCase, MiddlewareFunction, BuilderCallback } from 'yargs';
+export interface Command<T = any, U = T> {
+    command: string | ReadonlyArray<string>;
+    description: string;
+    builder?: BuilderCallback<T, U>;
+    handler?: (args: ArgumentsCamelCase<U>) => void | Promise<void>;
+    middlewares?: MiddlewareFunction[];
+    deprecated?: boolean | string;
+}

package/lib/types/command.js

@@ -0,0 +1 @@
+export {};

package/lib/types/config-data-library.d.ts

@@ -0,0 +1,3 @@
+import type { PackageJson } from 'pkg-types';
+export interface ConfigDataLibrary extends PackageJson {
+}

package/lib/types/config-data-library.js

@@ -0,0 +1 @@
+export {};

package/lib/types/config-data-typescript.d.ts

@@ -0,0 +1,5 @@
+import type { TsConfigJsonResolved } from 'get-tsconfig';
+export interface ConfigDataTypescript extends TsConfigJsonResolved {
+    /** Enables TypeScript types on runtime using Deepkit's type compiler */
+    reflection?: boolean;
+}

package/lib/types/config-data-typescript.js

@@ -0,0 +1 @@
+export {};

package/lib/types/config-data.d.ts

@@ -0,0 +1,11 @@
+import type { BuildOptions as EsbuildOptions } from 'esbuild';
+import type { ConfigDataLibrary, ConfigDataTypescript } from './index.js';
+export interface ConfigData {
+    /** Switch on the verbose mode */
+    verbose?: boolean;
+    esbuild?: EsbuildOptions;
+    library?: ConfigDataLibrary;
+    typescript?: ConfigDataTypescript;
+    /** An array of glob patterns to exclude matches and aliases */
+    exclude?: string[];
+}

package/lib/types/config-data.js

@@ -0,0 +1 @@
+export {};

package/lib/types/cosmiconfig-result.d.ts

@@ -0,0 +1,5 @@
+export type CosmiconfigResult<C = any> = {
+    config: C;
+    filepath: string;
+    isEmpty?: boolean;
+} | null;

package/lib/types/cosmiconfig-result.js

@@ -0,0 +1 @@
+export {};

package/lib/types/index.d.ts

@@ -1 +1,6 @@
-export * from './build-options';
+export * from './cli-build-options.js';
+export * from './command.js';
+export * from './config-data-library.js';
+export * from './config-data-typescript.js';
+export * from './config-data.js';
+export * from './cosmiconfig-result.js';

package/lib/types/index.js

@@ -1,2 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export * from './cli-build-options.js';
+export * from './command.js';
+export * from './config-data-library.js';
+export * from './config-data-typescript.js';
+export * from './config-data.js';
+export * from './cosmiconfig-result.js';