Fix bugs in createPackageFromNpm, allow resolveImplementationPackageForTypesPackage to accept a range

Author: andrewbranch

.changeset/wet-birds-marry.md

@@ -0,0 +1,5 @@
+---
+"@arethetypeswrong/core": patch
+---
+
+Fix bugs in createPackageFromNpm, allow resolveImplementationPackageForTypesPackage to accept a range

packages/core/src/createPackage.ts

@@ -2,7 +2,7 @@ import { untar } from "@andrewbranch/untar.js";
 import { gunzipSync } from "fflate";
 import ts from "typescript";
 import { parsePackageSpec, type ParsedPackageSpec } from "./utils.js";
-import { maxSatisfying, major, minor, valid, validRange } from "semver";
+import { maxSatisfying, major, minor, valid, validRange, coerce } from "semver";
 
 export class Package {
   #files: Record<string, string | Uint8Array> = {};
@@ -106,16 +106,16 @@ export async function createPackageFromNpm(
     throw new Error(parsed.error);
   }
   const packageName = parsed.data.name;
+  const typesPackageName = ts.getTypesPackageName(packageName);
   const { tarballUrl, packageVersion } =
     parsed.data.versionKind === "none" && typeof definitelyTyped === "string"
-      ? await resolveImplementationPackageForTypesPackage(packageName, definitelyTyped, { before })
+      ? await resolveImplementationPackageForTypesPackage(typesPackageName, definitelyTyped, { before })
       : await getNpmTarballUrl([parsed.data], before);
   const pkg = await createPackageFromTarballUrl(tarballUrl);
   if (!definitelyTyped || pkg.containsTypes()) {
     return pkg;
   }
 
-  const typesPackageName = ts.getTypesPackageName(packageName);
   let typesPackageData;
   if (definitelyTyped === true) {
     typesPackageData = await resolveTypesPackageForPackage(packageName, packageVersion, before);
@@ -147,14 +147,30 @@ export async function resolveImplementationPackageForTypesPackage(
     throw new Error(`'resolveImplementationPackageForTypesPackage' expects an @types package name and version`);
   }
   const packageName = ts.unmangleScopedPackageName(typesPackageName.slice("@types/".length));
-  return getNpmTarballUrl(
-    [
-      parsePackageSpec(`${packageName}@${major(typesPackageVersion)}.${minor(typesPackageVersion)}`).data!,
-      parsePackageSpec(`${packageName}@${major(typesPackageVersion)}`).data!,
-      parsePackageSpec(`${packageName}@latest`).data!,
-    ],
-    options?.before,
-  );
+  const version = valid(typesPackageVersion);
+  if (version) {
+    return getNpmTarballUrl(
+      [
+        parsePackageSpec(`${packageName}@${major(version)}.${minor(version)}`).data!,
+        parsePackageSpec(`${packageName}@${major(version)}`).data!,
+        parsePackageSpec(`${packageName}@latest`).data!,
+      ],
+      options?.before,
+    );
+  }
+
+  const range = validRange(typesPackageVersion);
+  if (range) {
+    return getNpmTarballUrl(
+      [
+        { name: packageName, versionKind: "range", version: range },
+        { name: packageName, versionKind: "tag", version: "latest" },
+      ],
+      options?.before,
+    );
+  }
+
+  throw new Error(`'resolveImplementationPackageForTypesPackage' expects a valid SemVer version or range`);
 }
 
 export async function resolveTypesPackageForPackage(

packages/web/src/main.ts

@@ -1,16 +1,24 @@
-import type { ResultMessage } from "../worker/worker.ts";
+import type { Message } from "../worker/worker.ts";
 import { subscribeRenderer } from "./renderer.ts";
 import { updateState, type PackageInfo, getState, subscribe, type State } from "./state.ts";
 import { shallowEqual } from "./utils/shallowEqual.ts";
 import NProgress from "nprogress";
 import { parsePackageSpec, type ParsedPackageSpec } from "@arethetypeswrong/core/utils";
 
 const worker = new Worker(new URL("../worker/worker.ts", import.meta.url), { type: "module" });
-worker.onmessage = async (event: MessageEvent<ResultMessage>) => {
+worker.onmessage = async (event: MessageEvent<Message>) => {
   updateState((state) => {
-    state.analysis = event.data.data.result;
-    state.isLoading = false;
-    state.message = undefined;
+    if (event.data.kind === "error") {
+      state.isLoading = false;
+      state.message = {
+        isError: true,
+        text: event.data.data.error,
+      };
+    } else {
+      state.analysis = event.data.data.result;
+      state.isLoading = false;
+      state.message = undefined;
+    }
   });
 
   const params = new URLSearchParams(location.search);
@@ -56,7 +64,6 @@ if (location.search) {
     onPackageNameInput(packageSpec);
     getPackageInfo().then(() => {
       const info = getState().packageInfo.info;
-      console.log(info);
       if (info && info.size && info.size < 1_000_000 && !navigator.connection?.saveData) {
         onCheck();
       }

packages/web/worker/worker.ts

@@ -16,29 +16,49 @@ export interface CheckFileEventData {
   file: Uint8Array;
 }
 
+export interface ErrorMessage {
+  kind: "error";
+  data: {
+    error: string;
+  };
+}
+
 export interface ResultMessage {
   kind: "result";
   data: {
     result: CheckResult;
   };
 }
 
+export type Message = ErrorMessage | ResultMessage;
+
 onmessage = async (event: MessageEvent<CheckPackageEventData | CheckFileEventData>) => {
-  const result = await checkPackage(
-    event.data.kind === "check-file"
-      ? createPackageFromTarballData(event.data.file)
-      : event.data.packageSpec.startsWith("@types/")
-      ? await createPackageFromNpm(getImplementationPackageName(event.data.packageSpec), {
-          definitelyTyped: parsePackageSpec(event.data.packageSpec).data?.version,
-        })
-      : await createPackageFromNpm(event.data.packageSpec),
-  );
-  postMessage({
-    kind: "result",
-    data: {
-      result,
-    },
-  } satisfies ResultMessage);
+  try {
+    const result = await checkPackage(
+      event.data.kind === "check-file"
+        ? createPackageFromTarballData(event.data.file)
+        : event.data.packageSpec.startsWith("@types/")
+        ? await createPackageFromNpm(getImplementationPackageName(event.data.packageSpec), {
+            definitelyTyped: parsePackageSpec(event.data.packageSpec).data?.version,
+          })
+        : await createPackageFromNpm(event.data.packageSpec),
+    );
+    postMessage({
+      kind: "result",
+      data: {
+        result,
+      },
+    } satisfies ResultMessage);
+  } catch (err) {
+    if (err instanceof Error) {
+      postMessage({
+        kind: "error",
+        data: {
+          error: err.message,
+        },
+      } satisfies ErrorMessage);
+    }
+  }
 };
 
 function getImplementationPackageName(typesPackageSpec: string): string {