@driveflux/fab 1.0.0-next.0 → 1.0.0-next.2

package/dist/src/build.js

@@ -0,0 +1,737 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+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 _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 _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import fg from "fast-glob";
+import assert from "node:assert";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { clean } from "./clean.js";
+import { ensureDir, getDefaultOptions, runCommand, validatePackageJson } from "./utils.js";
+var glob = fg.glob;
+export var build = function() {
+    var _ref = _async_to_generator(function() {
+        var options, promises;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    options = _arguments.length > 0 && _arguments[0] !== void 0 ? _arguments[0] : getDefaultOptions();
+                    // Cleanup first
+                    return [
+                        4,
+                        clean(options)
+                    ];
+                case 1:
+                    _state.sent();
+                    promises = [];
+                    if (!options.noESM) {
+                        promises.push(buildEsm(options));
+                    }
+                    if (!options.noTypes) {
+                        promises.push(buildTypes(options));
+                    }
+                    if (!options.noCJS) {
+                        promises.push(buildCjs(options));
+                    }
+                    // Build necessary files
+                    return [
+                        4,
+                        Promise.all(promises)
+                    ];
+                case 2:
+                    _state.sent();
+                    // Make exports for CJS
+                    return [
+                        4,
+                        makeBaseExports(options)
+                    ];
+                case 3:
+                    _state.sent();
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return function build() {
+        return _ref.apply(this, arguments);
+    };
+}();
+export var buildTypes = function() {
+    var _ref = _async_to_generator(function() {
+        var options;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    options = _arguments.length > 0 && _arguments[0] !== void 0 ? _arguments[0] : getDefaultOptions();
+                    return [
+                        4,
+                        validatePackageJson({
+                            command: "tsc",
+                            cwd: options.cwd
+                        })
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        4,
+                        runCommand("pnpm", [
+                            "tsc",
+                            "--emitDeclarationOnly",
+                            "--declarationMap"
+                        ], {
+                            cwd: options.cwd
+                        })
+                    ];
+                case 2:
+                    _state.sent();
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return function buildTypes() {
+        return _ref.apply(this, arguments);
+    };
+}();
+export var buildCjs = function() {
+    var _ref = _async_to_generator(function() {
+        var options, _options_cwd, cwd, _options_destination, destination, cjsPath, targetPath;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    options = _arguments.length > 0 && _arguments[0] !== void 0 ? _arguments[0] : getDefaultOptions();
+                    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",
+                            "-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
+                    ];
+            }
+        });
+    });
+    return function buildCjs() {
+        return _ref.apply(this, arguments);
+    };
+}();
+export var makeBaseExports = function() {
+    var _ref = _async_to_generator(function() {
+        var options, _options_cwd, cwd, exp, _tmp, baseMap;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    options = _arguments.length > 0 && _arguments[0] !== void 0 ? _arguments[0] : getDefaultOptions();
+                    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 !== "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() {
+        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 !== "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)
+                    ];
+                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,
+                        ,
+                        3
+                    ]);
+                    return [
+                        4,
+                        fs.stat(targetFile)
+                    ];
+                case 1:
+                    if (_state.sent().isDirectory()) {
+                        return [
+                            2,
+                            "".concat(targetFile, "/index.").concat(extension)
+                        ];
+                    } else {
+                        return [
+                            2,
+                            "".concat(targetFile, ".").concat(extension)
+                        ];
+                    }
+                    return [
+                        3,
+                        3
+                    ];
+                case 2:
+                    e = _state.sent();
+                    return [
+                        2,
+                        "".concat(targetFile, ".").concat(extension)
+                    ];
+                case 3:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    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) {
+                        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() {
+        var options, _options_destination;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    options = _arguments.length > 0 && _arguments[0] !== void 0 ? _arguments[0] : getDefaultOptions();
+                    console.log("DESTINATION", options.destination, getDefaultOptions().destination);
+                    return [
+                        4,
+                        runCommand("pnpm", [
+                            "swc",
+                            "src",
+                            "-d",
+                            (_options_destination = options.destination) !== null && _options_destination !== void 0 ? _options_destination : getDefaultOptions().destination
+                        ], {
+                            cwd: options.cwd
+                        })
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return function buildEsm() {
+        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);
+    };
+}();