rsbuild-plugin-arethetypeswrong 0.2.0 → 0.3.0

package/dist/453.js

@@ -1,26 +1,185 @@
-const problemFlags = {
-    NoResolution: "no-resolution",
-    UntypedResolution: "untyped-resolution",
-    FalseCJS: "false-cjs",
-    FalseESM: "false-esm",
-    CJSResolvesToESM: "cjs-resolves-to-esm",
-    FallbackCondition: "fallback-condition",
-    CJSOnlyExportsDefault: "cjs-only-exports-default",
-    NamedExports: "named-exports",
-    FalseExportDefault: "false-export-default",
-    MissingExportEquals: "missing-export-equals",
-    UnexpectedModuleSyntax: "unexpected-module-syntax",
-    InternalResolutionError: "internal-resolution-error"
-};
-const resolutionKinds = {
-    node10: "node10",
-    "node16-cjs": "node16 (from CJS)",
-    "node16-esm": "node16 (from ESM)",
-    bundler: "bundler"
-};
-const moduleKinds = {
-    1: "(CJS)",
-    99: "(ESM)",
-    "": ""
-};
-export { moduleKinds, problemFlags, resolutionKinds };
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { logger } from "@rsbuild/core";
+import { createRequire as __rspack_createRequire } from "node:module";
+const __rspack_createRequire_require = __rspack_createRequire(import.meta.url);
+var __webpack_modules__ = {};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+__webpack_require__.m = __webpack_modules__;
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.add = function(modules) {
+        Object.assign(__webpack_require__.m, modules);
+    };
+})();
+var __webpack_require__temp = __webpack_require__;
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    var installedChunks = {
+        410: 0,
+        453: 0
+    };
+    var installChunk = (data)=>{
+        var __rspack_esm_ids = data.__rspack_esm_ids;
+        var __webpack_modules__ = data.__webpack_modules__;
+        var __rspack_esm_runtime = data.__rspack_esm_runtime;
+        var moduleId, chunkId, i = 0;
+        for(moduleId in __webpack_modules__)if (__webpack_require__.o(__webpack_modules__, moduleId)) __webpack_require__.m[moduleId] = __webpack_modules__[moduleId];
+        if (__rspack_esm_runtime) __rspack_esm_runtime(__webpack_require__);
+        for(; i < __rspack_esm_ids.length; i++){
+            chunkId = __rspack_esm_ids[i];
+            if (__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) installedChunks[chunkId][0]();
+            installedChunks[__rspack_esm_ids[i]] = 0;
+        }
+    };
+    __webpack_require__.C = installChunk;
+})();
+__webpack_require__.add({
+    "module?f4c0" (module) {
+        module.exports = __rspack_createRequire_require("module");
+    },
+    os (module) {
+        module.exports = __rspack_createRequire_require("os");
+    },
+    util (module) {
+        module.exports = __rspack_createRequire_require("util");
+    }
+});
+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;
+            api.onAfterBuild({
+                handler: async ({ isFirstCompile, isWatch })=>{
+                    const env = {
+                        stack: [],
+                        error: void 0,
+                        hasError: false
+                    };
+                    try {
+                        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}...`);
+                        logger.info("");
+                        logger.debug(`[arethetypeswrong] Running npm pack from ${rootPath}`);
+                        const { createTarball } = await import("./createTarball.js");
+                        const tarball = _ts_add_disposable_resource(env, await createTarball(rootPath, packageJson), true);
+                        logger.debug("[arethetypeswrong] npm pack success");
+                        const { checkPackage, createPackageFromTarballData } = await import("./@arethetypeswrong/core.js");
+                        const pkg = createPackageFromTarballData(node_fs.readFileSync(tarball.path));
+                        const result = await checkPackage(pkg);
+                        const { render } = await import("./render.js");
+                        const message = render(result, options.areTheTypesWrongOptions ?? {});
+                        const { getExitCode } = await import("./getExitCode.js");
+                        const exitCode = getExitCode(result, options.areTheTypesWrongOptions);
+                        const hasErrors = 0 !== exitCode;
+                        if (hasErrors) {
+                            logger.error(message);
+                            if (!isWatch) throw new Error("arethetypeswrong failed!");
+                            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 { __webpack_require__temp as __webpack_require__, __webpack_require__, pluginAreTheTypesWrong };

package/dist/854.js

@@ -0,0 +1,156 @@
+import { getResolutionKinds } from "./utils.js";
+const problemKindInfo = {
+    NoResolution: {
+        emoji: "💀",
+        title: "Resolution failed",
+        shortDescription: "Resolution failed",
+        description: "Import failed to resolve to type declarations or JavaScript files.",
+        docsUrl: "https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/NoResolution.md"
+    },
+    UntypedResolution: {
+        emoji: "❌",
+        title: "Could not find types",
+        shortDescription: "No types",
+        description: "Import resolved to JavaScript files, but no type declarations were found.",
+        docsUrl: "https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/UntypedResolution.md"
+    },
+    FalseCJS: {
+        emoji: "🎭",
+        title: "Types are CJS, but implementation is ESM",
+        shortDescription: "Masquerading as CJS",
+        description: "Import resolved to a CommonJS type declaration file, but an ESM JavaScript file.",
+        docsUrl: "https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/FalseCJS.md"
+    },
+    FalseESM: {
+        emoji: "👺",
+        title: "Types are ESM, but implementation is CJS",
+        shortDescription: "Masquerading as ESM",
+        description: "Import resolved to an ESM type declaration file, but a CommonJS JavaScript file.",
+        docsUrl: "https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/FalseESM.md"
+    },
+    NamedExports: {
+        emoji: "🕵️",
+        title: "Named exports cannot be detected by Node.js",
+        shortDescription: "Named exports",
+        description: "TypeScript allows ESM named imports of the properties of this CommonJS module, but they will crash at runtime because they don’t exist or can’t be statically detected by Node.js in the JavaScript file.",
+        details: "the list of exports TypeScript can see but Node.js cannot",
+        docsUrl: "https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/NamedExports.md"
+    },
+    CJSResolvesToESM: {
+        emoji: "⚠️",
+        title: "Entrypoint is ESM-only",
+        shortDescription: "ESM (dynamic import only)",
+        description: "A `require` call resolved to an ESM JavaScript file, which is an error in Node and some bundlers. CommonJS consumers will need to use a dynamic import.",
+        docsUrl: "https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/CJSResolvesToESM.md"
+    },
+    FallbackCondition: {
+        emoji: "🐛",
+        title: "Resolved through fallback condition",
+        shortDescription: "Used fallback condition",
+        description: "Import resolved to types through a conditional package.json export, but only after failing to resolve through an earlier condition. This behavior is a [TypeScript bug](https://github.com/microsoft/TypeScript/issues/50762). It may misrepresent the runtime behavior of this import and should not be relied upon.",
+        docsUrl: "https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/FallbackCondition.md"
+    },
+    CJSOnlyExportsDefault: {
+        emoji: "🤨",
+        title: "CJS module uses default export",
+        shortDescription: "CJS default export",
+        description: "CommonJS module simulates a default export with `exports.default` and `exports.__esModule`, but does not also set `module.exports` for compatibility with Node. Node, and [some bundlers under certain conditions](https://andrewbranch.github.io/interop-test/#synthesizing-default-exports-for-cjs-modules), do not respect the `__esModule` marker, so accessing the intended default export will require a `.default` property access on the default import.",
+        docsUrl: "https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/CJSOnlyExportsDefault.md"
+    },
+    FalseExportDefault: {
+        emoji: "❗️",
+        title: "Types incorrectly use default export",
+        shortDescription: "Incorrect default export",
+        description: "The resolved types use `export default` where the JavaScript file appears to use `module.exports =`. This will cause TypeScript under the `node16` module mode to think an extra `.default` property access is required, but that will likely fail at runtime. These types should use `export =` instead of `export default`.",
+        docsUrl: "https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/FalseExportDefault.md"
+    },
+    MissingExportEquals: {
+        emoji: "❓",
+        title: "Types are missing an `export =`",
+        shortDescription: "Missing `export =`",
+        description: "The JavaScript appears to set both `module.exports` and `module.exports.default` for improved compatibility, but the types only reflect the latter (by using `export default`). This will cause TypeScript under the `node16` module mode to think an extra `.default` property access is required, which will work at runtime but is not necessary. These types should `export =` an object with a `default` property instead of using `export default`.",
+        docsUrl: "https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/MissingExportEquals.md"
+    },
+    UnexpectedModuleSyntax: {
+        emoji: "🚭",
+        title: "Syntax is incompatible with detected module kind",
+        shortDescription: "Unexpected module syntax",
+        description: "Syntax detected in the module is incompatible with the module kind according to the package.json or file extension. This is an error in Node and may cause problems in some bundlers.",
+        docsUrl: "https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/UnexpectedModuleSyntax.md"
+    },
+    InternalResolutionError: {
+        emoji: "🥴",
+        title: "Internal resolution error",
+        shortDescription: "Internal resolution error",
+        description: "Import found in a type declaration file failed to resolve. Either this indicates that runtime resolution errors will occur, or (more likely) the types misrepresent the contents of the JavaScript files.",
+        details: "the imports that failed to resolve",
+        docsUrl: "https://github.com/arethetypeswrong/arethetypeswrong.github.io/blob/main/docs/problems/InternalResolutionError.md"
+    }
+};
+Object.keys(problemKindInfo);
+function filterProblems(...args) {
+    const [problems, analysis, filter] = 2 === args.length ? [
+        args[0].problems,
+        ...args
+    ] : args;
+    return problems.filter((p)=>{
+        if (filter.kind && !filter.kind.includes(p.kind)) return false;
+        if (filter.entrypoint && filter.resolutionKind) return problemAffectsEntrypointResolution(p, filter.entrypoint, filter.resolutionKind, analysis);
+        if (filter.entrypoint && filter.resolutionOption) return getResolutionKinds(filter.resolutionOption).every((resolutionKind)=>problemAffectsEntrypointResolution(p, filter.entrypoint, resolutionKind, analysis));
+        if (filter.entrypoint) return problemAffectsEntrypoint(p, filter.entrypoint, analysis);
+        if (filter.resolutionKind) return problemAffectsResolutionKind(p, filter.resolutionKind, analysis);
+        return true;
+    });
+}
+function problemAffectsResolutionKind(problem, resolutionKind, analysis) {
+    var _a;
+    const index = getProblemIndex(analysis, problem);
+    for (const entrypoint of Object.values(analysis.entrypoints))if (null == (_a = entrypoint.resolutions[resolutionKind].visibleProblems) ? void 0 : _a.includes(index)) return true;
+    return false;
+}
+function problemAffectsEntrypoint(problem, entrypoint, analysis) {
+    var _a;
+    const index = getProblemIndex(analysis, problem);
+    for (const resolution of Object.values(analysis.entrypoints[entrypoint].resolutions))if (null == (_a = resolution.visibleProblems) ? void 0 : _a.includes(index)) return true;
+    return false;
+}
+function problemAffectsEntrypointResolution(problem, entrypoint, resolutionKind, analysis) {
+    var _a, _b;
+    const index = getProblemIndex(analysis, problem);
+    return null != (_b = null == (_a = analysis.entrypoints[entrypoint].resolutions[resolutionKind].visibleProblems) ? void 0 : _a.includes(index)) ? _b : false;
+}
+function getProblemIndex(analysis, problem) {
+    let index = analysis.problems.indexOf(problem);
+    if (-1 === index) {
+        const serialized = JSON.stringify(problem);
+        index = analysis.problems.findIndex((p)=>JSON.stringify(p) === serialized);
+        if (-1 === index) throw new Error("Could not find problem in analysis");
+    }
+    return index;
+}
+const problemFlags = {
+    NoResolution: "no-resolution",
+    UntypedResolution: "untyped-resolution",
+    FalseCJS: "false-cjs",
+    FalseESM: "false-esm",
+    CJSResolvesToESM: "cjs-resolves-to-esm",
+    FallbackCondition: "fallback-condition",
+    CJSOnlyExportsDefault: "cjs-only-exports-default",
+    NamedExports: "named-exports",
+    FalseExportDefault: "false-export-default",
+    MissingExportEquals: "missing-export-equals",
+    UnexpectedModuleSyntax: "unexpected-module-syntax",
+    InternalResolutionError: "internal-resolution-error"
+};
+const resolutionKinds = {
+    node10: "node10",
+    "node16-cjs": "node16 (from CJS)",
+    "node16-esm": "node16 (from ESM)",
+    bundler: "bundler"
+};
+const moduleKinds = {
+    1: "(CJS)",
+    99: "(ESM)",
+    "": ""
+};
+export { filterProblems, moduleKinds, problemAffectsEntrypoint, problemAffectsResolutionKind, problemFlags, problemKindInfo, resolutionKinds };

package/dist/{727.js → @arethetypeswrong/core.js}

@@ -1,8 +1,8 @@
-/*! For license information please see 727.js.LICENSE.txt */
-import { __webpack_require__ } from "./rslib-runtime.js";
+/*! LICENSE: core.js.LICENSE.txt */
 import typescript from "typescript";
-import "./363.js";
-import { getResolutionOption, getResolutionKinds, visitResolutions, allBuildTools, resolvedThroughFallback } from "./520.js";
+import { createRequire } from "module";
+import { __webpack_require__ } from "../453.js";
+import { getResolutionOption, getResolutionKinds, visitResolutions, allBuildTools, resolvedThroughFallback } from "../utils.js";
 __webpack_require__.add({
     "./node_modules/.pnpm/@andrewbranch+untar.js@1.0.3/node_modules/@andrewbranch/untar.js/lib/bytestream.js" (module) {
         const ByteStream = function(ab, opt_offset, opt_length) {
@@ -100,7 +100,7 @@ __webpack_require__.add({
             const remaining = 512 - bstream.ptr % 512;
             if (remaining > 0 && remaining < 512) bstream.readBytes(remaining);
         }
-        module.exports.untar = function(arrayBuffer) {
+        module.exports.P = function(arrayBuffer) {
             const bstream = new ByteStream(arrayBuffer);
             const localFiles = [];
             while(0 != bstream.peekNumber(4)){
@@ -220,8 +220,7 @@ const cjsOnlyExportsDefault = defineCheck({
         }
     }
 });
-const external_module_ = __webpack_require__("module");
-var esm_require = (0, external_module_.createRequire)('/');
+var esm_require = createRequire('/');
 try {
     esm_require('worker_threads').Worker;
 } catch (e) {}
@@ -682,7 +681,7 @@ function extractTarball(tarball) {
     var _a;
     let unzipped;
     new esm_Gunzip((chunk)=>unzipped = chunk).push(tarball, true);
-    const data = (0, untar.untar)(unzipped);
+    const data = (0, untar.P)(unzipped);
     const prefix = data[0].filename.substring(0, data[0].filename.indexOf("/") + 1);
     const packageJsonText = null == (_a = data.find((f)=>f.filename === `${prefix}package.json`)) ? void 0 : _a.fileData;
     const packageJson = JSON.parse(new TextDecoder().decode(packageJsonText));