susee 2.0.4 → 2.1.0

package/dist/cli/index.mjs

@@ -0,0 +1,989 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import readline from 'node:readline/promises';
+import tcolor from '@suseejs/color';
+import ts6 from '@suseejs/ts6';
+import { LogTimer, logError, logInfo, suseeBundler } from '@suseejs/susee_bundler';
+import { minify } from 'oxc-minify';
+//src/cli/init.ts
+const tsFileText = `
+import type { SuSeeConfig } from "susee";
+const config: SuSeeConfig = {
+  // Array of entry point objects.
+  // ----------------------------
+  entryPoints: [
+    // You can add more entry points for different export paths.
+    // NOTE: duplicate export paths are not allowed.
+    // --------------------------------------------
+    {
+      // (required) Entry file path.
+      entry: "src/index.ts", // replace with your entry file
+      // (required) Export path for this entry.
+      exportPath: ".", // "." stands for the main export path and can be set to "./foo", "./bar", etc.
+      // (optional) Output module formats ["commonjs"] or ["esm", "commonjs"], default: ["esm"].
+      // Uncomment the following line to edit.
+      //format: ["esm"],
+      // (optional) Custom tsconfig.json path, default: undefined.
+      // Uncomment the following line to edit.
+      //tsconfigFilePath: undefined,
+      // (optional)Lint checks to run on the bundled output.
+      // Uncomment the following line to edit.
+      //checks:{ checkAnonymous: false, checkDefaultExports: false, checkNpmInstalled: false }.
+      // (optional) Minify the bundled output.
+      // Pass true for default minification, or an object with custom MinifyOptions.
+      // Uncomment the following line to edit.
+      //minify: false,
+    },
+  ],
+  // NOTE: the following options apply to all entry points.
+  // ----------------------------------------------------------
+  // (optional) Output directory, default: dist.
+  // Uncomment the following line to edit.
+  //outDir: "dist",
+  // (optional) Allow susee to update your package.json, default: false.
+  // Uncomment the following line to edit.
+  //allowUpdatePackageJson: false,
+};
+export default config;
+`.trim();
+const jsFileText = `
+/**
+ * @type {import("susee").SuSeeConfig}
+ */
+const config = {
+  // Array of entry point objects.
+  // ----------------------------
+  entryPoints: [
+    // You can add more entry points for different export paths.
+    // NOTE: duplicate export paths are not allowed.
+    // --------------------------------------------
+    {
+      // (required) Entry file path.
+      entry: "src/index.ts", // replace with your entry file
+      // (required) Export path for this entry.
+      exportPath: ".", // "." stands for the main export path and can be set to "./foo", "./bar", etc.
+      // (optional) Output module formats ["commonjs"] or ["esm", "commonjs"], default: ["esm"].
+      // Uncomment the following line to edit.
+      //format: ["esm"],
+      // (optional) Custom tsconfig.json path, default: undefined.
+      // Uncomment the following line to edit.
+      //tsconfigFilePath: undefined,
+      // (optional)Lint checks to run on the bundled output.
+      // Uncomment the following line to edit.
+      //checks:{ checkAnonymous: false, checkDefaultExports: false, checkNpmInstalled: false }.
+      // (optional) Minify the bundled output.
+      // Pass true for default minification, or an object with custom MinifyOptions.
+      // Uncomment the following line to edit.
+      //minify: false,
+    },
+  ],
+  // NOTE: the following options apply to all entry points.
+  // ----------------------------------------------------------
+  // (optional) Output directory, default: dist.
+  // Uncomment the following line to edit.
+  //outDir: "dist",
+  // (optional) Allow susee to update your package.json, default: false.
+  // Uncomment the following line to edit.
+  //allowUpdatePackageJson: false,
+};
+export default config;
+`.trim();
+async function getPackageType() {
+    const pkgPath = path.resolve(process.cwd(), 'package.json');
+    const _pkg = await fs.promises.readFile(pkgPath, 'utf8');
+    const pkg = JSON.parse(_pkg);
+    return pkg.type === 'module' ? 'esm' : 'commonjs';
+}
+async function cliInit() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    const is_ts = await rl.question('Is TypeScript Project(y/n) : ');
+    const isTs = !!(is_ts === 'y' || is_ts === 'Y' || is_ts === '');
+    rl.close();
+    let configFile = '';
+    let str = '';
+    if (isTs) {
+        configFile = 'susee.config.ts';
+        str = tsFileText;
+    }
+    else {
+        str = jsFileText;
+        const pkgType = await getPackageType();
+        switch (pkgType) {
+            case 'commonjs':
+                configFile = 'susee.config.mjs';
+                break;
+            case 'esm':
+                configFile = 'susee.config.js';
+                break;
+        }
+    }
+    const configFilePath = path.resolve(process.cwd(), configFile);
+    if (fs.existsSync(configFilePath))
+        await fs.promises.unlink(configFilePath);
+    await fs.promises.writeFile(configFilePath, str);
+    logInfo(`Done! Susee config file ${configFile} is created at project root.`);
+}
+/**
+* Finds the path of the susee.config file if it exists.
+* It checks for the existence of "susee.config.ts", "susee.config.js", and "susee.config.mjs" in the current working directory.
+* The first file found is returned.
+* @returns {string | undefined} - path to the susee.config file or undefined if it does not exist.
+*/
+const getSuseeConfigPath = () => {
+    const fileNames = [
+        'susee.config.ts',
+        'susee.config.js',
+        'susee.config.mjs'
+    ];
+    let configFile;
+    for (const file of fileNames) {
+        const filePath = path.resolve(process.cwd(), file);
+        if (fs.existsSync(filePath)) {
+            configFile = filePath;
+            break;
+        }
+    }
+    return configFile;
+};
+/**
+* Checks if the given entries have at least one entry and if there are any duplicate export paths.
+* If there are no entries, it will exit with code 1 and print an error message.
+* If there are any duplicate export paths, it will exit with code 1 and print an error message.
+* It will also check if each entry file exists, if not, it will exit with code 1 and print an error message.
+* @param {EntryPoint[]} entries - array of entry points
+*/
+function checkEntries(entries) {
+    if (entries.length < 1) {
+        const info = 'At least one entry required';
+        const cause = 'No entry found in susee.config file or build options';
+        logError(info, cause, true);
+    }
+    const objectStore = {};
+    const duplicateExportPaths = [];
+    for (const obj of entries) {
+        const value = obj.exportPath;
+        if (objectStore[value]) {
+            duplicateExportPaths.push(`"${value}"`);
+        }
+        else {
+            objectStore[value] = true;
+        }
+    }
+    if (duplicateExportPaths.length > 0) {
+        const info = 'Found duplicated export paths/path';
+        const cause = `Duplicate export paths/path (${duplicateExportPaths.join(',')}) found in your susee.config file or build options , that will error for bundled output`;
+        logError(info, cause, true);
+    }
+    for (const obj of entries) {
+        if (!fs.existsSync(path.resolve(process.cwd(), obj.entry))) {
+            const info = 'Entry file error';
+            const cause = `Entry file ${obj.entry} dose not exists.`;
+            logError(info, cause, true);
+        }
+    }
+}
+/**
+* Generates normalized build options from the user config.
+* It validates entry points, applies default values, removes duplicate formats,
+* resolves the output directory for each export path, and keeps duplicate declaration handling fail-fast.
+* @param {SuSeeConfig} config - raw susee configuration object.
+* @returns {BuildOptions} normalized build options for the compiler.
+*/
+function generateBuildOptions(config) {
+    const outDir = config.outDir ?? 'dist';
+    const points = [];
+    checkEntries(config.entryPoints);
+    for (const ent of config.entryPoints) {
+        const entry = ent.entry;
+        const exportPath = ent.exportPath;
+        const format = ent.format ? [...new Set(ent.format)] : ['esm'];
+        const tsconfigFilePath = ent.tsconfigFilePath ?? undefined;
+        const outputDirectoryPath = ent.exportPath === '.' ? outDir : `${outDir}${ent.exportPath.slice(1)}`;
+        const checks = {
+            checkAnonymous: ent.checks?.checkAnonymous ?? false,
+            checkDefaultExports: ent.checks?.checkDefaultExports ?? false,
+            checkNpmInstalled: ent.checks?.checkNpmInstalled ?? false
+        };
+        const minify = ent.minify ?? false;
+        points.push({
+            entry,
+            exportPath,
+            format,
+            outputDirectoryPath,
+            tsconfigFilePath,
+            checks,
+            minify
+        });
+    }
+    return {
+        buildEntryPoints: points,
+        updatePackage: config.allowUpdatePackageJson ?? false,
+        outDir
+    };
+}
+/**
+* Loads the susee config file from the current working directory and converts it into build options.
+* If no supported config file is found, it returns `undefined`.
+* @returns {Promise<BuildOptions | undefined>} normalized build options or undefined when no config file exists.
+*/
+async function finalSuseeConfig() {
+    const configPath = getSuseeConfigPath();
+    if (configPath) {
+        const _default = await import(configPath);
+        const config = _default.default;
+        return generateBuildOptions(config);
+    }
+}
+function fail(message) {
+    const info = message;
+    const cause = '';
+    logError(info, cause, true);
+}
+function isFile(entry) {
+    const exts = [
+        '.js',
+        '.ts',
+        '.mts',
+        '.mjs',
+        '.cjs',
+        '.cts',
+        '.tsx',
+        '.jsx'
+    ];
+    return exts.includes(path.extname(entry));
+}
+function isEmptyObject(entry) {
+    return typeof entry === 'object' && !Array.isArray(entry) && Object.keys(entry).length === 0;
+}
+function parseBooleanFlag(flag, value) {
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    fail(`Type of ${flag} must be boolean.`);
+}
+function parseArgs(argv) {
+    const opts = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index];
+        if (index === 0 && !argument.startsWith('--') && isFile(argument)) {
+            opts.entry = argument;
+            continue;
+        }
+        const [flag, inlineValue] = argument.split('=', 2);
+        const nextValue = argv[index + 1];
+        const value = inlineValue ?? nextValue;
+        switch (flag) {
+            case '--entry':
+                if (!value || value.startsWith('--'))
+                    fail('Entry point required.');
+                if (opts.entry && isFile(opts.entry))
+                    fail('Entry point already exists.');
+                opts.entry = value;
+                if (inlineValue === undefined) {
+                    index += 1;
+                }
+                break;
+            case '--outdir':
+                if (!value || value.startsWith('--'))
+                    fail('Output directory required.');
+                opts.outDir = value;
+                if (inlineValue === undefined) {
+                    index += 1;
+                }
+                break;
+            case '--format':
+                if (value !== 'cjs' && value !== 'commonjs' && value !== 'esm') {
+                    fail('Format must be cjs, commonjs, esm, both.');
+                }
+                opts.format = value === 'cjs' || value === 'commonjs' ? ['commonjs'] : value === 'esm' ? ['esm'] : value === 'both' ? ['commonjs', 'esm'] : undefined;
+                if (inlineValue === undefined) {
+                    index += 1;
+                }
+                break;
+            case '--tsconfig':
+                if (!value || value.startsWith('--'))
+                    fail('Tsconfig path required.');
+                opts.tsconfig = value;
+                if (inlineValue === undefined) {
+                    index += 1;
+                }
+                break;
+            case '--allow-update':
+                if (inlineValue !== undefined) {
+                    opts.allowUpdate = parseBooleanFlag('allow update', inlineValue);
+                }
+                else if (nextValue === 'true' || nextValue === 'false') {
+                    opts.allowUpdate = parseBooleanFlag('allow update', nextValue);
+                    index += 1;
+                }
+                else {
+                    opts.allowUpdate = true;
+                }
+                break;
+            case '--check':
+                if (inlineValue !== undefined) {
+                    opts.check = parseBooleanFlag('check', inlineValue);
+                }
+                else if (nextValue === 'true' || nextValue === 'false') {
+                    opts.check = parseBooleanFlag('check', nextValue);
+                    index += 1;
+                }
+                else {
+                    opts.check = true;
+                }
+                break;
+            case '--minify':
+                if (inlineValue !== undefined) {
+                    opts.minify = parseBooleanFlag('minify', inlineValue);
+                }
+                else if (nextValue === 'true' || nextValue === 'false') {
+                    opts.minify = parseBooleanFlag('minify', nextValue);
+                    index += 1;
+                }
+                else {
+                    opts.minify = true;
+                }
+                break;
+        }
+    }
+    return opts;
+}
+function cliConfig(argv) {
+    const cliOpts = parseArgs(argv);
+    if (isEmptyObject(cliOpts))
+        return undefined;
+    const point = {
+        entry: cliOpts.entry ?? '',
+        exportPath: '.',
+        format: cliOpts.format ?? ['esm'],
+        tsconfigFilePath: cliOpts.tsconfig ?? undefined,
+        minify: cliOpts.minify ?? false,
+        checks: {
+            checkAnonymous: cliOpts.check ? true : false,
+            checkDefaultExports: cliOpts.check ? true : false,
+            checkNpmInstalled: cliOpts.check ? true : false
+        }
+    };
+    if (point.entry === '')
+        return undefined;
+    const config = {
+        entryPoints: [point],
+        outDir: cliOpts.outDir ?? 'dist',
+        allowUpdatePackageJson: cliOpts.allowUpdate ?? false
+    };
+    return config;
+}
+//src/cli/print_help.ts
+function printHelp() {
+    console.log(`Susee CLI.
+Usage:
+  susee build                           Build using susee.config.{ts,js,mjs}
+  susee init                            Generate susee.config.{ts,js,mjs}
+  susee --help                          Show this message
+  susee build <entry> [options]         Build from a single entry file
+Options:
+  --entry <path>                       Entry file (optional if provided as positional <entry>)
+  --outdir <path>                      Output directory. (default to "dist")
+  --format <cjs|commonjs|esm>          Output module format. (default to ["esm"])
+  --tsconfig <path>                    Custom tsconfig path. (default to undefined)
+  --allow-update[=true|false]          Enable package.json update. (default to false)
+  --minify[=true|false]                Enable minify to output JS code.(default to false)
+  --check[=true|false]                Enable minify to output JS code.(default to false)
+Notes:
+  Duplicate top-level declarations fail the build with file and location output.
+  Rename conflicting declarations in source files before bundling.
+Examples:
+  susee build src/index.ts --outdir dist
+  susee build src/index.ts --format commonjs
+  susee build --entry src/index.ts --format esm --tsconfig tsconfig.build.json
+  susee build src/index.ts --profile
+`);
+}
+//src/helpers/files.ts
+var files;
+(function (files_1) {
+    const root = process.cwd();
+    function resolvePath(pathStr) {
+        return path.resolve(root, pathStr);
+    }
+    files_1.resolvePath = resolvePath;
+    function relativePath(pathStr) {
+        return path.relative(root, pathStr);
+    }
+    files_1.relativePath = relativePath;
+    function joinPath(...paths) {
+        return path.join(...paths);
+    }
+    files_1.joinPath = joinPath;
+    function existsPath(pathStr) {
+        return fs.existsSync(resolvePath(pathStr));
+    }
+    files_1.existsPath = existsPath;
+    async function deleteFile(filePath) {
+        if (existsPath(filePath)) {
+            await fs.promises.unlink(filePath);
+        }
+    }
+    files_1.deleteFile = deleteFile;
+    async function readFile(filePath) {
+        if (!existsPath(filePath)) {
+            console.error(tcolor.magenta(`> ${filePath} does not exists `));
+            process.exit(1);
+        }
+        filePath = resolvePath(filePath);
+        const readContent = await fs.promises.readFile(filePath);
+        return {
+            str: readContent.toString('utf8'),
+            bytes: readContent.byteLength
+        };
+    }
+    files_1.readFile = readFile;
+    async function readJsonFile(filePath) {
+        const read = await readFile(filePath);
+        return JSON.parse(read.str);
+    }
+    files_1.readJsonFile = readJsonFile;
+    async function createDirectory(dirPath) {
+        dirPath = resolvePath(dirPath);
+        if (!existsPath(dirPath)) {
+            await fs.promises.mkdir(dirPath, { recursive: true });
+        }
+    }
+    files_1.createDirectory = createDirectory;
+    function parentPath(filePath) {
+        return path.dirname(resolvePath(filePath));
+    }
+    files_1.parentPath = parentPath;
+    async function writeFile(filePath, content) {
+        if (existsPath(filePath))
+            await deleteFile(filePath);
+        await createDirectory(parentPath(filePath));
+        filePath = resolvePath(filePath);
+        await fs.promises.writeFile(filePath, content);
+    }
+    files_1.writeFile = writeFile;
+    async function clearFolder(folderPath) {
+        folderPath = resolvePath(folderPath);
+        try {
+            const entries = await fs.promises.readdir(folderPath, { withFileTypes: true });
+            await Promise.all(entries.map((entry) => fs.promises.rm(path.join(folderPath, entry.name), { recursive: true })));
+        }
+        catch (error) {
+            // biome-ignore lint/suspicious/noExplicitAny: error code
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+    }
+    files_1.clearFolder = clearFolder;
+    // -------------------------------------------------------------------------------------------//
+    const isCjs = (files) => files.commonjs && files.commonjsTypes;
+    const isEsm = (files) => files.esm && files.esmTypes;
+    function getExports(files, exportPath) {
+        return isCjs(files) && isEsm(files) ? { [exportPath]: {
+                import: {
+                    types: `./${path.relative(process.cwd(), files.esmTypes)}`,
+                    default: `./${path.relative(process.cwd(), files.esm)}`
+                },
+                require: {
+                    types: `./${path.relative(process.cwd(), files.commonjsTypes)}`,
+                    default: `./${path.relative(process.cwd(), files.commonjs)}`
+                }
+            } } : isCjs(files) && !isEsm(files) ? { [exportPath]: { require: {
+                    types: `./${path.relative(process.cwd(), files.commonjsTypes)}`,
+                    default: `./${path.relative(process.cwd(), files.commonjs)}`
+                } } } : !isCjs(files) && isEsm(files) ? { [exportPath]: { import: {
+                    types: `./${path.relative(process.cwd(), files.esmTypes)}`,
+                    default: `./${path.relative(process.cwd(), files.esm)}`
+                } } } : {};
+    }
+    async function writePackageJson(files, exportPath) {
+        let isMain = true;
+        if (exportPath !== '.') {
+            isMain = false;
+        }
+        const pkgFile = resolvePath('package.json');
+        const pkgtext = await readJsonFile(pkgFile);
+        let { name, version, description, main, module, type, types, exports, ...rest } = pkgtext;
+        type = 'module';
+        let _main = {};
+        let _module = {};
+        let _types = {};
+        let _exports = {};
+        if (isMain) {
+            _main = files.main ? { main: path.relative(process.cwd(), files.main) } : {};
+            _module = files.module ? { module: path.relative(process.cwd(), files.module) } : {};
+            _types = files.types ? { types: path.relative(process.cwd(), files.types) } : {};
+            _exports = { exports: { ...getExports(files, exportPath) } };
+        }
+        else {
+            _main = main ? { main } : {};
+            _module = module ? { module } : {};
+            _types = types ? { types } : {};
+            const normalizedExports = exports && typeof exports === 'object' && !Array.isArray(exports) ? { ...exports } : {};
+            _exports = { exports: {
+                    ...normalizedExports,
+                    ...getExports(files, exportPath)
+                } };
+        }
+        const pkgJson = {
+            name,
+            version,
+            description,
+            type,
+            ..._main,
+            ..._types,
+            ..._module,
+            ..._exports,
+            ...rest
+        };
+        await writeFile(pkgFile, JSON.stringify(pkgJson, null, 2));
+    }
+    files_1.writePackageJson = writePackageJson;
+})(files || (files = {}));
+/**
+* Normalizes TypeScript compiler options when JSX compilation is requested.
+*
+* For JSX input, this validates that the source imports either React runtime
+* modules or the configured `jsxImportSource` runtime package. When validation
+* passes, it enables DOM libs and defaults `jsx` to `ReactJSX` if unset.
+*
+* @param {string} sourceCode - Source text to inspect for JSX runtime imports.
+* @param {ts6.CompilerOptions} compilerOptions - User-provided compiler options.
+* @param {boolean} isJsx - Whether JSX mode is enabled for this compilation.
+* @returns {ts6.CompilerOptions} Compiler options to pass into program creation.
+*/
+function jsxCompilerOptions(sourceCode, compilerOptions, isJsx) {
+    if (!isJsx) {
+        return compilerOptions;
+    }
+    const reactRegexp = /import\s+(?:.*?)\s+from\s+(?:"react"|"react\/.*"|"react-dom\/.*"|"react-dom")/gm;
+    if (!reactRegexp.test(sourceCode)) {
+        if (!compilerOptions.jsxImportSource) {
+            console.error('[jsx-runtime-error]:\nJSX syntax found in bundled code,but its not react runtime,you need to be set jsxImportSource in tsconfig.');
+            process.exit(1);
+        }
+        const txt = compilerOptions.jsxImportSource;
+        const pattern = `import\\s+(?:.*?)\\s+from\\s+("${txt}"|"${txt}\\/.*")`;
+        const re = new RegExp(pattern, 'gm');
+        if (!re.test(sourceCode)) {
+            console.error('[jsx-runtime-mismatch-error]:\nJSX syntax found in bundled code,but its not react runtime and jsx-runtime from bundled code and jsxImportSource from tsconfig are mismatched.`');
+            process.exit(1);
+        }
+    }
+    // oxlint-disable-next-line no-unused-vars
+    const { jsx, lib, ...rest } = compilerOptions;
+    const _jsx = jsx ?? ts6.JsxEmit.ReactJSX;
+    return {
+        lib: [
+            'dom',
+            'dom.iterable',
+            'esnext'
+        ],
+        jsx: _jsx,
+        ...rest
+    };
+}
+/**
+* Creates a ts.CompilerHost that can be used with the typescript compiler.
+* This host is designed to be used with in-memory compilation and will
+* return the source file for the given fileName and will write all output
+* files to the createdFiles object.
+* @param {string} sourceCode - the source code to compile
+* @param {string} fileName - the name of the file to compile
+* @returns {{createdFiles: Record<string, string>, host: ts.CompilerHost}}
+*/
+function createHost(sourceCode, fileName) {
+    const createdFiles = {};
+    const host = {
+        getSourceFile: (file, languageVersion) => {
+            if (file === fileName) {
+                return ts6.createSourceFile(file, sourceCode, languageVersion);
+            }
+            return undefined;
+        },
+        writeFile: (fileName, contents) => {
+            createdFiles[fileName] = contents;
+        },
+        getDefaultLibFileName: (options) => ts6.getDefaultLibFilePath(options),
+        getCurrentDirectory: () => '',
+        getDirectories: () => [],
+        fileExists: (file) => file === fileName,
+        readFile: (file) => file === fileName ? sourceCode : undefined,
+        getCanonicalFileName: (file) => file,
+        useCaseSensitiveFileNames: () => true,
+        getNewLine: () => '\n'
+    };
+    return {
+        createdFiles,
+        host
+    };
+}
+function suseeCompiler({ sourceCode, fileName, compilerOptions, isJsx = false }) {
+    compilerOptions = jsxCompilerOptions(sourceCode, compilerOptions, isJsx);
+    // create host
+    const _host = createHost(sourceCode, fileName);
+    const createdFiles = _host.createdFiles;
+    const host = _host.host;
+    const program = ts6.createProgram([fileName], compilerOptions, host);
+    program.emit();
+    let dts;
+    let map;
+    let code = '';
+    let file_name = '';
+    let out_dir = '';
+    for (const key of Object.keys(createdFiles)) {
+        if (key.endsWith('.js'))
+            code = createdFiles[key];
+        if (key.endsWith('.d.ts'))
+            dts = createdFiles[key];
+        if (key.endsWith('.js.map'))
+            map = createdFiles[key];
+        file_name = path.basename(key).split('.')[0];
+        out_dir = path.dirname(key);
+    }
+    return {
+        code,
+        file_name,
+        out_dir,
+        dts,
+        map
+    };
+}
+//src/compiler/tsoptions.ts
+/**
+* Get the path of the configuration file.
+* If customConfigPath is provided and exists, use it.
+* If customConfigPath is not provided or does not exist, use the default configuration file.
+* @param {string | undefined} customConfigPath path of the custom configuration file.
+* @returns {string | undefined} path of the configuration file or undefined if customConfigPath does not exist.
+*/
+function getTsConfigPath(customConfigPath) {
+    let config_path;
+    if (customConfigPath) {
+        if (!ts6.sys.fileExists(ts6.sys.resolvePath(customConfigPath))) {
+            console.error(`> ${tcolor.magenta(`Given custom file ${customConfigPath} does not exists`)}`);
+            ts6.sys.exit(1);
+        }
+        config_path = customConfigPath;
+        return config_path;
+    }
+    else {
+        config_path = ts6.findConfigFile(ts6.sys.getCurrentDirectory(), ts6.sys.fileExists);
+        return config_path;
+    }
+}
+/**
+* Get the TypeScript compiler options for susee bundler.
+* @param {string | undefined} customConfigPath path of the custom configuration file.
+*/
+function getCompilerOptions(customConfigPath) {
+    let tsconfig_opts;
+    const config_path = getTsConfigPath(customConfigPath);
+    if (config_path) {
+        const config = ts6.readConfigFile(config_path, ts6.sys.readFile);
+        const basePath = path.dirname(config_path);
+        const parsed = ts6.parseJsonConfigFileContent(config.config, ts6.sys, basePath);
+        tsconfig_opts = { ...parsed.options };
+    }
+    const commonjs = (out_dir) => {
+        const _out = out_dir ? out_dir : 'dist';
+        if (tsconfig_opts !== undefined) {
+            // oxlint-disable-next-line no-unused-vars
+            const { rootDir, outDir, module, allowJs, declarationDir, ...rest } = tsconfig_opts;
+            return {
+                outDir: _out,
+                module: ts6.ModuleKind.CommonJS,
+                allowJs: true,
+                ...rest
+            };
+        }
+        else {
+            return {
+                outDir: _out,
+                module: ts6.ModuleKind.CommonJS,
+                target: ts6.ScriptTarget.Latest
+            };
+        }
+    };
+    const esm = (out_dir) => {
+        const _out = out_dir ? out_dir : 'dist';
+        if (tsconfig_opts !== undefined) {
+            // oxlint-disable-next-line no-unused-vars
+            const { rootDir, outDir, module, allowJs, declarationDir, ...rest } = tsconfig_opts;
+            return {
+                outDir: _out,
+                module: ts6.ModuleKind.ES2020,
+                allowJs: true,
+                ...rest
+            };
+        }
+        else {
+            return {
+                outDir: _out,
+                module: ts6.ModuleKind.ES2020,
+                target: ts6.ScriptTarget.Latest
+            };
+        }
+    };
+    const defaultOptions = ts6.getDefaultCompilerOptions;
+    return {
+        commonjs,
+        esm,
+        defaultOptions
+    };
+}
+//src/bundler.ts
+function bundler(point) {
+    const bundledCodeCache = new WeakMap();
+    const root = process.cwd();
+    let bundledCode = bundledCodeCache.get(point);
+    if (!bundledCode) {
+        bundledCode = suseeBundler(point.entry, root, point.checks).bundledCode;
+        bundledCodeCache.set(point, bundledCode);
+    }
+    return bundledCode;
+}
+//src/helpers/minify.ts
+async function oxcMinify(fileName, code, point) {
+    const options = typeof point.minify === 'object' && typeof point.minify !== 'boolean' ? point.minify.options : undefined;
+    const result = await minify(fileName, code, options);
+    return result.code;
+}
+//src/compiler/index.ts
+//import { utils } from "../helpers/utilities.js";
+/**
+* Checks if the given code string contains JSX syntax.
+* @param code The content of the file as a string.
+* @returns true if the file contains JSX, false otherwise.
+*/
+function isJsxContent(code) {
+    const sourceFile = ts6.createSourceFile('file.tsx', code, ts6.ScriptTarget.Latest, 
+    /*setParentNodes*/
+    true, ts6.ScriptKind.TSX);
+    let containsJsx = false;
+    function visitor(node) {
+        // Check for JSX Elements, Self Closing Elements, or JSX Fragments
+        if (ts6.isJsxElement(node) || ts6.isJsxSelfClosingElement(node) || ts6.isJsxFragment(node)) {
+            containsJsx = true;
+            return;
+        }
+        ts6.forEachChild(node, visitor);
+    }
+    visitor(sourceFile);
+    return containsJsx;
+}
+/**
+* Compiler for the JavaScript API.
+* It bundles each configured entry point, emits CommonJS and ESM outputs,
+* and optionally updates package export metadata.
+*/
+class Compiler {
+    _files;
+    _object;
+    /**
+    * Creates a compiler instance with normalized build options.
+    * @param {BuildOptions} object - build options generated from the susee config.
+    */
+    constructor(object) {
+        this._object = object;
+        this._files = {
+            commonjs: undefined,
+            commonjsTypes: undefined,
+            esm: undefined,
+            esmTypes: undefined,
+            main: undefined,
+            module: undefined,
+            types: undefined
+        };
+    }
+    _update() {
+        return this._object.updatePackage;
+    }
+    async _commonjs(point, bundledCode) {
+        const isMain = point.exportPath === '.';
+        const opts = getCompilerOptions(point.tsconfigFilePath);
+        const compilerOptions = opts.commonjs(point.outputDirectoryPath);
+        const is_jsx = isJsxContent(bundledCode);
+        const compiled = suseeCompiler({
+            sourceCode: bundledCode,
+            fileName: point.entry,
+            compilerOptions,
+            isJsx: is_jsx
+        });
+        let compiledCode = compiled.code;
+        const mainFilePath = files.joinPath(compiled.out_dir, `${compiled.file_name}.cjs`);
+        const dtsFilePath = files.joinPath(compiled.out_dir, `${compiled.file_name}.d.cts`);
+        const mapFilePath = files.joinPath(compiled.out_dir, `${compiled.file_name}.cjs.map`);
+        // replace source mapping url
+        compiledCode = compiledCode.replace(new RegExp(`${compiled.file_name}.js.map`, 'gm'), `${compiled.file_name}.cjs.map`);
+        if (point.minify) {
+            compiledCode = await oxcMinify(`${compiled.file_name}.cjs`, compiledCode, point);
+        }
+        // if allow update create file object
+        if (this._update()) {
+            this._files.commonjs = mainFilePath;
+            if (compiled.dts) {
+                this._files.commonjsTypes = dtsFilePath;
+            }
+            if (isMain && point.format.includes('commonjs')) {
+                if (this._files.commonjs)
+                    this._files.main = this._files.commonjs;
+                if (this._files.commonjsTypes)
+                    this._files.types = this._files.commonjsTypes;
+            }
+        }
+        await files.writeFile(mainFilePath, compiledCode);
+        if (compiled.dts)
+            await files.writeFile(dtsFilePath, compiled.dts);
+        if (compiled.map)
+            await files.writeFile(mapFilePath, compiled.map);
+    }
+    async _esm(point, bundledCode) {
+        const isMain = point.exportPath === '.';
+        const opts = getCompilerOptions(point.tsconfigFilePath);
+        const compilerOptions = opts.esm(point.outputDirectoryPath);
+        const is_jsx = isJsxContent(bundledCode);
+        const compiled = suseeCompiler({
+            sourceCode: bundledCode,
+            fileName: point.entry,
+            compilerOptions,
+            isJsx: is_jsx
+        });
+        let compiledCode = compiled.code;
+        const mainFilePath = files.joinPath(compiled.out_dir, `${compiled.file_name}.mjs`);
+        const dtsFilePath = files.joinPath(compiled.out_dir, `${compiled.file_name}.d.mts`);
+        const mapFilePath = files.joinPath(compiled.out_dir, `${compiled.file_name}.mjs.map`);
+        compiledCode = compiledCode.replace(new RegExp(`${compiled.file_name}.js.map`, 'gm'), `${compiled.file_name}.mjs.map`);
+        if (point.minify) {
+            compiledCode = await oxcMinify(`${compiled.file_name}.mjs`, compiledCode, point);
+        }
+        if (this._update()) {
+            this._files.esm = mainFilePath;
+            if (compiled.dts) {
+                this._files.esmTypes = dtsFilePath;
+            }
+            if (isMain && this._files.esm) {
+                this._files.module = this._files.esm;
+            }
+        }
+        await files.writeFile(mainFilePath, compiledCode);
+        if (compiled.dts)
+            await files.writeFile(dtsFilePath, compiled.dts);
+        if (compiled.map)
+            await files.writeFile(mapFilePath, compiled.map);
+    }
+    /**
+    * Clears the output directory and compiles all configured entry points.
+    * It also updates package.json export fields when package updates are enabled.
+    * @returns {Promise<void>}
+    */
+    async compile() {
+        await files.clearFolder(this._object.outDir);
+        for (const point of this._object.buildEntryPoints) {
+            const bundleCode = bundler(point);
+            for (const format of point.format) {
+                switch (format) {
+                    case 'commonjs':
+                        await this._commonjs(point, bundleCode);
+                        if (this._update()) {
+                            await files.writePackageJson(this._files, point.exportPath);
+                        }
+                        break;
+                    case 'esm':
+                        await this._esm(point, bundleCode);
+                        if (this._update()) {
+                            await files.writePackageJson(this._files, point.exportPath);
+                        }
+                        break;
+                }
+            }
+        }
+    }
+}
+//src/build.ts
+/**
+* Run a Susee build.
+*
+* Resolution order:
+* 1. Use `options` when provided.
+* 2. Otherwise try loading root config via `finalSuseeConfig()`.
+*
+* If neither source is available, this logs an error and exits with code 1.
+*/
+async function build(options) {
+    const buildTime = new LogTimer();
+    let buildOptions = {};
+    const _buildOptions = await finalSuseeConfig();
+    if (!options && !_buildOptions) {
+        const info = 'Required build options or susee config file at root.You can use `npx susee init` to create susee config file at root';
+        const cause = 'No build options or susee config file at root.';
+        logError(info, cause, true);
+    }
+    if (options) {
+        buildOptions = generateBuildOptions(options);
+    }
+    else if (_buildOptions) {
+        buildOptions = _buildOptions;
+    }
+    const compiler = new Compiler(buildOptions);
+    await compiler.compile();
+    buildTime.buildTime();
+}
+//src/cli/index.ts
+async function getPackageVersion() {
+    const pkgPath = path.resolve(process.cwd(), 'package.json');
+    const _pkg = await fs.promises.readFile(pkgPath, 'utf8');
+    const pkg = JSON.parse(_pkg);
+    return pkg.version;
+}
+function errorLog() {
+    printHelp();
+    const info = 'Unknown CLI usage';
+    const cause = '';
+    logError(info, cause, true);
+}
+async function cliBuild() {
+    const args = process.argv.slice(2);
+    const version = await getPackageVersion();
+    if (args.length === 0) {
+        errorLog();
+    }
+    else if (args.length === 1) {
+        const arg0 = args[0];
+        switch (arg0) {
+            case 'build':
+                await build();
+                break;
+            case 'init':
+                await cliInit();
+                break;
+            case '--version':
+            case '-v':
+                logInfo(`susee v${version}`);
+                break;
+            case '--help':
+            case '-h':
+                printHelp();
+                break;
+            default:
+                printHelp();
+                break;
+        }
+    }
+    else if (args.length > 1 && args[0] === 'build') {
+        const restArgs = args.slice(1);
+        const config = cliConfig(restArgs);
+        await build(config);
+    }
+    else {
+        errorLog();
+    }
+}
+cliBuild();
+//# sourceMappingURL=index.mjs.map