@driveflux/fab 1.0.10 → 2.1.0

package/dist/build.js

@@ -6,6 +6,9 @@ function _array_like_to_array(arr, len) {
 function _array_with_holes(arr) {
     if (Array.isArray(arr)) return arr;
 }
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
@@ -35,6 +38,9 @@ function _async_to_generator(fn) {
         });
     };
 }
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
 function _iterable_to_array_limit(arr, i) {
     var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
     if (_i == null) return;
@@ -62,12 +68,14 @@ function _iterable_to_array_limit(arr, i) {
 function _non_iterable_rest() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 function _sliced_to_array(arr, i) {
     return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
 }
-function _type_of(obj) {
-    "@swc/helpers - typeof";
-    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
 }
 function _unsupported_iterable_to_array(o, minLen) {
     if (!o) return;
@@ -172,14 +180,11 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
-import fg from 'fast-glob';
-import merge from 'lodash.merge';
-import assert from 'node:assert';
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import merge from 'lodash.merge';
 import { clean } from './clean.js';
-import { ensureDir, getDefaultOptions, runCommand, validatePackageJson } from './utils.js';
-var glob = fg.glob;
+import { ensureDir, getDefaultOptions, runBin, runCommand } from './utils.js';
 export var build = function() {
     var _ref = _async_to_generator(function(rawOptions) {
         var options, promises;
@@ -195,15 +200,10 @@ export var build = function() {
                 case 1:
                     _state.sent();
                     promises = [];
-                    if (!options.noESM) {
-                        promises.push(buildEsm(options));
-                    }
+                    promises.push(buildEsm(options));
                     if (!options.noTypes) {
                         promises.push(buildTypes(options));
                     }
-                    if (!options.noCJS) {
-                        promises.push(buildCjs(options));
-                    }
                     promises.push(copyVerbatim(options));
                     // Build necessary files
                     return [
@@ -212,18 +212,6 @@ export var build = function() {
                     ];
                 case 2:
                     _state.sent();
-                    if (!!options.noCJS) return [
-                        3,
-                        4
-                    ];
-                    return [
-                        4,
-                        makeBaseExports(options)
-                    ];
-                case 3:
-                    _state.sent();
-                    _state.label = 4;
-                case 4:
                     return [
                         2
                     ];
@@ -236,7 +224,7 @@ export var build = function() {
 }();
 export var copyVerbatim = function() {
     var _ref = _async_to_generator(function(rawOptions) {
-        var _options_copyVerbatim, options, _options_cwd, cwd, _options_destination, destination;
+        var _options_copyVerbatim, options, destination, guessTarget;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -245,40 +233,39 @@ export var copyVerbatim = function() {
                         3,
                         2
                     ];
-                    cwd = (_options_cwd = options.cwd) !== null && _options_cwd !== void 0 ? _options_cwd : process.cwd();
-                    destination = (_options_destination = options.destination) !== null && _options_destination !== void 0 ? _options_destination : getDefaultOptions().destination;
+                    destination = options.destination;
+                    guessTarget = function(copySource) {
+                        var relative = path.relative(options.source, copySource);
+                        var targetPath = path.resolve(destination, relative);
+                        if (!copySource.startsWith(options.source)) {
+                            throw new Error('The files to be copied must be a subdirectory of the source directory. Or you can provide a destination path using an array: { copyVerbatim: [source, target] }');
+                        }
+                        return targetPath;
+                    };
                     return [
                         4,
                         Promise.all(options.copyVerbatim.map(function() {
                             var _ref = _async_to_generator(function(fileOrFolderRaw) {
-                                var fileOrFolder, targetPath, targetPathCjs;
+                                var source, target, tagetBasedir;
                                 return _ts_generator(this, function(_state) {
                                     switch(_state.label){
                                         case 0:
-                                            fileOrFolder = "src/".concat(fileOrFolderRaw.replace(/^(\/)*src/, ''));
-                                            targetPath = path.resolve(destination, fileOrFolder).replace('/src', '');
-                                            targetPathCjs = path.resolve(destination, 'cjs', fileOrFolder).replace('/src', '');
+                                            source = typeof fileOrFolderRaw === 'string' ? fileOrFolderRaw : fileOrFolderRaw[0];
+                                            target = Array.isArray(fileOrFolderRaw) ? fileOrFolderRaw[1] : guessTarget(source);
+                                            tagetBasedir = path.dirname(target);
                                             return [
                                                 4,
-                                                ensureDir(path.dirname(targetPath))
+                                                ensureDir(path.dirname(tagetBasedir))
                                             ];
                                         case 1:
                                             _state.sent();
                                             return [
                                                 4,
-                                                fs.cp(path.resolve(cwd, fileOrFolder), targetPath, {
+                                                fs.cp(source, target, {
                                                     recursive: true
                                                 })
                                             ];
                                         case 2:
-                                            _state.sent();
-                                            return [
-                                                4,
-                                                fs.cp(path.resolve(cwd, fileOrFolder), targetPathCjs, {
-                                                    recursive: true
-                                                })
-                                            ];
-                                        case 3:
                                             _state.sent();
                                             return [
                                                 2
@@ -307,90 +294,23 @@ export var copyVerbatim = function() {
 }();
 export var buildTypes = function() {
     var _ref = _async_to_generator(function(rawOptions) {
-        var options;
+        var options, tsProject;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
                     options = merge({}, getDefaultOptions(), rawOptions);
-                    return [
-                        4,
-                        validatePackageJson({
-                            command: 'tsc',
-                            cwd: options.cwd
-                        })
-                    ];
-                case 1:
-                    _state.sent();
+                    tsProject = path.resolve(options.cwd, 'tsconfig.json');
                     return [
                         4,
                         runCommand('pnpm', [
                             'tsc',
+                            '--project',
+                            tsProject,
                             '--emitDeclarationOnly',
                             '--declarationMap'
-                        ], {
-                            cwd: options.cwd
-                        })
-                    ];
-                case 2:
-                    _state.sent();
-                    return [
-                        2
-                    ];
-            }
-        });
-    });
-    return function buildTypes(rawOptions) {
-        return _ref.apply(this, arguments);
-    };
-}();
-export var buildCjs = function() {
-    var _ref = _async_to_generator(function(rawOptions) {
-        var options, _options_cwd, cwd, _options_destination, destination, cjsPath, targetPath;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    options = merge({}, getDefaultOptions(), rawOptions);
-                    cwd = (_options_cwd = options.cwd) !== null && _options_cwd !== void 0 ? _options_cwd : process.cwd();
-                    destination = (_options_destination = options.destination) !== null && _options_destination !== void 0 ? _options_destination : getDefaultOptions().destination;
-                    cjsPath = path.resolve(destination, 'cjs');
-                    return [
-                        4,
-                        validatePackageJson({
-                            command: 'swc',
-                            cwd: cwd
-                        })
+                        ])
                     ];
                 case 1:
-                    _state.sent();
-                    // We start by emitting the CJS files
-                    return [
-                        4,
-                        runCommand("pnpm", [
-                            'swc',
-                            'src',
-                            '-C',
-                            'module.type=commonjs',
-                            '--strip-leading-paths',
-                            '-d',
-                            cjsPath
-                        ], {
-                            cwd: cwd
-                        })
-                    ];
-                case 2:
-                    _state.sent();
-                    targetPath = path.resolve(cwd, cjsPath, 'package.json');
-                    return [
-                        4,
-                        ensureDir(path.dirname(targetPath))
-                    ];
-                case 3:
-                    _state.sent();
-                    return [
-                        4,
-                        fs.writeFile(targetPath, '{\n  "type": "commonjs"\n}')
-                    ];
-                case 4:
                     _state.sent();
                     return [
                         2
@@ -398,390 +318,73 @@ export var buildCjs = function() {
             }
         });
     });
-    return function buildCjs(rawOptions) {
+    return function buildTypes(rawOptions) {
         return _ref.apply(this, arguments);
     };
 }();
-export var makeBaseExports = function() {
+export var buildEsm = function() {
     var _ref = _async_to_generator(function(rawOptions) {
-        var options, _options_cwd, cwd, exp, _tmp, baseMap;
+        var options, finalOptions, swcrc, e, isValid, compilerOptions;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
                     options = merge({}, getDefaultOptions(), rawOptions);
-                    cwd = (_options_cwd = options.cwd) !== null && _options_cwd !== void 0 ? _options_cwd : process.cwd();
-                    _tmp = options.exports;
-                    if (_tmp) return [
-                        3,
-                        2
-                    ];
-                    return [
-                        4,
-                        parseExports(cwd)
-                    ];
-                case 1:
-                    _tmp = _state.sent();
-                    _state.label = 2;
-                case 2:
-                    exp = _tmp;
-                    // Let's validate the exports
-                    if (!exp) {
-                        throw new Error('No exports found');
-                    }
-                    if ((typeof exp === "undefined" ? "undefined" : _type_of(exp)) !== 'object' && Array.isArray(exp)) {
-                        throw new Error('Exports must be an object');
-                    }
-                    return [
-                        4,
-                        Promise.all(Object.entries(exp).map(function(entry) {
-                            return processEntry(entry, options);
-                        }))
-                    ];
-                case 3:
-                    baseMap = _state.sent().flat();
-                    return [
-                        4,
-                        Promise.all(baseMap.map(function(param) {
-                            var targetFile = param.targetFile, content = param.content;
-                            return createBaseExportFile(targetFile, content, cwd);
-                        }))
-                    ];
-                case 4:
-                    return [
-                        2,
-                        _state.sent()
-                    ];
-            }
-        });
-    });
-    return function makeBaseExports(rawOptions) {
-        return _ref.apply(this, arguments);
-    };
-}();
-var createBaseExportFile = function() {
-    var _ref = _async_to_generator(function(targetFile, content, cwd) {
-        var targetPath;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    targetPath = path.resolve(cwd, targetFile);
-                    return [
-                        4,
-                        ensureDir(path.dirname(targetPath))
-                    ];
-                case 1:
-                    _state.sent();
-                    return [
-                        4,
-                        fs.writeFile(targetPath, content)
-                    ];
-                case 2:
-                    _state.sent();
-                    return [
-                        2,
-                        targetPath
-                    ];
-            }
-        });
-    });
-    return function createBaseExportFile(targetFile, content, cwd) {
-        return _ref.apply(this, arguments);
-    };
-}();
-var processEntry = function() {
-    var _ref = _async_to_generator(function(entry, options) {
-        var cjsExportsPromise, typesExportsPromise;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    cjsExportsPromise = Promise.resolve([]);
-                    if (!options.noCJS) {
-                        cjsExportsPromise = extractBaseExportsFromEntry(entry, 'cjs', options);
-                    }
-                    typesExportsPromise = Promise.resolve([]);
-                    if (!options.noTypes) {
-                        typesExportsPromise = extractBaseExportsFromEntry(entry, 'types', options);
-                    }
-                    return [
-                        4,
-                        Promise.all([
-                            cjsExportsPromise,
-                            typesExportsPromise
-                        ])
-                    ];
-                case 1:
-                    return [
-                        2,
-                        _state.sent().flat()
-                    ];
-            }
-        });
-    });
-    return function processEntry(entry, options) {
-        return _ref.apply(this, arguments);
-    };
-}();
-var extractBaseExportsFromEntry = function() {
-    var _ref = _async_to_generator(function(param, type, options) {
-        var _param, key, value, _options_cwd, cwd, hasWildcard, exportTypeKey, exportKeyValue, asteriskPosition, paths, targetFiles;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
-                    cwd = (_options_cwd = options.cwd) !== null && _options_cwd !== void 0 ? _options_cwd : process.cwd();
-                    assert([
-                        'cjs',
-                        'types'
-                    ].includes(type), "The type of the entry ".concat(key, ' must be "cjs" | "types". ').concat(type, " given"));
-                    // We need to make sure the * is ONLY once at most and is at the end of the key
-                    hasWildcard = /^[^*]*\*$/.test(key);
-                    if (key.includes('*') && !hasWildcard) {
-                        throw new Error("Only 1 wildcard at the end of the export path is allowed. Provided ".concat(key));
-                    }
-                    exportTypeKey = type === 'cjs' ? 'require' : 'types';
-                    if ((typeof value === "undefined" ? "undefined" : _type_of(value)) !== 'object' || !value || Array.isArray(value) || !(exportTypeKey in value) || typeof value[exportTypeKey] === 'undefined') {
-                        throw new Error("Missing key ".concat(exportTypeKey, " from the exports map of ").concat(key, ". If this is desired, then set it to null."));
-                    }
-                    exportKeyValue = value[exportTypeKey];
-                    if (exportKeyValue === null) {
-                        return [
-                            2,
-                            []
-                        ];
-                    }
-                    if (typeof exportKeyValue !== 'string') {
-                        throw new Error('Only strings are allowed in the "'.concat(exportTypeKey, '" field'));
-                    }
-                    asteriskPosition = exportKeyValue.replace('./', '').split('/').findIndex(function(p) {
-                        return p.startsWith('*');
-                    });
-                    return [
-                        4,
-                        parseExportPath(exportKeyValue, cwd)
-                    ];
+                    finalOptions = {
+                        '--out-dir': options.destination,
+                        '--strip-leading-paths': true
+                    };
+                    swcrc = path.resolve(options.cwd, '.swcrc');
+                    _state.label = 1;
                 case 1:
-                    paths = _state.sent();
-                    targetFiles = Promise.all(paths.map(function() {
-                        var _ref = _async_to_generator(function(p) {
-                            var finalKey, content, targetFile, geImportPaths, importPaths, relativeImportPath, importPaths1, relativeImportPath1, fileContent, exportObj;
-                            return _ts_generator(this, function(_state) {
-                                switch(_state.label){
-                                    case 0:
-                                        finalKey = key;
-                                        if (hasWildcard) {
-                                            finalKey = key.replace('*', p.split('/').slice(asteriskPosition, asteriskPosition + 1).join('/'));
-                                        }
-                                        if (finalKey === '.' || finalKey === './') {
-                                            finalKey = 'index';
-                                        }
-                                        content = '';
-                                        targetFile = '';
-                                        geImportPaths = function(importPath) {
-                                            var targetFile = path.resolve(cwd, importPath);
-                                            var importFromPath = path.dirname(targetFile);
-                                            var fullImportPath = path.resolve(cwd, p);
-                                            var relativeImportPath = path.relative(importFromPath, fullImportPath);
-                                            return {
-                                                relativeImportPath: relativeImportPath,
-                                                fullImportPath: fullImportPath,
-                                                targetFile: targetFile
-                                            };
-                                        };
-                                        if (!(type === 'cjs')) return [
-                                            3,
-                                            2
-                                        ];
-                                        return [
-                                            4,
-                                            resolvePathWithExtension(finalKey, 'cjs')
-                                        ];
-                                    case 1:
-                                        finalKey = _state.sent();
-                                        importPaths = geImportPaths(finalKey);
-                                        relativeImportPath = importPaths.relativeImportPath;
-                                        targetFile = importPaths.targetFile;
-                                        content = "module.exports = require('".concat(formatImportPath(relativeImportPath), "')");
-                                        _state.label = 2;
-                                    case 2:
-                                        if (!(type === 'types')) return [
-                                            3,
-                                            5
-                                        ];
-                                        return [
-                                            4,
-                                            resolvePathWithExtension(finalKey, 'd.ts')
-                                        ];
-                                    case 3:
-                                        finalKey = _state.sent();
-                                        importPaths1 = geImportPaths(finalKey);
-                                        relativeImportPath1 = importPaths1.relativeImportPath;
-                                        targetFile = importPaths1.targetFile;
-                                        // Typescript will complain about exprting .d.ts, so we just omt that
-                                        content = "export * from '".concat(formatImportPath(relativeImportPath1).replace('.d.ts', ''), "'");
-                                        return [
-                                            4,
-                                            fs.readFile(importPaths1.fullImportPath, 'utf-8')
-                                        ];
-                                    case 4:
-                                        fileContent = _state.sent();
-                                        if (/export default/.test(fileContent)) {
-                                            content += "\nexport { default } from '".concat(formatImportPath(relativeImportPath1), "'");
-                                        }
-                                        _state.label = 5;
-                                    case 5:
-                                        if (!content) {
-                                            throw new Error("No content found for ".concat(exportKeyValue));
-                                        }
-                                        exportObj = {
-                                            type: type,
-                                            targetFile: targetFile,
-                                            content: content
-                                        };
-                                        return [
-                                            2,
-                                            exportObj
-                                        ];
-                                }
-                            });
-                        });
-                        return function(p) {
-                            return _ref.apply(this, arguments);
-                        };
-                    }()));
-                    if (!targetFiles) {
-                        console.log("⚠️ No CJS target files for ".concat(key));
-                    }
-                    return [
-                        2,
-                        targetFiles
-                    ];
-            }
-        });
-    });
-    return function extractBaseExportsFromEntry(_, type, options) {
-        return _ref.apply(this, arguments);
-    };
-}();
-var resolvePathWithExtension = function() {
-    var _ref = _async_to_generator(function(targetFile, extension) {
-        var e;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
                     _state.trys.push([
-                        0,
-                        2,
+                        1,
+                        3,
                         ,
-                        3
+                        4
                     ]);
                     return [
                         4,
-                        fs.stat(targetFile)
-                    ];
-                case 1:
-                    if (_state.sent().isDirectory()) {
-                        return [
-                            2,
-                            "".concat(targetFile, "/index.").concat(extension)
-                        ];
-                    }
-                    return [
-                        3,
-                        3
+                        fs.stat(swcrc)
                     ];
                 case 2:
-                    e = _state.sent();
+                    _state.sent();
+                    finalOptions['--config-file'] = swcrc;
                     return [
                         3,
-                        3
+                        4
                     ];
                 case 3:
-                    if (targetFile.endsWith(extension)) {
-                        return [
-                            2,
-                            targetFile
-                        ];
-                    }
-                    if (targetFile.endsWith(".js")) {
-                        return [
-                            2,
-                            targetFile.replace(/\.js$/, ".".concat(extension))
-                        ];
-                    }
+                    e = _state.sent();
                     return [
-                        2,
-                        "".concat(targetFile, ".").concat(extension)
+                        3,
+                        4
                     ];
-            }
-        });
-    });
-    return function resolvePathWithExtension(targetFile, extension) {
-        return _ref.apply(this, arguments);
-    };
-}();
-var formatImportPath = function(exportPath) {
-    return exportPath.startsWith('.') ? exportPath : "./".concat(exportPath);
-};
-var parseExportPath = function() {
-    var _ref = _async_to_generator(function(exportPath) {
-        var cwd, split, files;
-        var _arguments = arguments;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    cwd = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : process.cwd();
-                    split = exportPath.split('*');
-                    if (split.length === 1) {
+                case 4:
+                    isValid = function(v) {
+                        return typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean' && v;
+                    };
+                    compilerOptions = Object.entries(finalOptions).map(function(param) {
+                        var _param = _sliced_to_array(param, 2), k = _param[0], v = _param[1];
                         return [
-                            2,
-                            [
-                                exportPath
-                            ]
-                        ];
-                    }
-                    // Allow only 1 * in the path
-                    if (split.length > 2) {
-                        throw new Error('Invalid export path. Only one * is allowed');
-                    }
-                    return [
-                        4,
-                        glob(exportPath)
-                    ];
-                case 1:
-                    files = _state.sent();
-                    return [
-                        2,
-                        files.map(function(f) {
-                            return path.relative(cwd, f);
-                        })
-                    ];
-            }
-        });
-    });
-    return function parseExportPath(exportPath) {
-        return _ref.apply(this, arguments);
-    };
-}();
-export var buildEsm = function() {
-    var _ref = _async_to_generator(function(rawOptions) {
-        var options, _options_destination;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    options = merge({}, getDefaultOptions(), rawOptions);
+                            k
+                        ].concat(_to_consumable_array(isValid(v) ? [
+                            typeof v === 'boolean' ? '' : "".concat(v)
+                        ] : [
+                            null
+                        ]));
+                    }).filter(function(param) {
+                        var _param = _sliced_to_array(param, 2), _ = _param[0], v = _param[1];
+                        return v !== null && v !== undefined;
+                    }).flat().filter(function(v) {
+                        return v !== '';
+                    });
                     return [
                         4,
-                        runCommand("pnpm", [
-                            'swc',
-                            'src',
-                            '--strip-leading-paths',
-                            '-d',
-                            (_options_destination = options.destination) !== null && _options_destination !== void 0 ? _options_destination : getDefaultOptions().destination
-                        ], {
-                            cwd: options.cwd
-                        })
+                        runBin('swc', [
+                            options.source
+                        ].concat(_to_consumable_array(compilerOptions)))
                     ];
-                case 1:
+                case 5:
                     _state.sent();
                     return [
                         2
@@ -793,31 +396,3 @@ export var buildEsm = function() {
         return _ref.apply(this, arguments);
     };
 }();
-var parseExports = function() {
-    var _ref = _async_to_generator(function() {
-        var cwd, pkg, _;
-        var _arguments = arguments;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    cwd = _arguments.length > 0 && _arguments[0] !== void 0 ? _arguments[0] : process.cwd();
-                    _ = JSON.parse;
-                    return [
-                        4,
-                        fs.readFile(path.join(cwd, 'package.json'), 'utf-8')
-                    ];
-                case 1:
-                    pkg = _.apply(JSON, [
-                        _state.sent()
-                    ]);
-                    return [
-                        2,
-                        pkg.exports
-                    ];
-            }
-        });
-    });
-    return function parseExports() {
-        return _ref.apply(this, arguments);
-    };
-}();