@fuman/build 0.0.1

package/cli/commands/validate-workspace-deps.js

@@ -0,0 +1,68 @@
+import process from "node:process";
+import { satisfies } from "semver";
+import { collectPackageJsons } from "../../package-json/collect-package-jsons.js";
+import * as bc from "@drizzle-team/brocli";
+async function validateWorkspaceDeps(workspaceRoot, params) {
+  const { includeRoot = true, skipWorkspaceDeps = true } = params || {};
+  const pjs = await collectPackageJsons(workspaceRoot, includeRoot);
+  const workspacePackages = new Set(skipWorkspaceDeps ? pjs.map((pj) => pj.json.name) : []);
+  const versions = {};
+  const errors = [];
+  for (const { json: pj } of pjs) {
+    if (pj.name === void 0) {
+      throw new Error("package.json without name is not supported");
+    }
+    for (const field of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
+      const deps = pj[field];
+      if (!deps) continue;
+      for (const [name, version] of Object.entries(deps)) {
+        if (workspacePackages.has(name)) continue;
+        if (version.startsWith("workspace:")) continue;
+        if (versions[name] === void 0) {
+          versions[name] = {};
+        }
+        for (const [pkgName, pkgDepVersions] of Object.entries(versions[name])) {
+          if (!satisfies(version, pkgDepVersions)) {
+            errors.push({
+              package: pj.name,
+              dependency: name,
+              version,
+              at: field,
+              otherPackage: pkgName,
+              otherVersion: pkgDepVersions
+            });
+          }
+        }
+        versions[name][pj.name] = version;
+      }
+    }
+  }
+  return errors;
+}
+const validateWorkspaceDepsCli = bc.command({
+  name: "validate-workspace-deps",
+  desc: "validate the external dependencies of a workspace",
+  options: {
+    includeRoot: bc.boolean("include-root").desc("whether to also validate the root package.json").default(false),
+    noSkipWorkspaceDeps: bc.boolean("no-skip-workspace-deps").desc("whether to not skip validating dependencies of other workspace packages"),
+    root: bc.string().desc("path to the root of the workspace (default: cwd)")
+  },
+  handler: async (args) => {
+    const errors = await validateWorkspaceDeps(args.root ?? process.cwd(), {
+      includeRoot: args.includeRoot,
+      skipWorkspaceDeps: !args.noSkipWorkspaceDeps
+    });
+    if (errors.length > 0) {
+      console.error("⚠️ Found external dependencies mismatch:");
+      for (const error of errors) {
+        console.error(`  - at ${error.package}: ${error.at} has ${error.dependency}@${error.version}, but ${error.otherPackage} has @${error.otherVersion}`);
+      }
+    } else {
+      console.log("✅ All external dependencies match!");
+    }
+  }
+});
+export {
+  validateWorkspaceDeps,
+  validateWorkspaceDepsCli
+};

package/cli/index.d.ts

@@ -0,0 +1,3 @@
+export { buildPackage } from './commands/build.js';
+export { generateDepsGraph } from './commands/gen-deps-graph.js';
+export { validateWorkspaceDeps } from './commands/validate-workspace-deps.js';

package/cli/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/config.d.ts

@@ -0,0 +1,32 @@
+import { JsrConfig } from './jsr/config.js';
+import { PackageJson } from './package-json/types.js';
+import { VersioningOptions } from './versioning/types.js';
+export interface BuildHookContext {
+    /** full path to the output directory */
+    outDir: string;
+    /** full path to the package directory */
+    packageDir: string;
+    /** name of the package being build */
+    packageName: string;
+    /**
+     * package.json of the package being build
+     * should not be modified unless allowed in the hook docs
+     */
+    packageJson: PackageJson;
+    /** whether this is a jsr build */
+    jsr: boolean;
+}
+export interface RootConfigObject {
+    /**
+     * path to vite config to use when building using fuman-build cli,
+     * relative to the workspace root
+     *
+     * @default "vite.config.js"
+     */
+    viteConfig?: string;
+    /** jsr-specific configuration */
+    jsr?: JsrConfig;
+    /** configuration for the changelog generator */
+    versioning?: VersioningOptions;
+}
+export type RootConfig = RootConfigObject | (() => RootConfigObject);

package/fuman-build.d.ts

@@ -0,0 +1 @@
+export * from "./cli/main.js"

package/fuman-build.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import process from "node:process";
+import * as bc from "@drizzle-team/brocli";
+import { buildPackageCli } from "./cli/commands/build.js";
+import { bumpVersionCli } from "./cli/commands/bump-version.js";
+import { runContinuousReleaseCli } from "./cli/commands/cr.js";
+import { findChangedPackagesCli } from "./cli/commands/find-changed-packages.js";
+import { generateChangelogCli } from "./cli/commands/gen-changelog.js";
+import { generateDepsGraphCli } from "./cli/commands/gen-deps-graph.js";
+import { jsrCli } from "./cli/commands/jsr.js";
+import { publishPackagesCli } from "./cli/commands/publish.js";
+import { releaseCli } from "./cli/commands/release.js";
+import { validateWorkspaceDepsCli } from "./cli/commands/validate-workspace-deps.js";
+await bc.run([
+  validateWorkspaceDepsCli,
+  generateDepsGraphCli,
+  buildPackageCli,
+  jsrCli,
+  generateChangelogCli,
+  findChangedPackagesCli,
+  bumpVersionCli,
+  publishPackagesCli,
+  releaseCli,
+  runContinuousReleaseCli
+], {
+  theme: (event) => {
+    if (event.type === "error" && event.violation === "unknown_error") {
+      console.error(event.error);
+      process.exit(1);
+    }
+    return false;
+  }
+});

package/git/github.d.ts

@@ -0,0 +1,14 @@
+export declare function createGithubRelease(params: {
+    token: string;
+    repo: string;
+    tag: string;
+    name: string;
+    body: string;
+    draft?: boolean;
+    prerelease?: boolean;
+    artifacts?: {
+        name: string;
+        type: string;
+        body: BodyInit;
+    }[];
+}): Promise<number>;

package/git/github.js

@@ -0,0 +1,48 @@
+import { ffetchBase, ffetchAddons } from "@fuman/fetch";
+import { ffetchZodAdapter } from "@fuman/fetch/zod";
+import { asyncPool } from "@fuman/utils";
+import { z } from "zod";
+async function createGithubRelease(params) {
+  const ffetch = ffetchBase.extend({
+    baseUrl: "https://api.github.com",
+    addons: [
+      ffetchAddons.retry(),
+      ffetchAddons.parser(ffetchZodAdapter())
+    ],
+    headers: {
+      "Accept": "application/vnd.github+json",
+      "User-Agent": "@fuman/build",
+      "X-GitHub-Api-Version": "2022-11-28",
+      "Authorization": `Bearer ${params.token}`
+    }
+  });
+  const release = await ffetch.post(`/repos/${params.repo}/releases`, {
+    json: {
+      tag_name: params.tag,
+      name: params.name,
+      body: params.body,
+      draft: params.draft,
+      prerelease: params.prerelease
+    },
+    validateResponse: (res) => res.status === 201
+  }).parsedJson(z.object({
+    id: z.number()
+  }));
+  if (params.artifacts != null && params.artifacts.length > 0) {
+    await asyncPool(params.artifacts, async (file) => {
+      await ffetch(`/repos/${params.repo}/releases/${release.id}/assets`, {
+        method: "POST",
+        query: { name: file.name },
+        headers: {
+          "Content-Type": file.type
+        },
+        body: file.body,
+        validateResponse: (res) => res.status === 201
+      });
+    });
+  }
+  return release.id;
+}
+export {
+  createGithubRelease
+};

package/git/index.d.ts

@@ -0,0 +1 @@
+export * from './utils.js';

package/git/utils.d.ts

@@ -0,0 +1,38 @@
+export declare function getLatestTag(cwd?: string | URL): Promise<string | null>;
+export declare function getFirstCommit(cwd?: string | URL): Promise<string>;
+export declare function getCurrentCommit(cwd?: string | URL): Promise<string>;
+export declare function getCurrentBranch(cwd?: string | URL): Promise<string>;
+export declare function findChangedFiles(params: {
+    since: string;
+    /** @default  'HEAD' */
+    until?: string;
+    cwd?: string | URL;
+}): Promise<string[]>;
+export interface CommitInfo {
+    hash: string;
+    author: {
+        name: string;
+        email: string;
+        date: Date;
+    };
+    committer: {
+        name: string;
+        email: string;
+        date: Date;
+    };
+    message: string;
+    description: string;
+}
+export declare function getCommitsBetween(params: {
+    since: string;
+    /** @default  'HEAD' */
+    until?: string;
+    cwd?: string | URL;
+}): Promise<CommitInfo[]>;
+export interface ConventionalCommit {
+    type: string;
+    scope?: string;
+    breaking: boolean;
+    subject: string;
+}
+export declare function parseConventionalCommit(msg: string): ConventionalCommit | null;

package/git/utils.js

@@ -0,0 +1,110 @@
+import { randomUUID } from "node:crypto";
+import { exec } from "../misc/exec.js";
+async function getLatestTag(cwd) {
+  const res = await exec(["git", "describe", "--abbrev=0", "--tags"], { cwd });
+  if (res.exitCode !== 0) {
+    if (res.stderr.match(/^fatal: (?:No names found|No tags can describe)/i)) {
+      return null;
+    }
+    throw new Error(`git describe failed: ${res.stderr}`);
+  }
+  return res.stdout.trim();
+}
+async function getFirstCommit(cwd) {
+  return (await exec(["git", "rev-list", "--max-parents=0", "HEAD"], {
+    cwd,
+    throwOnError: true
+  })).stdout.trim();
+}
+async function getCurrentCommit(cwd) {
+  const res = await exec(["git", "rev-parse", "HEAD"], {
+    cwd,
+    throwOnError: true
+  });
+  return res.stdout.trim();
+}
+async function getCurrentBranch(cwd) {
+  const res = await exec(["git", "rev-parse", "--abbrev-ref", "HEAD"], {
+    cwd,
+    throwOnError: true
+  });
+  return res.stdout.trim();
+}
+async function findChangedFiles(params) {
+  const { since, until = "HEAD", cwd } = params;
+  const res = await exec(["git", "diff", "--name-only", since, until], {
+    cwd,
+    throwOnError: true
+  });
+  const files = res.stdout.trim().split("\n");
+  if (files.length === 1 && files[0] === "") {
+    return [];
+  }
+  return files;
+}
+async function getCommitsBetween(params) {
+  const { since, until = "HEAD", cwd } = params;
+  const delim = `---${randomUUID()}---`;
+  const res = await exec(["git", "log", `--pretty=format:%H %s%n%an%n%ae%n%aI%n%cn%n%ce%n%cI%n%b%n${delim}`, `${since}..${until}`], {
+    cwd,
+    throwOnError: true
+  });
+  const lines = res.stdout.trim().split("\n");
+  const items = [];
+  let current = null;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === delim) {
+      if (current) items.push(current);
+      current = null;
+    } else if (current) {
+      if (current.description) current.description += "\n";
+      current.description += line;
+    } else {
+      const [hash, ...msg] = line.split(" ");
+      const authorName = lines[++i];
+      const authorEmail = lines[++i];
+      const authorDate = lines[++i];
+      const committerName = lines[++i];
+      const committerEmail = lines[++i];
+      const committerDate = lines[++i];
+      current = {
+        hash,
+        author: {
+          name: authorName,
+          email: authorEmail,
+          date: new Date(authorDate)
+        },
+        committer: {
+          name: committerName,
+          email: committerEmail,
+          date: new Date(committerDate)
+        },
+        message: msg.join(" "),
+        description: ""
+      };
+    }
+  }
+  if (current) items.push(current);
+  return items.reverse();
+}
+function parseConventionalCommit(msg) {
+  const match = msg.match(/^(\w+)(?:\(([^)]+)\))?(!?): (.+)$/);
+  if (!match) return null;
+  const [, type, scope, breaking, subject] = match;
+  return {
+    type,
+    scope,
+    breaking: Boolean(breaking),
+    subject
+  };
+}
+export {
+  findChangedFiles,
+  getCommitsBetween,
+  getCurrentBranch,
+  getCurrentCommit,
+  getFirstCommit,
+  getLatestTag,
+  parseConventionalCommit
+};

package/index.d.ts

@@ -0,0 +1,7 @@
+export * from './ci/index.js';
+export * from './cli/index.js';
+export * from './config.js';
+export * from './git/index.js';
+export * from './misc/index.js';
+export * from './npm/index.js';
+export * from './package-json/index.js';

package/index.js

@@ -0,0 +1,46 @@
+import { getGithubActionsInput, isRunningInGithubActions, writeGithubActionsOutput } from "./ci/github-actions.js";
+import { buildPackage } from "./cli/commands/build.js";
+import { generateDepsGraph } from "./cli/commands/gen-deps-graph.js";
+import { validateWorkspaceDeps } from "./cli/commands/validate-workspace-deps.js";
+import { findChangedFiles, getCommitsBetween, getCurrentBranch, getCurrentCommit, getFirstCommit, getLatestTag, parseConventionalCommit } from "./git/utils.js";
+import { exec } from "./misc/exec.js";
+import { normalizeFilePath } from "./misc/path.js";
+import { determinePublishOrder, sortWorkspaceByPublishOrder } from "./misc/publish-order.js";
+import { getTsconfigFiles, getTsconfigFor } from "./misc/tsconfig.js";
+import { NPM_PACKAGE_NAME_REGEX, npmCheckVersion } from "./npm/npm-api.js";
+import { collectPackageJsons, filterPackageJsonsForPublish } from "./package-json/collect-package-jsons.js";
+import { findPackageJson } from "./package-json/find-package-json.js";
+import { parsePackageJson, parsePackageJsonFile, parseWorkspaceRootPackageJson } from "./package-json/parse.js";
+import { processPackageJson } from "./package-json/process-package-json.js";
+import { PackageJsonSchema } from "./package-json/types.js";
+export {
+  NPM_PACKAGE_NAME_REGEX,
+  PackageJsonSchema,
+  buildPackage,
+  collectPackageJsons,
+  determinePublishOrder,
+  exec,
+  filterPackageJsonsForPublish,
+  findChangedFiles,
+  findPackageJson,
+  generateDepsGraph,
+  getCommitsBetween,
+  getCurrentBranch,
+  getCurrentCommit,
+  getFirstCommit,
+  getGithubActionsInput,
+  getLatestTag,
+  getTsconfigFiles,
+  getTsconfigFor,
+  isRunningInGithubActions,
+  normalizeFilePath,
+  npmCheckVersion,
+  parseConventionalCommit,
+  parsePackageJson,
+  parsePackageJsonFile,
+  parseWorkspaceRootPackageJson,
+  processPackageJson,
+  sortWorkspaceByPublishOrder,
+  validateWorkspaceDeps,
+  writeGithubActionsOutput
+};

package/jsr/build-jsr.d.ts

@@ -0,0 +1,7 @@
+import { WorkspacePackage } from '../package-json/collect-package-jsons.js';
+import { JsrConfig } from './config.js';
+export declare function runJsrBuild(params: {
+    packageName: string;
+    workspacePackages: WorkspacePackage[];
+    rootConfig?: JsrConfig;
+}): Promise<void>;

package/jsr/build-jsr.js

@@ -0,0 +1,145 @@
+import * as fsp from "node:fs/promises";
+import { join, relative } from "node:path";
+import { asyncPool, asNonNull } 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 { processPackageJson } from "../package-json/process-package-json.js";
+import { findPackageByName, 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 runJsrBuild(params) {
+  const {
+    packageName,
+    workspacePackages,
+    rootConfig
+  } = params;
+  const ourPackage = findPackageByName(workspacePackages, packageName);
+  const rootPackage = findRootPackage(workspacePackages);
+  const packageRoot = ourPackage.path;
+  const workspaceRoot = rootPackage.path;
+  const outDir = join(packageRoot, normalizeFilePath(rootConfig?.outputDir ?? "dist"));
+  const packageConfig = await loadBuildConfig(packageRoot);
+  const srcDir = join(packageRoot, normalizeFilePath(packageConfig?.jsr?.sourceDir ?? rootConfig?.sourceDir ?? ""));
+  const excludeFiles = mergeArrays(rootConfig?.exclude, packageConfig?.jsr?.exclude);
+  await fsp.rm(outDir, { recursive: true, force: true });
+  await fsp.mkdir(outDir, { recursive: true });
+  await asyncPool(await fsp.readdir(srcDir), async (file) => {
+    const src = join(srcDir, file);
+    if (src === outDir) return;
+    await fsp.cp(src, join(outDir, file), { recursive: true });
+  });
+  const printer = ts.createPrinter();
+  const tsFiles = await glob("**/*.ts", {
+    cwd: outDir,
+    ignore: excludeFiles
+  });
+  const badImports = [];
+  await asyncPool(tsFiles, async (filename) => {
+    const fullFilePath = join(outDir, 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 {
+        badImports.push(`  from ${mod} at ${join(srcDir, filename)}`);
+      }
+    }
+    if (rootConfig?.transformAst?.(file)) {
+      changedTs = true;
+    }
+    if (packageConfig?.jsr?.transformAst?.(file)) {
+      changedTs = true;
+    }
+    if (changedTs) {
+      fileContent = printer.printFile(file);
+      changed = true;
+    }
+    if (rootConfig?.transformCode || packageConfig?.jsr?.transformCode) {
+      const origFileContent = fileContent;
+      if (rootConfig?.transformCode) {
+        fileContent = rootConfig.transformCode(filename, fileContent);
+      }
+      if (packageConfig?.jsr?.transformCode) {
+        fileContent = packageConfig.jsr.transformCode(filename, fileContent);
+      }
+      if (fileContent !== origFileContent) {
+        changed = true;
+      }
+    }
+    if (changed) {
+      await fsp.writeFile(fullFilePath, fileContent);
+    }
+  });
+  if (badImports.length > 0) {
+    throw new Error(`Found ${badImports.length} invalid imports (you must specify .js extension):
+${badImports.join("\n")}`);
+  }
+  const hookContext = {
+    outDir: "",
+    packageDir: ourPackage.path,
+    packageName: asNonNull(ourPackage.json.name),
+    packageJson: ourPackage.json,
+    jsr: true
+  };
+  packageConfig?.preparePackageJson?.(hookContext);
+  const workspaceVersions = collectVersions(workspacePackages);
+  const { packageJson, packageJsonOrig } = processPackageJson({
+    packageJson: ourPackage.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
+    bundledWorkspaceDeps: [],
+    rootFieldsToCopy: ["license"]
+  });
+  const denoJson = packageJsonToDeno({
+    packageJson,
+    packageJsonOrig,
+    workspaceVersions,
+    buildDirName: relative(packageRoot, outDir),
+    baseDir: relative(packageRoot, srcDir),
+    exclude: excludeFiles
+  });
+  await fsp.writeFile(join(outDir, "deno.json"), JSON.stringify(denoJson, null, 4));
+  for (const file of mergeArrays(rootConfig?.copyRootFiles, packageConfig?.jsr?.copyRootFiles, ["LICENSE"])) {
+    await tryCopy(join(workspaceRoot, file), join(outDir, file), { recursive: true });
+  }
+  for (const file of mergeArrays(rootConfig?.copyPackageFiles, packageConfig?.jsr?.copyPackageFiles, ["README.md"])) {
+    await tryCopy(join(packageRoot, file), join(outDir, file), { recursive: true });
+  }
+  if (!packageConfig?.jsr?.dryRun && !rootConfig?.dryRun) {
+    await exec(["deno", "publish", "--dry-run", "-q", "--allow-dirty"], {
+      cwd: outDir,
+      stdio: "inherit",
+      throwOnError: true
+    });
+  }
+}
+export {
+  runJsrBuild
+};

package/jsr/config.d.ts

@@ -0,0 +1,48 @@
+import { MaybePromise } from '@fuman/utils';
+import { default as ts } from 'typescript';
+import { BuildHookContext } from '../config.js';
+import { WorkspacePackage } from '../package-json/collect-package-jsons.js';
+export interface JsrConfig {
+    /**
+     * jsr build output dir (relative to workspace root)
+     *
+     * @default "dist"
+     */
+    outputDir?: string;
+    /**
+     * files to copy from the workspace root directory to the package build directory
+     *
+     * @default ['LICENSE']
+     */
+    copyRootFiles?: string[];
+    /**
+     * files to copy from the package root directory to the package build directory
+     *
+     * @default ['README.md']
+     */
+    copyPackageFiles?: string[];
+    /**
+     * source dir (relative to package root)
+     * anything outside this dir will be copied as-is
+     * @default "" (i.e. the package root itself)
+     */
+    sourceDir?: string;
+    /** globs to exclude from publishing */
+    exclude?: string[];
+    /** custom predicate for including packages */
+    includePackage?: (pkg: WorkspacePackage) => boolean;
+    /**
+     * whether to run `deno publish --dry-run` after generating the workspace
+     * to make sure everything is ok
+     * @default true
+     */
+    dryRun?: boolean;
+    /** hook to run after the deno.json file is generated but before it is written to disk */
+    finalizeDenoJson?: (ctx: BuildHookContext, jsr: any) => void;
+    /** hook to run *after* the build is done, time to do any final modifications to the package contents */
+    finalize?: (ctx: BuildHookContext) => MaybePromise<void>;
+    /** hook that will be run on each file as it is being processed, allowing you to change ast as you wish */
+    transformAst?: (ast: ts.SourceFile) => boolean;
+    /** similar to transformAst, but for the code itself (runs after transformAst) */
+    transformCode?: (path: string, code: string) => string;
+}

package/jsr/create-packages.d.ts

@@ -0,0 +1,8 @@
+import { WorkspacePackage } from '../package-json/collect-package-jsons.js';
+export declare function jsrCreatePackages(params: {
+    workspaceRoot: string;
+    workspacePackages?: WorkspacePackage[];
+    registry?: string;
+    token?: string;
+    githubRepo?: string;
+}): Promise<boolean>;

package/jsr/create-packages.js

@@ -0,0 +1,46 @@
+import process from "node:process";
+import { filterPackageJsonsForPublish, collectPackageJsons } from "../package-json/collect-package-jsons.js";
+import { jsrMaybeCreatePackage, jsrSetGithubRepo } from "./utils/jsr-api.js";
+import { jsrCheckVersion } from "./utils/jsr.js";
+async function jsrCreatePackages(params) {
+  const {
+    workspaceRoot,
+    registry = process.env.JSR_URL ?? "https://jsr.io",
+    token,
+    githubRepo
+  } = params;
+  const workspace = filterPackageJsonsForPublish(params.workspacePackages ?? await collectPackageJsons(workspaceRoot, false), "jsr");
+  let hasFailed = false;
+  for (const pkg of workspace) {
+    if (pkg.json.name == null) continue;
+    if (await jsrCheckVersion({ registry, package: pkg.json.name })) {
+      continue;
+    }
+    const [scope_, packageName] = pkg.json.name.split("/");
+    const scope = scope_.slice(1);
+    if (token == null) {
+      console.log(`ℹ️ to create \x1B[;33m${pkg.json.name}\x1B[;0m follow this link: \x1B[;34m${new URL(`/create?scope=${scope}&package=${packageName}`, registry).href}\x1B[;0m`);
+      hasFailed = true;
+      continue;
+    }
+    await jsrMaybeCreatePackage({
+      name: pkg.json.name,
+      registry,
+      token
+    });
+    if (githubRepo != null) {
+      const [owner, repo] = githubRepo.split("/");
+      await jsrSetGithubRepo({
+        registry,
+        name: pkg.json.name,
+        token,
+        owner,
+        repo
+      });
+    }
+  }
+  return hasFailed;
+}
+export {
+  jsrCreatePackages
+};