@fuman/build 0.0.1

package/jsr/deno-json.d.ts

@@ -0,0 +1,19 @@
+import { PackageJson } from '../package-json/types.js';
+export interface DenoJson {
+    name: string;
+    version: string;
+    exports?: Record<string, string>;
+    imports?: Record<string, string>;
+    exclude?: string[];
+    publish?: {
+        exclude?: string[];
+    };
+}
+export declare function packageJsonToDeno({ packageJson, packageJsonOrig, workspaceVersions, exclude, buildDirName, baseDir, }: {
+    packageJson: PackageJson;
+    packageJsonOrig: PackageJson;
+    workspaceVersions: Record<string, string>;
+    buildDirName: string;
+    baseDir?: string;
+    exclude?: string[];
+}): DenoJson;

package/jsr/deno-json.js

@@ -0,0 +1,80 @@
+import { asNonNull } from "@fuman/utils";
+function packageJsonToDeno({
+  packageJson,
+  packageJsonOrig,
+  workspaceVersions,
+  exclude,
+  buildDirName,
+  baseDir
+}) {
+  const importMap = {};
+  const exports = {};
+  for (const field of ["dependencies", "peerDependencies", "optionalDependencies"]) {
+    const deps = packageJson[field];
+    if (deps == null) continue;
+    for (const [name, version] of Object.entries(deps)) {
+      if (typeof version !== "string") continue;
+      if (name in workspaceVersions) {
+        continue;
+      } else if (version.startsWith("npm:@jsr/")) {
+        const jsrName = version.slice(9).split("@")[0].replace("__", "/");
+        const jsrVersion = version.slice(9).split("@")[1];
+        importMap[name] = `jsr:@${jsrName}@${jsrVersion}`;
+      } else if (name) {
+        let packageName = name;
+        let packageVersion = version;
+        if (version.startsWith("npm:")) {
+          const idx = packageName.indexOf("@");
+          if (idx === -1) {
+            throw new Error(`Invalid npm dependency: ${name}`);
+          }
+          packageVersion = packageName.slice(idx + 1);
+          packageName = packageName.slice(4, idx);
+        } else if (version.match(/\|\||&&|:/)) {
+          throw new Error(`Invalid npm dependency (not supported by JSR): ${name}@${version}`);
+        }
+        importMap[name] = `npm:${packageName}@${packageVersion}`;
+      }
+    }
+  }
+  if (packageJsonOrig.exports != null) {
+    let tmpExports;
+    if (typeof packageJsonOrig.exports === "string") {
+      tmpExports = { ".": packageJsonOrig.exports };
+    } else if (typeof packageJsonOrig.exports !== "object") {
+      throw new TypeError("package.json exports must be an object");
+    } else {
+      tmpExports = packageJsonOrig.exports;
+    }
+    for (const [name, value] of Object.entries(tmpExports)) {
+      if (typeof value !== "string") {
+        throw new TypeError(`package.json exports value must be a string: ${name}`);
+      }
+      if (value.endsWith(".wasm")) continue;
+      if (baseDir != null && baseDir !== ".") {
+        if (!value.startsWith(`./${baseDir}`)) {
+          throw new Error(`Invalid export value: ${value} (must be inside ./${baseDir})`);
+        }
+        exports[name] = `./${value.slice(baseDir.length + 3)}`;
+      } else {
+        exports[name] = value;
+      }
+    }
+  }
+  return {
+    name: asNonNull(packageJson.name),
+    version: asNonNull(packageJson.version),
+    exports,
+    exclude,
+    imports: importMap,
+    publish: {
+      // in the probable case we have `dist` in .gitignore, deno will ignore it by default
+      // but since the dist in our case is the generated JSR package, we do want to include it
+      exclude: [`!../${buildDirName}`]
+    },
+    ...packageJson.denoJson != null && typeof packageJson.denoJson === "object" ? packageJson.denoJson : {}
+  };
+}
+export {
+  packageJsonToDeno
+};

package/jsr/generate-workspace.d.ts

@@ -0,0 +1,9 @@
+import { WorkspacePackage } from '../package-json/collect-package-jsons.js';
+import { JsrConfig } from './config.js';
+export declare function generateDenoWorkspace(params: {
+    workspaceRoot: string | URL;
+    workspacePackages?: WorkspacePackage[];
+    rootConfig?: JsrConfig;
+    withDryRun?: boolean;
+    fixedVersion?: string;
+}): Promise<string>;

package/jsr/generate-workspace.js

@@ -0,0 +1,174 @@
+import * as fsp from "node:fs/promises";
+import { join, relative } from "node:path";
+import process from "node:process";
+import { asyncPool } from "@fuman/utils";
+import { glob } from "tinyglobby";
+import ts from "typescript";
+import { loadBuildConfig } from "../misc/_config.js";
+import { exec } from "../misc/exec.js";
+import { tryCopy } from "../misc/fs.js";
+import { normalizeFilePath } from "../misc/path.js";
+import { collectPackageJsons, filterPackageJsonsForPublish } from "../package-json/collect-package-jsons.js";
+import { processPackageJson } from "../package-json/process-package-json.js";
+import { findRootPackage, collectVersions } from "../package-json/utils.js";
+import { packageJsonToDeno } from "./deno-json.js";
+function mergeArrays(a, b, defaultValue = []) {
+  if (!a) return b ?? defaultValue;
+  if (!b) return a;
+  return [...a, ...b];
+}
+async function generateDenoWorkspace(params) {
+  const {
+    workspaceRoot: workspaceRoot_,
+    workspacePackages = await collectPackageJsons(workspaceRoot_, true),
+    rootConfig,
+    withDryRun = false,
+    fixedVersion
+  } = params;
+  const workspaceRoot = normalizeFilePath(workspaceRoot_);
+  const rootPackage = findRootPackage(workspacePackages);
+  const outDir = join(workspaceRoot, rootConfig?.outputDir ?? "dist");
+  await fsp.rm(outDir, { recursive: true, force: true });
+  await fsp.mkdir(outDir, { recursive: true });
+  const rootDenoJson = {
+    workspace: []
+  };
+  for (const pkg of filterPackageJsonsForPublish(workspacePackages, "jsr")) {
+    if (pkg.json.name == null) continue;
+    if (rootConfig?.includePackage != null && !rootConfig.includePackage(pkg)) continue;
+    const packageRoot = pkg.path;
+    const packageDirName = pkg.json.name.replace(/\//g, "__");
+    const packageOutRoot = join(outDir, packageDirName);
+    rootDenoJson.workspace.push(`./${packageDirName}`);
+    await fsp.mkdir(packageOutRoot, { recursive: true });
+    if (pkg.json.scripts?.["build:jsr"] != null) {
+      await exec([
+        "npm",
+        "run",
+        "build:jsr"
+      ], {
+        env: {
+          ...process.env,
+          FUMAN_BUILD_SRC: packageRoot,
+          FUMAN_BUILD_OUT: packageOutRoot
+        },
+        cwd: packageRoot,
+        stdio: "inherit",
+        throwOnError: true
+      });
+      continue;
+    }
+    const packageConfig = await loadBuildConfig(pkg.path);
+    const packageConfigJsr = packageConfig?.jsr;
+    const srcDir = join(packageRoot, normalizeFilePath(packageConfigJsr?.sourceDir ?? rootConfig?.sourceDir ?? ""));
+    const excludeFiles = mergeArrays(rootConfig?.exclude, packageConfigJsr?.exclude);
+    await fsp.cp(srcDir, packageOutRoot, { recursive: true });
+    const printer = ts.createPrinter();
+    const tsFiles = await glob("**/*.ts", {
+      cwd: packageOutRoot,
+      ignore: excludeFiles
+    });
+    await asyncPool(tsFiles, async (filename) => {
+      const fullFilePath = join(packageOutRoot, filename);
+      let fileContent = await fsp.readFile(fullFilePath, "utf8");
+      let changed = false;
+      const file = ts.createSourceFile(filename, fileContent, ts.ScriptTarget.ESNext, true);
+      let changedTs = false;
+      for (const imp of file.statements) {
+        if (!ts.isImportDeclaration(imp) && !ts.isExportDeclaration(imp)) {
+          continue;
+        }
+        if (!imp.moduleSpecifier || !ts.isStringLiteral(imp.moduleSpecifier)) {
+          continue;
+        }
+        const mod = imp.moduleSpecifier.text;
+        if (mod[0] !== ".") {
+          continue;
+        }
+        if (mod.endsWith(".js")) {
+          changedTs = true;
+          imp.moduleSpecifier = ts.factory.createStringLiteral(
+            mod.replace(/\.js$/, ".ts")
+          );
+        } else {
+          throw new Error(`Invalid import specifier: ${mod} at ${join(srcDir, filename)}`);
+        }
+      }
+      if (rootConfig?.transformAst?.(file)) {
+        changedTs = true;
+      }
+      if (packageConfigJsr?.transformAst?.(file)) {
+        changedTs = true;
+      }
+      if (changedTs) {
+        fileContent = printer.printFile(file);
+        changed = true;
+      }
+      if (rootConfig?.transformCode || packageConfigJsr?.transformCode) {
+        const origFileContent = fileContent;
+        if (rootConfig?.transformCode) {
+          fileContent = rootConfig.transformCode(filename, fileContent);
+        }
+        if (packageConfigJsr?.transformCode) {
+          fileContent = packageConfigJsr.transformCode(filename, fileContent);
+        }
+        if (fileContent !== origFileContent) {
+          changed = true;
+        }
+      }
+      if (changed) {
+        await fsp.writeFile(fullFilePath, fileContent);
+      }
+    });
+    const hookContext = {
+      outDir: "",
+      packageDir: packageOutRoot,
+      packageName: pkg.json.name,
+      packageJson: pkg.json,
+      jsr: true
+    };
+    packageConfig?.preparePackageJson?.(hookContext);
+    const workspaceVersions = collectVersions(workspacePackages);
+    const { packageJson, packageJsonOrig } = processPackageJson({
+      packageJson: pkg.json,
+      rootPackageJson: rootPackage.json,
+      workspaceVersions,
+      // since there's no bundling, we can't drop any deps.
+      // we *could* copy them from node_modules and add to the import map,
+      // but maybe sometime later, doesn't seem like a critical feature
+      bundledWorkspaceDeps: [],
+      rootFieldsToCopy: ["license"]
+    });
+    if (fixedVersion != null) {
+      packageJson.version = fixedVersion;
+      packageJsonOrig.version = fixedVersion;
+    }
+    const denoJson = packageJsonToDeno({
+      packageJson,
+      packageJsonOrig,
+      workspaceVersions,
+      buildDirName: relative(packageOutRoot, outDir),
+      baseDir: relative(packageRoot, srcDir),
+      exclude: excludeFiles
+    });
+    await fsp.writeFile(join(packageOutRoot, "deno.json"), JSON.stringify(denoJson, null, 4));
+    for (const file of mergeArrays(rootConfig?.copyRootFiles, packageConfig?.jsr?.copyRootFiles, ["LICENSE"])) {
+      await tryCopy(join(workspaceRoot, file), join(packageOutRoot, file), { recursive: true });
+    }
+    for (const file of mergeArrays(rootConfig?.copyPackageFiles, packageConfig?.jsr?.copyPackageFiles, ["README.md"])) {
+      await tryCopy(join(packageRoot, file), join(packageOutRoot, file), { recursive: true });
+    }
+  }
+  await fsp.writeFile(join(outDir, "deno.json"), JSON.stringify(rootDenoJson, null, 4));
+  if (rootConfig?.dryRun !== false || withDryRun) {
+    await exec(["deno", "publish", "--dry-run", "-q", "--allow-dirty"], {
+      cwd: outDir,
+      stdio: "inherit",
+      throwOnError: true
+    });
+  }
+  return outDir;
+}
+export {
+  generateDenoWorkspace
+};

package/jsr/index.d.ts

@@ -0,0 +1,5 @@
+export * from './build-jsr.js';
+export * from './config.js';
+export * from './deno-json.js';
+export * from './populate.js';
+export * from './utils/index.js';

package/jsr/populate.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Populate a local JSR instance with packages from an upstream registry
+ */
+export declare function populateFromUpstream(params: {
+    /**
+     * URL of the upstream registry
+     *
+     * @default  "https://jsr.io"
+     */
+    upstream?: string;
+    /**
+     * URL of the downstream local registry
+     */
+    downstream: string;
+    /**
+     * List of packages to populate (in format: `@scope/name@version`, e.g. `@std/fs@0.105.0`)
+     */
+    packages: string[];
+    /**
+     * Optional token for authentication (will be passed as `-t` to `deno publish`). Useful for CI/CD.
+     */
+    token?: string;
+    /**
+     * Whether to create packages via the API instead of interactively via web UI. Useful for CI/CD.
+     *
+     * Requires {@link token} to be set.
+     */
+    createViaApi?: boolean;
+    /**
+     * Deno executable path
+     *
+     * @default "deno" (from PATH)
+     */
+    deno?: string;
+    /**
+     * Whether to suppress output
+     *
+     * @default false
+     */
+    quiet?: boolean;
+    /**
+     * Additional arguments to pass to `deno publish`
+     */
+    publishArgs?: string[] | ((pkg: string) => string[]);
+}): Promise<void>;

package/jsr/populate.js

@@ -0,0 +1,132 @@
+import * as fsp from "node:fs/promises";
+import { join, resolve, dirname } from "node:path";
+import process from "node:process";
+import { AsyncQueue, asyncPool } from "@fuman/utils";
+import ts from "typescript";
+import { exec } from "../misc/exec.js";
+import { determinePublishOrder } from "../misc/publish-order.js";
+import { parseImportSpecifier } from "./utils/external-libs.js";
+import { jsrMaybeCreatePackage } from "./utils/jsr-api.js";
+import { findClosestJsrJson, parseJsrJson } from "./utils/jsr-json.js";
+import { downloadJsrPackage } from "./utils/jsr.js";
+async function findPackageDependencies(packagePath) {
+  const jsrJsonPath = findClosestJsrJson(packagePath);
+  if (jsrJsonPath == null) {
+    throw new Error(`Could not find jsr.json for package at ${packagePath}`);
+  }
+  const jsrJson = parseJsrJson(await fsp.readFile(jsrJsonPath, "utf8"));
+  const entrypoints = typeof jsrJson.exports === "string" ? [jsrJson.exports] : Object.values(jsrJson.exports);
+  const visited = /* @__PURE__ */ new Set();
+  const dependencies = /* @__PURE__ */ new Set();
+  const queue = [...entrypoints];
+  while (queue.length > 0) {
+    let handleSpecifier = function(specifier) {
+      if (specifier.startsWith("jsr:")) {
+        const parsed = parseImportSpecifier(specifier);
+        dependencies.add(`${parsed.packageName}@${parsed.version}`);
+      } else if (specifier.startsWith(".")) {
+        const resolved = resolve(dirname(join(packagePath, file)), specifier);
+        let relative = resolved.slice(packagePath.length + 1);
+        if (!relative.startsWith(".")) relative = `./${relative}`;
+        queue.push(relative);
+      }
+    };
+    const file = queue.shift();
+    if (visited.has(file)) {
+      continue;
+    }
+    visited.add(file);
+    const content = await fsp.readFile(join(packagePath, file), "utf8");
+    const source = ts.createSourceFile(file, content, ts.ScriptTarget.ESNext, true);
+    for (const node of source.statements) {
+      if (ts.isImportDeclaration(node)) {
+        const specifier = node.moduleSpecifier.getText().slice(1, -1);
+        handleSpecifier(specifier);
+      } else if (ts.isExportDeclaration(node)) {
+        if (node.moduleSpecifier) {
+          const specifier = node.moduleSpecifier.getText().slice(1, -1);
+          handleSpecifier(specifier);
+        }
+      }
+    }
+  }
+  return Array.from(dependencies);
+}
+async function populateFromUpstream(params) {
+  const {
+    upstream = "https://jsr.io",
+    downstream,
+    packages,
+    token,
+    createViaApi = false,
+    deno = "deno",
+    quiet = false,
+    publishArgs: _publishArgs
+  } = params;
+  const publishArgs = typeof _publishArgs === "function" ? _publishArgs : () => _publishArgs || [];
+  if (createViaApi && token == null) {
+    throw new Error("createViaApi requires a token");
+  }
+  const depsMap = /* @__PURE__ */ new Map();
+  const nameToPath = /* @__PURE__ */ new Map();
+  const downloadQueue = new AsyncQueue(packages);
+  let i = 0;
+  let total = downloadQueue.length;
+  await asyncPool(downloadQueue, async (pkg) => {
+    i += 1;
+    if (nameToPath.has(pkg)) {
+      if (downloadQueue.length === 0) {
+        downloadQueue.end();
+      }
+      return;
+    }
+    if (!quiet) {
+      console.log(`[${i}/${total}] Downloading ${pkg}...`);
+    }
+    const specifier = parseImportSpecifier(`jsr:${pkg}`);
+    const path = await downloadJsrPackage(specifier, { registry: upstream });
+    nameToPath.set(pkg, path);
+    const deps = await findPackageDependencies(path);
+    depsMap.set(pkg, deps);
+    deps.forEach((dep) => downloadQueue.enqueue(dep));
+    total += deps.length;
+    if (downloadQueue.length === 0 && deps.length === 0) {
+      downloadQueue.end();
+    }
+  });
+  const order = determinePublishOrder(Object.fromEntries(depsMap));
+  for (const item of order) {
+    const spec = parseImportSpecifier(`jsr:${item}`);
+    const path = nameToPath.get(item);
+    if (createViaApi) {
+      await jsrMaybeCreatePackage({
+        name: spec.packageName,
+        registry: downstream,
+        // eslint-disable-next-line ts/no-non-null-assertion
+        token,
+        quiet
+      });
+    }
+    if (!quiet) {
+      console.log(`Publishing ${item}...`);
+    }
+    await exec([
+      deno,
+      "publish",
+      "--quiet",
+      ...token != null ? ["--token", token] : [],
+      ...publishArgs(item)
+    ], {
+      env: {
+        ...process.env,
+        JSR_URL: downstream
+      },
+      cwd: path,
+      stdio: "inherit",
+      throwOnError: true
+    });
+  }
+}
+export {
+  populateFromUpstream
+};

package/jsr/utils/external-libs.d.ts

@@ -0,0 +1,8 @@
+export declare function getModuleCacheDirectory(): string;
+export interface ImportSpecifier {
+    registry: 'npm' | 'jsr';
+    packageName: string;
+    version: string;
+}
+export declare function parseImportSpecifier(importSpecifier: string): ImportSpecifier;
+export declare function splitImportRequest(request: string): [string, string];

package/jsr/utils/external-libs.js

@@ -0,0 +1,46 @@
+import { join } from "node:path";
+import process from "node:process";
+let _cacheDir;
+function getModuleCacheDirectory() {
+  if (process.env.JSR_CACHE_DIR != null) return process.env.JSR_CACHE_DIR;
+  if (_cacheDir != null) return _cacheDir;
+  switch (process.platform) {
+    case "win32": {
+      return _cacheDir = join(process.env.LOCALAPPDATA ?? process.env.APPDATA ?? "C:", "jsr-cache");
+    }
+    case "darwin": {
+      return _cacheDir = join(process.env.HOME ?? "/tmp", "Library", "Caches", "jsr");
+    }
+    default: {
+      return _cacheDir = join(process.env.XDG_CACHE_HOME ?? process.env.HOME ?? "/tmp", ".cache", "jsr");
+    }
+  }
+}
+function parseImportSpecifier(importSpecifier) {
+  let [registry, specifier] = importSpecifier.split(":");
+  if (registry !== "npm" && registry !== "jsr") {
+    throw new Error(`Invalid import specifier: ${importSpecifier}`);
+  }
+  if (registry === "jsr" && specifier[0] === "/") {
+    specifier = specifier.slice(1);
+  }
+  if (specifier.startsWith("@")) {
+    const [pkg2, version2] = specifier.slice(1).split("@");
+    return { registry, packageName: `@${pkg2}`, version: version2.split("/")[0] };
+  }
+  const [pkg, version] = specifier.split("@");
+  return { registry, packageName: pkg, version: version.split("/")[0] };
+}
+function splitImportRequest(request) {
+  if (request.startsWith("jsr:/")) request = `jsr:${request.slice(5)}`;
+  const parts = request.split("/");
+  if (parts[0].match(/^(?:npm:|jsr:)?@/)) {
+    return [parts.slice(0, 2).join("/"), parts.slice(2).join("/")];
+  }
+  return [parts[0], parts.slice(1).join("/")];
+}
+export {
+  getModuleCacheDirectory,
+  parseImportSpecifier,
+  splitImportRequest
+};

package/jsr/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './external-libs.js';
+export * from './jsr-api.js';
+export * from './jsr-json.js';
+export * from './jsr.js';

package/jsr/utils/jsr-api.d.ts

@@ -0,0 +1,23 @@
+export declare function jsrGetScopeInfo(params: {
+    scope: string;
+    registry: string;
+}): Promise<any>;
+export declare function jsrCreateScope(params: {
+    name: string;
+    registry: string;
+    token: string;
+    quiet?: boolean;
+}): Promise<void>;
+export declare function jsrMaybeCreatePackage(params: {
+    name: string;
+    registry: string;
+    token: string;
+    quiet?: boolean;
+}): Promise<void>;
+export declare function jsrSetGithubRepo(params: {
+    registry: string;
+    name: string;
+    token: string;
+    owner: string;
+    repo: string;
+}): Promise<void>;

package/jsr/utils/jsr-api.js

@@ -0,0 +1,115 @@
+import { createFfetch, ffetchAddons } from "@fuman/fetch";
+const ffetch = /* @__PURE__ */ createFfetch({
+  addons: [
+    /* @__PURE__ */ ffetchAddons.timeout(),
+    /* @__PURE__ */ ffetchAddons.retry()
+  ],
+  retry: { maxRetries: 3 },
+  timeout: 5e3
+});
+async function jsrGetScopeInfo(params) {
+  const { scope, registry } = params;
+  const res = await ffetch(`/api/scopes/${scope}`, {
+    baseUrl: registry,
+    validateResponse: false
+  });
+  if (res.status === 404) return null;
+  if (res.status !== 200) {
+    throw new Error(`Failed to get scope info: ${res.statusText}`);
+  }
+  return res.json();
+}
+async function jsrCreateScope(params) {
+  const { name, registry, token, quiet } = params;
+  const create = await ffetch("/api/scopes", {
+    baseUrl: registry,
+    headers: {
+      Cookie: `token=${token}`
+    },
+    json: { scope: name }
+  });
+  if (create.status !== 200) {
+    throw new Error(`Failed to create scope: ${create.statusText} ${await create.text()}`);
+  }
+  if (!quiet) {
+    console.log("Created scope @%s", name);
+  }
+}
+async function jsrMaybeCreatePackage(params) {
+  const { name, registry, token, quiet } = params;
+  const [scopeWithAt, packageName] = name.split("/");
+  if (!packageName || !scopeWithAt || !scopeWithAt.startsWith("@")) {
+    throw new Error("Invalid package name");
+  }
+  const scope = scopeWithAt.slice(1);
+  const packageMeta = await ffetch(`/api/scopes/${scope}/packages/${packageName}`, {
+    baseUrl: registry,
+    validateResponse: false
+  });
+  if (packageMeta.status === 200) return;
+  if (packageMeta.status !== 404) {
+    throw new Error(`Failed to check package: ${packageMeta.statusText} ${await packageMeta.text()}`);
+  }
+  if (!quiet) {
+    console.log("%s does not exist, creating..", name);
+  }
+  const create = await ffetch(`/api/scopes/${scope}/packages`, {
+    baseUrl: registry,
+    headers: {
+      Cookie: `token=${token}`
+    },
+    json: { package: packageName },
+    validateResponse: false
+  });
+  if (create.status !== 200) {
+    const text = await create.text();
+    if (create.status === 403) {
+      const json = JSON.parse(text);
+      if (json.code === "actorNotScopeMember") {
+        const info = await jsrGetScopeInfo({ scope, registry });
+        if (info === null) {
+          await jsrCreateScope({ name: scope, registry, token, quiet });
+          return jsrMaybeCreatePackage({
+            ...params,
+            quiet: true
+          });
+        }
+      }
+    }
+    throw new Error(`Failed to create package: ${create.statusText} ${text}`);
+  }
+}
+async function jsrSetGithubRepo(params) {
+  const {
+    registry,
+    name,
+    token,
+    owner,
+    repo
+  } = params;
+  const [scopeWithAt, packageName] = name.split("/");
+  if (!packageName || !scopeWithAt || !scopeWithAt.startsWith("@")) {
+    throw new Error("Invalid package name");
+  }
+  const scope = scopeWithAt.slice(1);
+  const res = await ffetch(`/api/scopes/${scope}/packages/${packageName}`, {
+    method: "PATCH",
+    baseUrl: registry,
+    validateResponse: false,
+    headers: {
+      Cookie: `token=${token}`
+    },
+    json: {
+      githubRepository: { owner, name: repo }
+    }
+  });
+  if (res.status !== 200) {
+    throw new Error(`Failed to set github repo: ${await res.text()}`);
+  }
+}
+export {
+  jsrCreateScope,
+  jsrGetScopeInfo,
+  jsrMaybeCreatePackage,
+  jsrSetGithubRepo
+};

package/jsr/utils/jsr-json.d.ts

@@ -0,0 +1,10 @@
+import { ImportSpecifier } from './external-libs.js';
+export interface JsrJson {
+    name: string;
+    version: string;
+    exports: string | Record<string, string>;
+    imports?: Record<string, ImportSpecifier>;
+    compilerOptions?: object;
+}
+export declare function parseJsrJson(json: string): JsrJson;
+export declare function findClosestJsrJson(path: string): string | null;