everything-dev 1.27.0 → 1.28.1

package/src/internal/manifest-normalizer.ts

@@ -1,290 +0,0 @@
-import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { dirname, join, relative, sep } from "node:path";
-import { glob } from "glob";
-
-const FRAMEWORK_PACKAGES = ["every-plugin", "everything-dev"] as const;
-
-const CATALOG_TOOL_PACKAGES = [
-  "@rspack/core",
-  "@rspack/cli",
-  "@rsbuild/core",
-  "@rsbuild/plugin-react",
-  "@module-federation/enhanced",
-  "@module-federation/node",
-  "@module-federation/rsbuild-plugin",
-  "@module-federation/runtime-core",
-  "@module-federation/sdk",
-  "@module-federation/dts-plugin",
-] as const;
-
-type PackageJson = Record<string, unknown>;
-
-type NormalizationSpec = {
-  rootCatalog: Record<string, string>;
-  frameworkVersions: Record<string, string>;
-};
-
-type NormalizeManifestOptions = {
-  resolveCatalogRefs: boolean;
-  preserveCatalogRefs?: boolean;
-  excludeFrameworkWorkspaces?: boolean;
-  removeWorkspaceDeps?: string[];
-  removeWorkspaces?: boolean;
-  removePublishScripts?: boolean;
-};
-
-export type NormalizeTreeOptions = NormalizeManifestOptions & {
-  sourceRootDir: string;
-  targetDir: string;
-};
-
-function readJson<T>(filePath: string): T {
-  return JSON.parse(readFileSync(filePath, "utf-8")) as T;
-}
-
-function extractExactVersion(input: string | undefined): string | null {
-  if (!input) return null;
-  const match = input.match(/\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?/);
-  return match ? match[0] : null;
-}
-
-function writeJson(filePath: string, value: PackageJson) {
-  writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
-}
-
-export function loadManifestNormalizationSpec(sourceRootDir: string): NormalizationSpec {
-  const rootPackage = readJson<PackageJson>(join(sourceRootDir, "package.json"));
-  const rootCatalog = {
-    ...(((rootPackage.workspaces as { catalog?: Record<string, string> } | undefined)?.catalog ??
-      {}) as Record<string, string>),
-  };
-  const frameworkVersions: Record<string, string> = {};
-
-  for (const packageName of FRAMEWORK_PACKAGES) {
-    const sourcePackagePath = join(sourceRootDir, "packages", packageName, "package.json");
-    const localPackagePath = join(import.meta.dirname, "..", "..", packageName, "package.json");
-    const packageVersion = existsSync(localPackagePath)
-      ? readJson<{ version: string }>(localPackagePath).version
-      : existsSync(sourcePackagePath)
-        ? readJson<{ version: string }>(sourcePackagePath).version
-        : extractExactVersion(rootCatalog[packageName]);
-
-    if (!packageVersion) {
-      throw new Error(`Could not resolve version for ${packageName}`);
-    }
-
-    frameworkVersions[packageName] = packageVersion;
-    rootCatalog[packageName] = `^${packageVersion}`;
-  }
-
-  return { rootCatalog, frameworkVersions };
-}
-
-function normalizeDependencyMap(
-  map: Record<string, string>,
-  spec: NormalizationSpec,
-  options: NormalizeManifestOptions,
-) {
-  const catalogPackages = new Set<string>([...FRAMEWORK_PACKAGES, ...CATALOG_TOOL_PACKAGES]);
-
-  let modified = false;
-
-  for (const [name, version] of Object.entries(map)) {
-    if (options.preserveCatalogRefs && catalogPackages.has(name)) {
-      if (version !== "catalog:") {
-        map[name] = "catalog:";
-        modified = true;
-      }
-      continue;
-    }
-
-    if (version === "workspace:*") {
-      const frameworkVersion = spec.frameworkVersions[name];
-      if (frameworkVersion) {
-        map[name] = `^${frameworkVersion}`;
-        modified = true;
-        continue;
-      }
-
-      if (options.removeWorkspaceDeps?.includes(name)) {
-        delete map[name];
-        modified = true;
-      }
-      continue;
-    }
-
-    if (options.resolveCatalogRefs && version.startsWith("catalog:")) {
-      const resolved = spec.rootCatalog[name];
-      if (resolved) {
-        map[name] = resolved;
-        modified = true;
-      }
-    }
-  }
-
-  return modified;
-}
-
-export function normalizePackageManifest(
-  pkg: PackageJson,
-  spec: NormalizationSpec,
-  options: NormalizeManifestOptions,
-) {
-  let modified = false;
-
-  for (const depField of ["dependencies", "devDependencies", "peerDependencies"]) {
-    const deps = pkg[depField];
-    if (!deps || typeof deps !== "object") continue;
-    if (normalizeDependencyMap(deps as Record<string, string>, spec, options)) {
-      modified = true;
-    }
-  }
-
-  if (pkg.workspaces && typeof pkg.workspaces === "object") {
-    const workspaces = pkg.workspaces as {
-      packages?: string[];
-      catalog?: Record<string, string>;
-    };
-
-    if (options.excludeFrameworkWorkspaces && Array.isArray(workspaces.packages)) {
-      const nextPackages = workspaces.packages.filter(
-        (entry) => !FRAMEWORK_PACKAGES.some((name) => entry === `packages/${name}`),
-      );
-      if (nextPackages.length !== workspaces.packages.length) {
-        workspaces.packages = nextPackages;
-        modified = true;
-      }
-    }
-
-    if (workspaces.catalog && typeof workspaces.catalog === "object") {
-      for (const [name, version] of Object.entries(workspaces.catalog)) {
-        const resolved = spec.rootCatalog[name];
-        if (resolved && resolved !== version) {
-          workspaces.catalog[name] = resolved;
-          modified = true;
-          continue;
-        }
-
-        if (version === "workspace:*" && spec.frameworkVersions[name]) {
-          workspaces.catalog[name] = `^${spec.frameworkVersions[name]}`;
-          modified = true;
-        }
-      }
-    }
-  }
-
-  if (options.removeWorkspaces && "workspaces" in pkg) {
-    delete pkg.workspaces;
-    modified = true;
-  }
-
-  if (options.removePublishScripts && pkg.scripts && typeof pkg.scripts === "object") {
-    const scripts = pkg.scripts as Record<string, string>;
-    let scriptsModified = false;
-    for (const key of ["prepublishOnly", "prepack", "prepare", "postpack"]) {
-      if (key in scripts) {
-        delete scripts[key];
-        scriptsModified = true;
-      }
-    }
-    if (scriptsModified) {
-      modified = true;
-      if (Object.keys(scripts).length === 0) {
-        delete pkg.scripts;
-      }
-    }
-  }
-
-  return modified;
-}
-
-export async function normalizePackageManifestsInTree(opts: NormalizeTreeOptions) {
-  const spec = loadManifestNormalizationSpec(opts.sourceRootDir);
-  const files = await glob("**/package.json", {
-    cwd: opts.targetDir,
-    nodir: true,
-    dot: false,
-    absolute: true,
-    ignore: ["**/node_modules/**"],
-  });
-
-  const updatedFiles: string[] = [];
-
-  for (const filePath of files) {
-    const pkg = readJson<PackageJson>(filePath);
-    if (normalizePackageManifest(pkg, spec, opts)) {
-      writeJson(filePath, pkg);
-      updatedFiles.push(filePath);
-    }
-  }
-
-  return updatedFiles;
-}
-
-function shouldCopyPackageFile(sourceDir: string, filePath: string) {
-  const relPath = relative(sourceDir, filePath);
-  if (!relPath) return true;
-  const segments = relPath.split(sep);
-  return !segments.includes("node_modules") && !segments.includes("tests");
-}
-
-function stripDevelopmentExports(pkg: PackageJson) {
-  const exports = pkg.exports;
-  if (!exports || typeof exports !== "object") return;
-
-  for (const key of Object.keys(exports as Record<string, unknown>)) {
-    const entry = (exports as Record<string, unknown>)[key];
-    if (entry && typeof entry === "object") {
-      delete (entry as Record<string, unknown>).development;
-    }
-  }
-}
-
-export function stageReleasePackage(opts: {
-  repoRoot: string;
-  packageName: string;
-  outDir: string;
-}) {
-  const sourceDir = join(opts.repoRoot, "packages", opts.packageName);
-
-  rmSync(opts.outDir, { recursive: true, force: true });
-  mkdirSync(dirname(opts.outDir), { recursive: true });
-  cpSync(sourceDir, opts.outDir, {
-    recursive: true,
-    filter: (filePath) => shouldCopyPackageFile(sourceDir, filePath),
-  });
-  rmSync(join(opts.outDir, "tests"), { recursive: true, force: true });
-
-  const packageJsonPath = join(opts.outDir, "package.json");
-  const spec = loadManifestNormalizationSpec(opts.repoRoot);
-  const pkg = readJson<PackageJson>(packageJsonPath);
-
-  normalizePackageManifest(pkg, spec, {
-    resolveCatalogRefs: true,
-    preserveCatalogRefs: false,
-    removeWorkspaces: true,
-    removePublishScripts: true,
-  });
-
-  stripDevelopmentExports(pkg);
-
-  writeJson(packageJsonPath, pkg);
-}
-
-export function stageReleasePackages(opts: {
-  repoRoot: string;
-  outDir: string;
-  packageNames?: string[];
-}) {
-  const packageNames = opts.packageNames ?? [...FRAMEWORK_PACKAGES];
-  rmSync(opts.outDir, { recursive: true, force: true });
-  mkdirSync(opts.outDir, { recursive: true });
-
-  for (const packageName of packageNames) {
-    stageReleasePackage({
-      repoRoot: opts.repoRoot,
-      packageName,
-      outDir: join(opts.outDir, packageName),
-    });
-  }
-}

package/src/merge.ts

@@ -1,187 +0,0 @@
-import { createDefu } from "defu";
-import type { BosConfigInput, ExtendsConfig } from "./types";
-
-export const BOS_CONFIG_ORDER = [
-  "extends",
-  "account",
-  "domain",
-  "title",
-  "description",
-  "testnet",
-  "staging",
-  "repository",
-  "app",
-  "plugins",
-  "shared",
-] as const;
-
-export type BosConfigFieldName = (typeof BOS_CONFIG_ORDER)[number];
-
-export type BosEnv = "development" | "production" | "staging";
-
-export interface ResolvedConfigMeta {
-  env: BosEnv;
-  resolvedAt: string;
-  extendsChain: string[];
-  source?: string;
-}
-
-const ARRAY_UNION_KEYS = new Set(["secrets"]);
-
-export function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-
-function unionArrays(a: unknown, b: unknown): unknown[] | undefined {
-  const aArr = Array.isArray(a) ? a : [];
-  const bArr = Array.isArray(b) ? b : [];
-  if (aArr.length === 0 && bArr.length === 0) return undefined;
-  const seen = new Set<string>();
-  const result: unknown[] = [];
-  for (const item of [...aArr, ...bArr]) {
-    if (typeof item === "string") {
-      if (seen.has(item)) continue;
-      seen.add(item);
-    }
-    result.push(item);
-  }
-  return result;
-}
-
-function cleanNullSentinels(obj: Record<string, unknown>): Record<string, unknown> {
-  const out: Record<string, unknown> = {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (value === null || value === undefined) continue;
-    if (isPlainObject(value)) {
-      const cleaned = cleanNullSentinels(value);
-      if (Object.keys(cleaned).length > 0) {
-        out[key] = cleaned;
-      }
-    } else {
-      out[key] = value;
-    }
-  }
-  return out;
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const bosConfigMerger = createDefu((obj: any, key: any, value: any): boolean | undefined => {
-  if (obj[key] === null) return true;
-  if (value === null) {
-    obj[key] = null;
-    return true;
-  }
-  if (Array.isArray(obj[key]) && Array.isArray(value)) {
-    if (ARRAY_UNION_KEYS.has(key)) {
-      obj[key] = unionArrays(obj[key], value);
-    } else {
-      obj[key] = value;
-    }
-    return true;
-  }
-  return false;
-});
-
-export function resolveExtendsRef(
-  extendsField: string | ExtendsConfig | undefined,
-  env: BosEnv,
-): string | undefined {
-  if (!extendsField) return undefined;
-  if (typeof extendsField === "string") return extendsField;
-  return extendsField[env] ?? extendsField.production ?? Object.values(extendsField).find(Boolean);
-}
-
-export function mergeBosConfigWithExtends(
-  parent: BosConfigInput,
-  child: BosConfigInput,
-): BosConfigInput {
-  const { plugins: _ignoredParentPlugins, ...parentWithoutPlugins } = parent;
-  const merged = bosConfigMerger(child, parentWithoutPlugins) as BosConfigInput;
-
-  if (child.plugins !== undefined && isPlainObject(child.plugins)) {
-    (merged as Record<string, unknown>).plugins = cleanNullSentinels(
-      child.plugins as Record<string, unknown>,
-    );
-  } else {
-    delete (merged as Record<string, unknown>).plugins;
-  }
-
-  const mergedRecord = merged as Record<string, unknown>;
-
-  if (isPlainObject(mergedRecord.app)) {
-    for (const entryVal of Object.values(mergedRecord.app as Record<string, unknown>)) {
-      if (!isPlainObject(entryVal)) continue;
-      for (const secretKey of ARRAY_UNION_KEYS) {
-        if (Array.isArray(entryVal[secretKey])) {
-          entryVal[secretKey] =
-            (unionArrays(entryVal[secretKey] as unknown[], []) as string[] | undefined)?.filter(
-              Boolean,
-            ) ?? entryVal[secretKey];
-        }
-      }
-    }
-  }
-
-  if (isPlainObject(mergedRecord.plugins)) {
-    for (const pluginVal of Object.values(mergedRecord.plugins as Record<string, unknown>)) {
-      if (!isPlainObject(pluginVal)) continue;
-      for (const secretKey of ARRAY_UNION_KEYS) {
-        if (Array.isArray(pluginVal[secretKey])) {
-          pluginVal[secretKey] =
-            (unionArrays(pluginVal[secretKey] as unknown[], []) as string[] | undefined)?.filter(
-              Boolean,
-            ) ?? pluginVal[secretKey];
-        }
-      }
-    }
-  }
-
-  return rebuildOrderedConfig(mergedRecord) as BosConfigInput;
-}
-
-export function mergeBosConfigWithTemplate(
-  local: BosConfigInput,
-  template: BosConfigInput,
-): BosConfigInput {
-  const merged = mergeJsonValuesPreservingLocalOrder(local, template) as BosConfigInput;
-  return rebuildOrderedConfig(merged as Record<string, unknown>) as BosConfigInput;
-}
-
-function mergeJsonValuesPreservingLocalOrder(local: unknown, template: unknown): unknown {
-  if (isPlainObject(local) && isPlainObject(template)) {
-    const merged: Record<string, unknown> = {};
-    for (const key of Object.keys(local)) {
-      merged[key] = mergeJsonValuesPreservingLocalOrder(
-        local[key],
-        (template as Record<string, unknown>)[key],
-      );
-    }
-    for (const key of Object.keys(template as Record<string, unknown>)) {
-      if (!(key in merged)) {
-        merged[key] = (template as Record<string, unknown>)[key];
-      }
-    }
-    return merged;
-  }
-  return local ?? template;
-}
-
-export function rebuildOrderedConfig<T extends Record<string, unknown>>(config: T): T {
-  const ordered: Record<string, unknown> = {};
-
-  for (const key of BOS_CONFIG_ORDER) {
-    if (key in config) {
-      ordered[key] = config[key];
-    }
-  }
-
-  for (const key of Object.keys(config)) {
-    if (!BOS_CONFIG_ORDER.includes(key as BosConfigFieldName)) {
-      ordered[key] = config[key];
-    }
-  }
-
-  return ordered as T;
-}
-
-export { bosConfigMerger };

package/src/mf.ts

@@ -1,147 +0,0 @@
-import { createInstance, getInstance } from "@module-federation/enhanced/runtime";
-import { setGlobalFederationInstance } from "@module-federation/runtime-core";
-import { computeSriHash, type IntegrityRegistry } from "./integrity";
-
-type FederationInstance = ReturnType<typeof createInstance>;
-
-let mfInstance: FederationInstance | null = null;
-
-export function patchManifestFetchForSsrPublicPath(mf: FederationInstance): void {
-  if (!mf || !(mf as any).loaderHook?.lifecycle?.fetch?.on) return;
-  if ((mf as any).__everythingDevPatchedManifestFetch === true) return;
-  (mf as any).__everythingDevPatchedManifestFetch = true;
-
-  (mf as any).loaderHook.lifecycle.fetch.on((url: unknown, init: unknown) => {
-    if (typeof url !== "string" || !url.endsWith("/mf-manifest.json")) {
-      return;
-    }
-    return fetch(url, init as any)
-      .then((res) => res.json())
-      .then((json: any) => {
-        json.metaData = json.metaData ?? {};
-        json.metaData.ssrPublicPath =
-          json.metaData.ssrPublicPath ?? url.replace(/\/mf-manifest\.json$/, "/");
-        return new Response(JSON.stringify(json), {
-          headers: { "content-type": "application/json" },
-        });
-      });
-  });
-}
-
-export function installIntegrityFetchHook(
-  mf: FederationInstance,
-  registry: IntegrityRegistry,
-): void {
-  if (!mf || !(mf as any).loaderHook?.lifecycle?.fetch?.on) {
-    console.warn("[SRI] MF lifecycle fetch hook not available, skipping integrity-in-pipeline");
-    return;
-  }
-  if ((mf as any).__everythingDevIntegrityHook === true) return;
-  (mf as any).__everythingDevIntegrityHook = true;
-
-  (mf as any).loaderHook.lifecycle.fetch.on((url: unknown, init: unknown) => {
-    if (typeof url !== "string") return;
-
-    const expectedHash = registry.get(url);
-    if (!expectedHash) return;
-
-    return fetch(url, init as any).then(async (res) => {
-      const buffer = Buffer.from(await res.arrayBuffer());
-      const computed = computeSriHash(buffer);
-
-      if (computed !== expectedHash) {
-        console.error(
-          `[SRI] Integrity check failed in MF fetch pipeline for ${url}\n  Expected: ${expectedHash}\n  Computed: ${computed}`,
-        );
-        return new Response(`Integrity check failed for ${url}`, {
-          status: 500,
-          statusText: "Integrity Check Failed",
-        });
-      }
-
-      console.log(`[SRI] Integrity verified in pipeline for ${url}`);
-      return new Response(buffer, {
-        status: res.status,
-        statusText: res.statusText,
-        headers: res.headers,
-      });
-    });
-  });
-}
-
-export function getFederationInstance(): FederationInstance {
-  if (mfInstance) return mfInstance;
-
-  const existing = getInstance();
-  if (existing) {
-    mfInstance = existing as FederationInstance;
-    setGlobalFederationInstance(mfInstance as any);
-    patchManifestFetchForSsrPublicPath(mfInstance);
-    return mfInstance;
-  }
-
-  mfInstance = createInstance({
-    name: "host",
-    remotes: [],
-  }) as FederationInstance;
-  setGlobalFederationInstance(mfInstance as any);
-  patchManifestFetchForSsrPublicPath(mfInstance);
-  return mfInstance;
-}
-
-export async function registerRemote(opts: {
-  name: string;
-  entry: string;
-  type?: "manifest" | "script";
-}): Promise<void> {
-  const instance = getFederationInstance();
-
-  const inferType = (): "manifest" | "script" => {
-    if (opts.type) return opts.type;
-    if (opts.entry.endsWith("/mf-manifest.json")) return "manifest";
-    if (opts.entry.endsWith("/remoteEntry.js")) return "script";
-    return typeof window === "undefined" ? "script" : "manifest";
-  };
-
-  const remoteType = inferType();
-
-  instance.registerRemotes([
-    {
-      name: opts.name,
-      entry: opts.entry,
-      type: remoteType,
-    },
-  ]);
-}
-
-export async function loadRemoteModule<T>(
-  specifier: string,
-  options?: { loadFactory?: boolean; from?: "build" | "runtime" },
-): Promise<T> {
-  const instance = getFederationInstance();
-
-  const isServer = typeof window === "undefined";
-  if (isServer) {
-    await (instance as any).initializeSharing?.("default");
-  }
-
-  const mod = await instance.loadRemote<T>(specifier, options as any);
-  if (!mod) {
-    throw new Error(`Failed to load remote module: ${specifier}`);
-  }
-  return mod;
-}
-
-export async function ensureNodeRuntimePlugin(): Promise<void> {
-  const instance = getFederationInstance();
-  if (typeof window !== "undefined") return;
-  if ((instance as any).__nodeRuntimePluginLoaded) return;
-
-  const mod: any = await import("@module-federation/node/runtimePlugin");
-  const factory = mod?.default ?? mod;
-  const plugin = typeof factory === "function" ? factory() : null;
-  if (plugin) {
-    instance.registerPlugins([plugin]);
-  }
-  (instance as any).__nodeRuntimePluginLoaded = true;
-}