@fuman/build 0.0.1

package/jsr/utils/jsr-json.js

@@ -0,0 +1,80 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { parseConfigFileTextToJson } from "typescript";
+import { parseImportSpecifier } from "./external-libs.js";
+function parseJsrJson(json) {
+  const res = parseConfigFileTextToJson("jsr.json", json);
+  if (res.error) {
+    throw new Error(res.error.messageText.toString());
+  }
+  const obj = res.config;
+  if (typeof obj !== "object" || obj === null) {
+    throw new Error("Expected object");
+  }
+  if (typeof obj.name !== "string") {
+    throw new TypeError('Expected "name" to be a string');
+  }
+  if (typeof obj.version !== "string") {
+    throw new TypeError('Expected "version" to be a string');
+  }
+  if (typeof obj.exports !== "string" && (typeof obj.exports !== "object" || obj.exports === null)) {
+    throw new TypeError('Expected "exports" to be a string or an object');
+  }
+  if (typeof obj.exports !== "string") {
+    for (const key in obj.exports) {
+      if (typeof key !== "string") {
+        throw new TypeError("exports: Expected key to be a string");
+      }
+      if (typeof obj.exports[key] !== "string") {
+        throw new TypeError("exports: Expected value to be a string");
+      }
+    }
+  }
+  if (obj.imports !== void 0) {
+    if (typeof obj.imports !== "object" || obj.imports === null) {
+      throw new TypeError('Expected "imports" to be an object');
+    }
+    for (const key in obj.imports) {
+      if (typeof key !== "string") {
+        throw new TypeError("imports: Expected key to be a string");
+      }
+      if (typeof obj.imports[key] !== "string") {
+        throw new TypeError("imports: Expected value to be a string");
+      }
+      obj.imports[key] = parseImportSpecifier(obj.imports[key]);
+    }
+  }
+  if (obj.compilerOptions !== void 0) {
+    if (typeof obj.compilerOptions !== "object" || obj.compilerOptions === null) {
+      throw new TypeError('Expected "compilerOptions" to be an object');
+    }
+  }
+  return obj;
+}
+const _findClosestJsrJsonCache = /* @__PURE__ */ new Map();
+function findClosestJsrJson(path) {
+  while (true) {
+    if (_findClosestJsrJsonCache.has(path)) {
+      return _findClosestJsrJsonCache.get(path);
+    }
+    for (const file of ["jsr.json", "deno.json", "jsr.jsonc", "deno.jsonc"]) {
+      if (existsSync(join(path, file))) {
+        _findClosestJsrJsonCache.set(path, join(path, file));
+        return join(path, file);
+      }
+    }
+    if (existsSync(join(path, "package.json"))) {
+      _findClosestJsrJsonCache.set(path, null);
+      return null;
+    }
+    const parent = join(path, "..");
+    if (parent === path) {
+      return null;
+    }
+    path = parent;
+  }
+}
+export {
+  findClosestJsrJson,
+  parseJsrJson
+};

package/jsr/utils/jsr.d.ts

@@ -0,0 +1,11 @@
+import { ImportSpecifier } from './external-libs.js';
+/** check if a specific version (or a package at all) is available in the jsr registry */
+export declare function jsrCheckVersion(params: {
+    registry?: string;
+    package: string;
+    version?: string;
+}): Promise<boolean>;
+export declare function downloadJsrPackage(specifier: ImportSpecifier, params?: {
+    registry?: string;
+    force?: boolean;
+}): Promise<string>;

package/jsr/utils/jsr.js

@@ -0,0 +1,74 @@
+import * as fs from "node:fs";
+import * as fsp from "node:fs/promises";
+import { join } from "node:path";
+import process from "node:process";
+import { ffetchBase, ffetchAddons } from "@fuman/fetch";
+import { ffetchZodAdapter } from "@fuman/fetch/zod";
+import { write, webReadableToFuman } from "@fuman/io";
+import { nodeWritableToFuman } from "@fuman/node";
+import { asyncPool } from "@fuman/utils";
+import semver from "semver";
+import { z } from "zod";
+import { directoryExists } from "../../misc/fs.js";
+import { getModuleCacheDirectory } from "./external-libs.js";
+const DEFAULT_REGISTRY = process.env.JSR_URL ?? "https://jsr.io";
+async function jsrCheckVersion(params) {
+  const {
+    registry = DEFAULT_REGISTRY,
+    package: packageName,
+    version
+  } = params;
+  const res = await ffetchBase(`/${packageName}/meta${version != null ? `_${version}` : ""}.json`, {
+    baseUrl: registry,
+    validateResponse: false
+  });
+  return res.status === 200;
+}
+async function downloadJsrPackage(specifier, params) {
+  if (specifier.registry !== "jsr") {
+    throw new Error("Invalid registry");
+  }
+  const registry = params?.registry ?? DEFAULT_REGISTRY;
+  const ffetch = ffetchBase.extend({
+    baseUrl: registry,
+    addons: [
+      ffetchAddons.parser(ffetchZodAdapter())
+    ]
+  });
+  const targetDir = `${specifier.packageName.replace(/\//g, "+")}@${specifier.version}`;
+  const registryHost = new URL(registry).host;
+  const cacheDir = join(getModuleCacheDirectory(), "jsr", registryHost, targetDir);
+  if (await directoryExists(cacheDir)) {
+    if (params?.force) {
+      await fsp.rm(cacheDir, { recursive: true });
+    } else {
+      return cacheDir;
+    }
+  }
+  const meta = await ffetch(`${specifier.packageName}/meta.json`).parsedJson(z.object({
+    versions: z.record(z.unknown())
+  }));
+  const availableVersions = Object.keys(meta.versions);
+  const version = semver.maxSatisfying(availableVersions, specifier.version);
+  if (version == null) {
+    throw new Error(`No matching version for ${specifier.packageName}@${specifier.version}`);
+  }
+  await fsp.mkdir(cacheDir, { recursive: true });
+  const versionMeta = await ffetch(`${specifier.packageName}/${version}_meta.json`).parsedJson(z.object({
+    manifest: z.record(z.unknown())
+  }));
+  const fetchFile = async (file) => {
+    file = file.replace(/^\//, "");
+    const filePath = join(cacheDir, file);
+    await fsp.mkdir(join(filePath, ".."), { recursive: true });
+    const from = await ffetch(`${specifier.packageName}/${version}/${file}`).stream();
+    const into = nodeWritableToFuman(fs.createWriteStream(filePath));
+    await write.pipe(into, webReadableToFuman(from));
+  };
+  await asyncPool(Object.keys(versionMeta.manifest), fetchFile, { limit: 16 });
+  return cacheDir;
+}
+export {
+  downloadJsrPackage,
+  jsrCheckVersion
+};

package/jsr.d.ts

@@ -0,0 +1 @@
+export * from "./jsr/index.js"

package/jsr.js

@@ -0,0 +1,23 @@
+import { runJsrBuild } from "./jsr/build-jsr.js";
+import { packageJsonToDeno } from "./jsr/deno-json.js";
+import { populateFromUpstream } from "./jsr/populate.js";
+import { getModuleCacheDirectory, parseImportSpecifier, splitImportRequest } from "./jsr/utils/external-libs.js";
+import { jsrCreateScope, jsrGetScopeInfo, jsrMaybeCreatePackage, jsrSetGithubRepo } from "./jsr/utils/jsr-api.js";
+import { findClosestJsrJson, parseJsrJson } from "./jsr/utils/jsr-json.js";
+import { downloadJsrPackage, jsrCheckVersion } from "./jsr/utils/jsr.js";
+export {
+  downloadJsrPackage,
+  findClosestJsrJson,
+  getModuleCacheDirectory,
+  jsrCheckVersion,
+  jsrCreateScope,
+  jsrGetScopeInfo,
+  jsrMaybeCreatePackage,
+  jsrSetGithubRepo,
+  packageJsonToDeno,
+  parseImportSpecifier,
+  parseJsrJson,
+  populateFromUpstream,
+  runJsrBuild,
+  splitImportRequest
+};

package/misc/_config.d.ts

@@ -0,0 +1 @@
+export declare function loadBuildConfig<T>(packageRoot: string, configName?: string): Promise<T | undefined>;

package/misc/_config.js

@@ -0,0 +1,18 @@
+import { join } from "node:path";
+async function loadBuildConfig(packageRoot, configName = "build.config.js") {
+  try {
+    const mod = (await import(join(packageRoot, configName))).default;
+    if (typeof mod === "function") {
+      return mod();
+    } else {
+      return mod;
+    }
+  } catch (e) {
+    if (!(e instanceof Error && e.code === "ERR_MODULE_NOT_FOUND")) {
+      throw new Error(`Could not load ${configName}`, { cause: e });
+    }
+  }
+}
+export {
+  loadBuildConfig
+};

package/misc/exec.d.ts

@@ -0,0 +1,9 @@
+import { SpawnOptions } from 'node:child_process';
+export interface ExecResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export declare function exec(cmd: string[], options?: SpawnOptions & {
+    throwOnError?: boolean;
+}): Promise<ExecResult>;

package/misc/exec.js

@@ -0,0 +1,40 @@
+import { spawn } from "node:child_process";
+function exec(cmd, options) {
+  return new Promise((resolve, reject) => {
+    if (options?.stdio === "inherit") {
+      console.log("\x1B[;34m$\x1B[;0m", cmd.map((it) => it.includes(" ") ? `"${it.replace(/"/g, '\\"')}"` : it).join(" "));
+    }
+    const proc = spawn(cmd[0], cmd.slice(1), {
+      stdio: "pipe",
+      ...options
+    });
+    const stdout = [];
+    const stderr = [];
+    proc.stdout?.on("data", (data) => {
+      stdout.push(data);
+    });
+    proc.stderr?.on("data", (data) => {
+      stderr.push(data);
+    });
+    proc.on("error", reject);
+    proc.on("close", (code) => {
+      if (code !== 0 && options?.throwOnError) {
+        reject(new Error(`Command exited with code ${code}`, {
+          cause: {
+            stderr: Buffer.concat(stderr).toString(),
+            exitCode: code,
+            cmd
+          }
+        }));
+      }
+      resolve({
+        stdout: Buffer.concat(stdout).toString(),
+        stderr: Buffer.concat(stderr).toString(),
+        exitCode: code ?? -1
+      });
+    });
+  });
+}
+export {
+  exec
+};

package/misc/fs.d.ts

@@ -0,0 +1,4 @@
+import { CopyOptions } from 'node:fs';
+export declare function fileExists(path: string): Promise<boolean>;
+export declare function directoryExists(path: string): Promise<boolean>;
+export declare function tryCopy(src: string, dest: string, options?: CopyOptions): Promise<void>;

package/misc/fs.js

@@ -0,0 +1,32 @@
+import * as fsp from "node:fs/promises";
+async function fileExists(path) {
+  try {
+    const stat = await fsp.stat(path);
+    return stat.isFile();
+  } catch {
+    return false;
+  }
+}
+async function directoryExists(path) {
+  try {
+    const stat = await fsp.stat(path);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function tryCopy(src, dest, options) {
+  try {
+    await fsp.cp(src, dest, options);
+  } catch (err) {
+    if (err.code === "ENOENT") ;
+    else {
+      throw err;
+    }
+  }
+}
+export {
+  directoryExists,
+  fileExists,
+  tryCopy
+};

package/misc/index.d.ts

@@ -0,0 +1,4 @@
+export * from './exec.js';
+export * from './path.js';
+export * from './publish-order.js';
+export * from './tsconfig.js';

package/misc/path.d.ts

@@ -0,0 +1 @@
+export declare function normalizeFilePath(filePath: string | URL): string;

package/misc/path.js

@@ -0,0 +1,12 @@
+import { fileURLToPath } from "node:url";
+function normalizeFilePath(filePath) {
+  if (filePath instanceof URL) {
+    return fileURLToPath(filePath);
+  } else if (filePath.startsWith("file://")) {
+    return fileURLToPath(new URL(filePath));
+  }
+  return filePath;
+}
+export {
+  normalizeFilePath
+};

package/misc/publish-order.d.ts

@@ -0,0 +1,3 @@
+import { WorkspacePackage } from '../package-json/collect-package-jsons.js';
+export declare function sortWorkspaceByPublishOrder(packages: WorkspacePackage[]): WorkspacePackage[];
+export declare function determinePublishOrder(dependencies: Record<string, string[]>): string[];

package/misc/publish-order.js

@@ -0,0 +1,56 @@
+import { asNonNull } from "@fuman/utils";
+function sortWorkspaceByPublishOrder(packages) {
+  const workspacePackages = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    workspacePackages.set(asNonNull(pkg.json.name), pkg);
+  }
+  const dependencies = {};
+  for (const pkg of packages) {
+    if (pkg.json.name == null) continue;
+    const list = [];
+    for (const key of ["dependencies", "peerDependencies"]) {
+      const deps = pkg.json[key];
+      if (!deps) continue;
+      for (const name in deps) {
+        if (workspacePackages.has(name)) {
+          list.push(name);
+        }
+      }
+    }
+    dependencies[pkg.json.name] = list;
+  }
+  const order = determinePublishOrder(dependencies);
+  const res = [];
+  for (const name of order) {
+    res.push(asNonNull(workspacePackages.get(name)));
+  }
+  return res;
+}
+function determinePublishOrder(dependencies) {
+  const result = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  function visit(name) {
+    if (visited.has(name)) {
+      return;
+    }
+    if (visiting.has(name)) {
+      throw new Error(`Circular dependency detected: ${name}`);
+    }
+    visiting.add(name);
+    for (const dep of dependencies[name] ?? []) {
+      visit(dep);
+    }
+    visiting.delete(name);
+    visited.add(name);
+    result.push(name);
+  }
+  for (const name in dependencies) {
+    visit(name);
+  }
+  return result;
+}
+export {
+  determinePublishOrder,
+  sortWorkspaceByPublishOrder
+};

package/misc/tsconfig.d.ts

@@ -0,0 +1,2 @@
+export declare function getTsconfigFor(cwd: string): Promise<unknown>;
+export declare function getTsconfigFiles(cwd: string): Promise<string[]>;

package/misc/tsconfig.js

@@ -0,0 +1,28 @@
+import { LruMap } from "@fuman/utils";
+import { exec } from "./exec.js";
+async function getTsconfigFor(cwd) {
+  const res = await exec(["npx", "tsc", "--showConfig"], {
+    cwd,
+    throwOnError: true
+  });
+  return JSON.parse(res.stdout);
+}
+const _tsconfigFilesCache = new LruMap(32);
+async function getTsconfigFiles(cwd) {
+  const cached = _tsconfigFilesCache.get(cwd);
+  if (cached) return cached;
+  const config = await getTsconfigFor(cwd);
+  if (typeof config !== "object" || config === null) {
+    throw new Error("tsconfig.json is not an object");
+  }
+  if (!("files" in config) || !Array.isArray(config.files)) {
+    throw new Error("tsconfig.json > .files is not an array");
+  }
+  const files = config.files.map((file) => file.replace(/^\.\//, ""));
+  _tsconfigFilesCache.set(cwd, files);
+  return files;
+}
+export {
+  getTsconfigFiles,
+  getTsconfigFor
+};

package/npm/index.d.ts

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

package/npm/npm-api.d.ts

@@ -0,0 +1,7 @@
+export declare const NPM_PACKAGE_NAME_REGEX: RegExp;
+/** check if a specific version is available in the jsr registry */
+export declare function npmCheckVersion(params: {
+    registry?: string;
+    package: string;
+    version: string;
+}): Promise<boolean>;

package/npm/npm-api.js

@@ -0,0 +1,18 @@
+import { ffetchBase } from "@fuman/fetch";
+const NPM_PACKAGE_NAME_REGEX = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+async function npmCheckVersion(params) {
+  const {
+    registry = "https://registry.npmjs.org",
+    package: packageName,
+    version
+  } = params;
+  const res = await ffetchBase(`/${packageName}/${version}`, {
+    baseUrl: registry,
+    validateResponse: false
+  });
+  return res.status === 200;
+}
+export {
+  NPM_PACKAGE_NAME_REGEX,
+  npmCheckVersion
+};

package/package-json/collect-package-jsons.d.ts

@@ -0,0 +1,8 @@
+import { PackageJson } from './types.js';
+export interface WorkspacePackage {
+    path: string;
+    root: boolean;
+    json: PackageJson;
+}
+export declare function collectPackageJsons(workspaceRoot: string | URL, includeRoot?: boolean): Promise<WorkspacePackage[]>;
+export declare function filterPackageJsonsForPublish(packages: WorkspacePackage[], registry: 'jsr' | 'npm'): WorkspacePackage[];

package/package-json/collect-package-jsons.js

@@ -0,0 +1,61 @@
+import * as path from "node:path";
+import process from "node:process";
+import { glob } from "tinyglobby";
+import { normalizeFilePath } from "../misc/path.js";
+import { parseWorkspaceRootPackageJson, parsePackageJsonFile } from "./parse.js";
+const maxDepth = process.env.FUMAN_BUILD_MAX_DEPTH !== void 0 ? Number(process.env.FUMAN_BUILD_MAX_DEPTH) : 5;
+async function collectPackageJsons(workspaceRoot, includeRoot = false) {
+  workspaceRoot = normalizeFilePath(workspaceRoot);
+  const packageJsons = [];
+  const rootPackageJson = await parseWorkspaceRootPackageJson(workspaceRoot);
+  if (!rootPackageJson.workspaces) {
+    throw new Error("No workspaces found in package.json");
+  }
+  if (includeRoot) {
+    packageJsons.push({
+      path: workspaceRoot,
+      root: true,
+      json: rootPackageJson
+    });
+  }
+  for (const dir of await glob({
+    patterns: rootPackageJson.workspaces,
+    cwd: workspaceRoot,
+    onlyDirectories: true,
+    followSymbolicLinks: true,
+    deep: maxDepth
+  })) {
+    try {
+      const packageJson = await parsePackageJsonFile(path.join(workspaceRoot, dir, "package.json"));
+      packageJsons.push({
+        path: path.join(workspaceRoot, dir),
+        root: false,
+        json: packageJson
+      });
+    } catch (err) {
+      if (err.code === "ENOENT") ;
+      else {
+        throw err;
+      }
+    }
+  }
+  return packageJsons;
+}
+function filterPackageJsonsForPublish(packages, registry) {
+  const otherRegistry = registry === "npm" ? "jsr" : "npm";
+  return packages.filter((pkg) => {
+    if (pkg.root) {
+      return false;
+    }
+    const fumanConfig = pkg.json.fuman;
+    if (!fumanConfig) return true;
+    if (fumanConfig.private) return false;
+    if (fumanConfig[registry] === "skip") return false;
+    if (fumanConfig[otherRegistry] === "only") return false;
+    return true;
+  });
+}
+export {
+  collectPackageJsons,
+  filterPackageJsonsForPublish
+};

package/package-json/find-package-json.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Find the closest package.json file
+ *
+ * @param from The directory (or file) to start searching from
+ * @example `findPackageJson(import.meta.url)` // returns the package.json file of this package
+ */
+export declare function findPackageJson(from: string | URL): Promise<string | null>;

package/package-json/find-package-json.js

@@ -0,0 +1,28 @@
+import * as path from "node:path";
+import { LruMap } from "@fuman/utils";
+import { fileExists } from "../misc/fs.js";
+import { normalizeFilePath } from "../misc/path.js";
+const _findPackageJsonCache = new LruMap(32);
+async function findPackageJson(from) {
+  from = normalizeFilePath(from);
+  const cached = _findPackageJsonCache.get(from);
+  if (cached != null) return cached;
+  let current = from;
+  while (true) {
+    if (current === "/") return null;
+    const file = path.join(current, "package.json");
+    if (await fileExists(file)) {
+      _findPackageJsonCache.set(from, file);
+      return file;
+    }
+    const parent = path.join(current, "..");
+    if (parent === current) {
+      _findPackageJsonCache.set(from, null);
+      return null;
+    }
+    current = parent;
+  }
+}
+export {
+  findPackageJson
+};

package/package-json/index.d.ts

@@ -0,0 +1,5 @@
+export * from './collect-package-jsons.js';
+export * from './find-package-json.js';
+export * from './parse.js';
+export * from './process-package-json.js';
+export * from './types.js';

package/package-json/parse.d.ts

@@ -0,0 +1,4 @@
+import { PackageJson } from './types.js';
+export declare function parsePackageJson(packageJson: string): PackageJson;
+export declare function parsePackageJsonFile(packageJsonPath: string | URL): Promise<PackageJson>;
+export declare function parseWorkspaceRootPackageJson(workspaceRoot: string | URL): Promise<PackageJson>;

package/package-json/parse.js

@@ -0,0 +1,40 @@
+import * as fsp from "node:fs/promises";
+import path__default from "node:path";
+import * as jsyaml from "js-yaml";
+import { normalizeFilePath } from "../misc/path.js";
+import { PackageJsonSchema } from "./types.js";
+function parsePackageJson(packageJson) {
+  return PackageJsonSchema.parse(JSON.parse(packageJson));
+}
+async function parsePackageJsonFile(packageJsonPath) {
+  return parsePackageJson(await fsp.readFile(normalizeFilePath(packageJsonPath), "utf8"));
+}
+async function parseWorkspaceRootPackageJson(workspaceRoot) {
+  workspaceRoot = normalizeFilePath(workspaceRoot);
+  const packageJsonPath = path__default.join(workspaceRoot, "package.json");
+  const parsed = await parsePackageJsonFile(packageJsonPath);
+  if (!parsed.workspaces) {
+    const pnpmWorkspacePath = path__default.join(workspaceRoot, "pnpm-workspace.yaml");
+    let yaml;
+    try {
+      yaml = await fsp.readFile(pnpmWorkspacePath, "utf8");
+    } catch (e) {
+      if (e.code !== "ENOENT") throw e;
+      return parsed;
+    }
+    const workspace = jsyaml.load(yaml);
+    if (!workspace.packages) {
+      throw new Error("No packages found in pnpm-workspace.yaml");
+    }
+    return {
+      ...parsed,
+      workspaces: workspace.packages
+    };
+  }
+  return parsed;
+}
+export {
+  parsePackageJson,
+  parsePackageJsonFile,
+  parseWorkspaceRootPackageJson
+};

package/package-json/process-package-json.d.ts

@@ -0,0 +1,13 @@
+import { PackageJson } from './types.js';
+export declare function processPackageJson(params: {
+    packageJson: PackageJson;
+    workspaceVersions?: Record<string, string>;
+    bundledWorkspaceDeps?: RegExp[];
+    rootPackageJson?: PackageJson;
+    rootFieldsToCopy?: string[];
+    fixedVersion?: string;
+}): {
+    packageJson: PackageJson;
+    packageJsonOrig: PackageJson;
+    entrypoints: Record<string, string>;
+};