rsbuild-plugin-arethetypeswrong 0.1.1 → 0.2.0

package/dist/131.js

@@ -0,0 +1,124 @@
+/*! For license information please see 131.js.LICENSE.txt */
+import node_fs from "node:fs";
+import node_path, { delimiter, dirname, normalize, resolve } from "node:path";
+function _ts_add_disposable_resource(env, value, async) {
+    if (null != value) {
+        if ("object" != typeof value && "function" != typeof value) throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (void 0 === dispose) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if ("function" != typeof dispose) throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() {
+            try {
+                inner.call(this);
+            } catch (e) {
+                return Promise.reject(e);
+            }
+        };
+        env.stack.push({
+            value: value,
+            dispose: dispose,
+            async: async
+        });
+    } else if (async) env.stack.push({
+        async: true
+    });
+    return value;
+}
+function src_ts_dispose_resources(env) {
+    var _SuppressedError = "function" == typeof SuppressedError ? SuppressedError : function(error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+    return (src_ts_dispose_resources = function(env) {
+        function fail(e) {
+            env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while(r = env.stack.pop())try {
+                if (!r.async && 1 === s) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                if (r.dispose) {
+                    var result = r.dispose.call(r.value);
+                    if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+                        fail(e);
+                        return next();
+                    });
+                } else s |= 1;
+            } catch (e) {
+                fail(e);
+            }
+            if (1 === s) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    })(env);
+}
+const pluginAreTheTypesWrong = (options = {})=>({
+        name: "plugin-arethetypeswrong",
+        setup (api) {
+            if (false === options.enable) return;
+            const logger = api.logger;
+            api.onAfterBuild({
+                handler: async ({ isFirstCompile, isWatch })=>{
+                    const env = {
+                        stack: [],
+                        error: void 0,
+                        hasError: false
+                    };
+                    try {
+                        /* node:coverage ignore if -- @preserve */ if (!isFirstCompile) return;
+                        const { rootPath } = api.context;
+                        const packageJson = JSON.parse(node_fs.readFileSync(node_path.join(rootPath, "package.json"), "utf-8"));
+                        const packageName = packageJson.name;
+                        const packageVersion = packageJson.version;
+                        logger.start(`[arethetypeswrong] Checking ${packageName}@${packageVersion}...`);
+                        console.info();
+                        logger.debug(`[arethetypeswrong] Running npm pack from ${rootPath}`);
+                        const { createTarball } = await import("./45.js").then((mod)=>({
+                                createTarball: mod.createTarball
+                            }));
+                        const tarball = _ts_add_disposable_resource(env, await createTarball(rootPath, packageJson), true);
+                        logger.debug("[arethetypeswrong] npm pack success");
+                        const { checkPackage, createPackageFromTarballData } = await import("./727.js").then((mod)=>({
+                                checkPackage: mod.checkPackage,
+                                createPackageFromTarballData: mod.createPackageFromTarballData
+                            }));
+                        const pkg = createPackageFromTarballData(node_fs.readFileSync(tarball.path));
+                        const result = await checkPackage(pkg);
+                        const { render } = await import("./356.js").then((mod)=>({
+                                render: mod.render
+                            }));
+                        const message = await render(result, options.areTheTypesWrongOptions ?? {});
+                        const { getExitCode } = await import("./408.js").then((mod)=>({
+                                getExitCode: mod.getExitCode
+                            }));
+                        const exitCode = getExitCode(result, options.areTheTypesWrongOptions);
+                        const hasErrors = 0 !== exitCode;
+                        if (hasErrors) {
+                            logger.error(message);
+                            /* node:coverage ignore next -- @preserve */ if (!isWatch) throw new Error("arethetypeswrong failed!");
+                            /* node:coverage ignore next -- @preserve */ return;
+                        }
+                        logger.success(message);
+                    } catch (e) {
+                        env.error = e;
+                        env.hasError = true;
+                    } finally{
+                        const result = src_ts_dispose_resources(env);
+                        if (result) await result;
+                    }
+                },
+                order: "post"
+            });
+        }
+    });
+export { delimiter, dirname, node_path, normalize, pluginAreTheTypesWrong, resolve };

package/dist/218.js

@@ -0,0 +1 @@
+export { cwd, default as node_process } from "node:process";