susee 2.0.3 → 2.0.4

package/dist/index.mjs

@@ -0,0 +1,651 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import tcolor from '@suseejs/color';
+import ts6 from '@suseejs/ts6';
+import { LogTimer, logError, suseeBundler } from '@suseejs/susee_bundler';
+import { minify } from 'oxc-minify';
+/**
+* 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);
+    }
+}
+//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();
+}
+export { build };
+//# sourceMappingURL=index.mjs.map