@softarc/native-federation 4.3.1 → 4.4.0

package/dist/lib/utils/io/node-io-adapter.js

@@ -1,51 +1,72 @@
 import * as fs from "fs";
+import * as path from "path";
 import * as crypto from "crypto";
 import fg from "fast-glob";
 const nodeIo = {
-  readText(path) {
-    return fs.readFileSync(path, "utf-8");
+  readText(path2) {
+    return fs.readFileSync(path2, "utf-8");
   },
-  readBytes(path) {
-    return fs.readFileSync(path);
+  readBytes(path2) {
+    return fs.readFileSync(path2);
   },
-  exists(path) {
-    return fs.existsSync(path);
+  exists(path2) {
+    return fs.existsSync(path2);
   },
-  isFile(path) {
+  isFile(path2) {
     try {
-      return fs.statSync(path).isFile();
+      return fs.statSync(path2).isFile();
     } catch {
       return false;
     }
   },
-  isDirectory(path) {
+  isDirectory(path2) {
     try {
-      return fs.statSync(path).isDirectory();
+      return fs.statSync(path2).isDirectory();
     } catch {
       return false;
     }
   },
-  readDir(path) {
+  readDir(path2) {
     try {
-      return fs.readdirSync(path);
+      return fs.readdirSync(path2);
     } catch {
       return [];
     }
   },
-  writeText(path, data) {
-    fs.writeFileSync(path, data, "utf-8");
+  realpath(path2) {
+    try {
+      return fs.realpathSync(path2);
+    } catch {
+      return path2;
+    }
   },
-  mkdirp(path) {
-    fs.mkdirSync(path, { recursive: true });
+  stat(path2) {
+    try {
+      const s = fs.lstatSync(path2);
+      return { mtimeMs: s.mtimeMs, size: s.size, isSymbolicLink: s.isSymbolicLink() };
+    } catch {
+      return null;
+    }
+  },
+  writeText(path2, data) {
+    fs.writeFileSync(path2, data, "utf-8");
+  },
+  mkdirp(path2) {
+    fs.mkdirSync(path2, { recursive: true });
   },
   copyFile(from, to) {
     fs.copyFileSync(from, to);
   },
-  remove(path) {
-    fs.unlinkSync(path);
+  remove(path2) {
+    fs.unlinkSync(path2);
   },
   globFiles(pattern, opts) {
-    return fg.sync(pattern, { cwd: opts.cwd, onlyFiles: true, deep: Infinity });
+    return fg.sync(pattern, {
+      cwd: opts.cwd,
+      ignore: opts.ignore,
+      onlyFiles: true,
+      deep: Infinity
+    });
   },
   hash(algorithm, data) {
     const sum = crypto.createHash(algorithm).update(data);
@@ -54,15 +75,55 @@ const nodeIo = {
       base64: () => sum.digest("base64")
     };
   },
-  watch(path, opts, onEvent) {
-    const watcher = opts.recursive ? fs.watch(
-      path,
-      { recursive: true },
+  watch(watchPath, opts, onEvent) {
+    if (opts.poll) return pollWatch(watchPath, opts.recursive, opts.poll.intervalMs, onEvent);
+    const watcher = fs.watch(
+      watchPath,
+      { recursive: opts.recursive },
       (_event, filename) => onEvent(filename ? filename.toString() : null)
-    ) : fs.watch(path, () => onEvent(path));
+    );
     return { close: () => watcher.close() };
   }
 };
+function pollWatch(root, recursive, intervalMs, onEvent) {
+  const snapshot = () => {
+    const out = /* @__PURE__ */ new Map();
+    const walk = (dir) => {
+      let entries;
+      try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          if (recursive) walk(full);
+        } else {
+          try {
+            out.set(path.relative(root, full), fs.statSync(full).mtimeMs);
+          } catch {
+          }
+        }
+      }
+    };
+    walk(root);
+    return out;
+  };
+  let prev = snapshot();
+  const timer = setInterval(() => {
+    const next = snapshot();
+    for (const [rel, mtime] of next) {
+      if (prev.get(rel) !== mtime) onEvent(rel);
+    }
+    for (const rel of prev.keys()) {
+      if (!next.has(rel)) onEvent(rel);
+    }
+    prev = next;
+  }, intervalMs);
+  timer.unref?.();
+  return { close: () => clearInterval(timer) };
+}
 export {
   nodeIo
 };

package/dist/lib/utils/package/cjs-named-exports.d.ts

@@ -0,0 +1,21 @@
+/** A key is re-exportable only if it is a syntactically valid identifier name. */
+export declare const isIdentifierName: (name: string) => boolean;
+/**
+ * Decides whether a `require()`d CommonJS value needs a synthetic named-export
+ * wrapper, and which names to re-export. UMD/CJS packages (e.g. dayjs) assign
+ * named exports dynamically, invisible to static lexers; enumerating the value
+ * recovers them. ES-module namespaces and `__esModule` interop objects are
+ * skipped — a bundler already exposes those statically.
+ */
+export declare const planCjsWrap: (mod: unknown) => {
+    wrap: boolean;
+    keys: string[];
+};
+/**
+ * Synthetic ESM entry re-exporting the CommonJS default plus each discovered name.
+ * The `export { local as key }` clause lets reserved-word keys (`class`, `default`)
+ * pass without escaping.
+ */
+export declare const buildSyntheticCjsEntry: (importPath: string, keys: string[]) => string;
+/** True when a `require()` failure just means the file was ESM after all. */
+export declare const isEsmInteropError: (err: unknown) => boolean;

package/dist/lib/utils/package/cjs-named-exports.js

@@ -0,0 +1,36 @@
+const isIdentifierName = (name) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
+const planCjsWrap = (mod) => {
+  if (mod === null || typeof mod !== "object" && typeof mod !== "function") {
+    return { wrap: false, keys: [] };
+  }
+  if (mod[Symbol.toStringTag] === "Module") {
+    return { wrap: false, keys: [] };
+  }
+  if (mod["__esModule"]) {
+    return { wrap: false, keys: [] };
+  }
+  const keys = Object.keys(mod).filter(
+    (key) => key !== "default" && key !== "__esModule" && isIdentifierName(key)
+  );
+  return { wrap: keys.length > 0, keys };
+};
+const buildSyntheticCjsEntry = (importPath, keys) => {
+  const spec = JSON.stringify(importPath);
+  const lines = [`import _nfDefault from ${spec};`, `export default _nfDefault;`];
+  if (keys.length > 0) {
+    keys.forEach((key, i) => lines.push(`const _nf${i} = _nfDefault[${JSON.stringify(key)}];`));
+    lines.push(`export { ${keys.map((key, i) => `_nf${i} as ${key}`).join(", ")} };`);
+  }
+  return lines.join("\n") + "\n";
+};
+const isEsmInteropError = (err) => {
+  const code = err?.code;
+  if (code === "ERR_REQUIRE_ESM" || code === "ERR_REQUIRE_ASYNC_MODULE") return true;
+  return err instanceof SyntaxError && /Unexpected token 'export'|Cannot use import statement|export|import statement/.test(err.message);
+};
+export {
+  buildSyntheticCjsEntry,
+  isEsmInteropError,
+  isIdentifierName,
+  planCjsWrap
+};

package/dist/lib/utils/package/entry-point-resolver.js

@@ -44,7 +44,7 @@ function resolvePackageInfo(repo, packageName, directory) {
   const version = mainPkgJson["version"];
   const esm = mainPkgJson["type"] === "module";
   if (!version) {
-    logger.warn("No version found for " + packageName);
+    logger.debug("No version found for " + packageName + " in " + directory);
     return null;
   }
   const pathToSecondary = path.relative(mainPkgName, packageName);
@@ -67,10 +67,7 @@ function resolvePackageInfo(repo, packageName, directory) {
     const result = strategy(ctx);
     if (result) return result;
   }
-  logger.warn("No entry point found for " + packageName);
-  logger.warn(
-    "If you don't need this package, skip it in your federation.config.js or consider moving it into depDependencies in your package.json"
-  );
+  logger.debug("No entry point found for " + packageName + " in " + directory);
   return null;
 }
 export {

package/dist/lib/utils/package/esm-detection.d.ts

@@ -3,3 +3,16 @@
  * or ambiguous (`undefined`).
  */
 export declare const isESMExport: (e: string) => boolean | undefined;
+export type ModuleFormat = 'esm' | 'cjs' | 'unknown';
+/** Node's format rule keyed on extension alone; `.js` stays ambiguous. */
+export declare const classifyByExtension: (entryPoint: string) => ModuleFormat;
+/** Does the source contain top-level ESM `import`/`export`? Dynamic `import()` is excluded (legal in CJS). */
+export declare const hasEsmSyntax: (source: string) => boolean;
+export declare const isCjsCandidate: (input: {
+    esm?: boolean;
+    entryPoint: string;
+    /** Nearest package.json `type` for an ambiguous `.js`. */
+    packageType?: "module" | "commonjs";
+    /** Lazy source for fallback content sniff; only read for an ambiguous `.js`. */
+    readSource?: () => string;
+}) => boolean;

package/dist/lib/utils/package/esm-detection.js

@@ -5,6 +5,35 @@ const isESMExport = (e) => {
   if (e === "cjs" || e === "commonjs") return false;
   return void 0;
 };
+const classifyByExtension = (entryPoint) => {
+  if (entryPoint.endsWith(".mjs")) return "esm";
+  if (entryPoint.endsWith(".cjs")) return "cjs";
+  if (entryPoint.endsWith(".js")) return "unknown";
+  return "esm";
+};
+const hasEsmSyntax = (source) => {
+  const head = source.slice(0, 16384);
+  const exportStmt = /(?:^|[;\n}])\s*export\s*(?:\{|\*|default\b|const\b|let\b|var\b|function\b|async\b|class\b)/;
+  const importStmt = /(?:^|[;\n}])\s*import\s*(?:[A-Za-z_$]|\{|\*|['"])/;
+  return exportStmt.test(head) || importStmt.test(head);
+};
+const isCjsCandidate = (input) => {
+  if (input.esm === true) return false;
+  const fmt = classifyByExtension(input.entryPoint);
+  if (fmt === "esm") return false;
+  if (fmt === "cjs") return true;
+  if (input.packageType === "module") return false;
+  if (input.readSource) {
+    try {
+      if (hasEsmSyntax(input.readSource())) return false;
+    } catch {
+    }
+  }
+  return true;
+};
 export {
+  classifyByExtension,
+  hasEsmSyntax,
+  isCjsCandidate,
   isESMExport
 };

package/dist/lib/utils/package/package-info.d.ts

@@ -2,6 +2,19 @@ import type { PackageInfo, PackageJsonRepository, VersionMap } from '../../domai
 export { sharedPackageJsonRepository } from '../io/package-json-repository.js';
 export type { PackageInfo, VersionMap, ExportCondition, ExportEntry, } from '../../domain/utils/package-json.contract.js';
 export { isESMExport } from './esm-detection.js';
+export declare function tryGetPackageInfo(packageName: string, workspaceRoot: string, repo?: PackageJsonRepository): PackageInfo | null;
+/**
+ * Resolve a package that is expected to be resolvable, warning once if it is not.
+ * Only use this where a failure is genuinely actionable, i.e. for packages the user
+ * asked to share.
+ */
 export declare function getPackageInfo(packageName: string, workspaceRoot: string, repo?: PackageJsonRepository): PackageInfo | null;
+/**
+ * Installed version per key, from each key's package root. Resolution is deduped by root:
+ * `findDepPackageJson` trims to the root anyway, and that root package.json is also where
+ * `resolvePackageInfo` reads the `version` it records as `PackageInfo.version`, so a secondary
+ * yields the same string as its main entry point. Unresolvable keys map to ''.
+ */
+export declare function installedVersions(packageNames: string[], workspaceRoot: string, repo?: PackageJsonRepository): Record<string, string>;
 export declare function getVersionMaps(project: string, workspace: string, repo?: PackageJsonRepository): VersionMap[];
 export declare function findDepPackageJson(packageName: string, projectRoot: string, repo?: PackageJsonRepository): string | null;

package/dist/lib/utils/package/package-info.js

@@ -1,11 +1,11 @@
 import { logger } from "../logger.js";
 import { normalize } from "../normalize.js";
-import { sharedPackageJsonRepository } from "../io/package-json-repository.js";
+import { getPkgFolder, sharedPackageJsonRepository } from "../io/package-json-repository.js";
 import { resolvePackageInfo } from "./entry-point-resolver.js";
 import { getVersionMaps as getVersionMapsFromRepo } from "./version-maps.js";
 import { sharedPackageJsonRepository as sharedPackageJsonRepository2 } from "../io/package-json-repository.js";
 import { isESMExport } from "./esm-detection.js";
-function getPackageInfo(packageName, workspaceRoot, repo = sharedPackageJsonRepository) {
+function tryGetPackageInfo(packageName, workspaceRoot, repo = sharedPackageJsonRepository) {
   workspaceRoot = normalize(workspaceRoot, true);
   for (const info of repo.getPackageJsonFiles(workspaceRoot, workspaceRoot)) {
     const cand = resolvePackageInfo(repo, packageName, info.directory);
@@ -13,9 +13,33 @@ function getPackageInfo(packageName, workspaceRoot, repo = sharedPackageJsonRepo
       return cand;
     }
   }
-  logger.warn("No meta data found for shared lib " + packageName);
   return null;
 }
+function getPackageInfo(packageName, workspaceRoot, repo = sharedPackageJsonRepository) {
+  const info = tryGetPackageInfo(packageName, workspaceRoot, repo);
+  if (!info) {
+    logger.warn("No meta data found for shared lib " + packageName);
+    logger.warn(
+      "If you don't need this package, skip it in your federation.config.js or consider moving it into depDependencies in your package.json"
+    );
+  }
+  return info;
+}
+function installedVersions(packageNames, workspaceRoot, repo = sharedPackageJsonRepository) {
+  workspaceRoot = normalize(workspaceRoot, true);
+  const byRoot = /* @__PURE__ */ new Map();
+  const result = {};
+  for (const packageName of packageNames) {
+    const root = getPkgFolder(packageName);
+    if (!byRoot.has(root)) {
+      const pkgJsonPath = repo.findDepPackageJson(root, workspaceRoot);
+      const version = pkgJsonPath ? repo.readJson(pkgJsonPath)["version"] : "";
+      byRoot.set(root, version ?? "");
+    }
+    result[packageName] = byRoot.get(root);
+  }
+  return result;
+}
 function getVersionMaps(project, workspace, repo = sharedPackageJsonRepository) {
   return getVersionMapsFromRepo(repo, project, workspace);
 }
@@ -26,6 +50,8 @@ export {
   findDepPackageJson,
   getPackageInfo,
   getVersionMaps,
+  installedVersions,
   isESMExport,
-  sharedPackageJsonRepository2 as sharedPackageJsonRepository
+  sharedPackageJsonRepository2 as sharedPackageJsonRepository,
+  tryGetPackageInfo
 };

package/dist/lib/utils/package/resolve-wildcard-keys.js

@@ -1,10 +1,16 @@
-import { captureWildcard, parseWildcard, substituteWildcard, toPosix } from "../path-patterns.js";
+import {
+  captureWildcard,
+  parseWildcard,
+  substituteWildcard,
+  toGlobPattern,
+  toPosix
+} from "../path-patterns.js";
 function resolvePackageJsonExportsWildcardCore(io, keyPattern, valuePattern, cwd) {
   const pattern = parseWildcard(valuePattern.replace(/^\.?\/+/, ""));
   if (!pattern.hasWildcard) {
     return [];
   }
-  const files = io.globFiles(pattern.prefix + "**/*" + pattern.suffix, { cwd });
+  const files = io.globFiles(toGlobPattern(pattern), { cwd, ignore: ["**/node_modules/**"] });
   const keys = [];
   for (const file of files) {
     const relPath = toPosix(file).replace(/^\.\//, "");

package/dist/lib/utils/path-patterns.d.ts

@@ -1,4 +1,11 @@
 export declare const toPosix: (p: string) => string;
+/**
+ * True when `file` is `dir` itself or lives under it. Both sides are normalized, so a
+ * caller cannot splice in `path.sep` and get a predicate that is silently always-false
+ * on Windows -- `linkedSharedDirs` and the file watcher both emit posix paths.
+ */
+export declare function isUnderDir(file: string, dir: string): boolean;
+export declare const isUnderAnyDir: (file: string, dirs: readonly string[]) => boolean;
 export interface WildcardPattern {
     prefix: string;
     suffix: string;
@@ -12,3 +19,10 @@ export declare function matchesWildcard(value: string, pattern: string): boolean
  */
 export declare function captureWildcard(value: string, pattern: WildcardPattern): string | null;
 export declare function substituteWildcard(template: string, captured: string): string;
+/**
+ * A glob that is a superset of the pattern, for callers that re-check the match themselves
+ * (`captureWildcard`, `matchMapping`). `**` only acts as a globstar on a segment of its own,
+ * so a prefix stopping mid-segment (`libs/ui-`) has to be widened back to its directory --
+ * `libs/ui-**` reads as `libs/ui-*` and silently matches nothing one level down.
+ */
+export declare function toGlobPattern({ prefix, suffix }: WildcardPattern): string;

package/dist/lib/utils/path-patterns.js

@@ -1,4 +1,10 @@
 const toPosix = (p) => p.replace(/\\/g, "/");
+function isUnderDir(file, dir) {
+  const f = toPosix(file);
+  const d = toPosix(dir).replace(/\/+$/, "");
+  return f === d || f.startsWith(d + "/");
+}
+const isUnderAnyDir = (file, dirs) => dirs.some((d) => isUnderDir(file, d));
 function parseWildcard(pattern) {
   const i = pattern.indexOf("*");
   if (i === -1) return { prefix: pattern, suffix: "", hasWildcard: false };
@@ -19,10 +25,16 @@ function captureWildcard(value, pattern) {
 function substituteWildcard(template, captured) {
   return template.replace("*", captured);
 }
+function toGlobPattern({ prefix, suffix }) {
+  return prefix.slice(0, prefix.lastIndexOf("/") + 1) + "**/*" + suffix;
+}
 export {
   captureWildcard,
+  isUnderAnyDir,
+  isUnderDir,
   matchesWildcard,
   parseWildcard,
   substituteWildcard,
+  toGlobPattern,
   toPosix
 };

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@softarc/native-federation",
-  "version": "4.3.1",
+  "version": "4.4.0",
   "type": "module",
   "license": "MIT",
-  "packageManager": "pnpm@11.11.0",
+  "packageManager": "pnpm@11.18.0",
   "scripts": {
     "build": "node esbuild.config.mjs && tsc -p tsconfig.build.json",
     "lint": "eslint src",
@@ -13,7 +13,7 @@
   },
   "dependencies": {
     "@softarc/sheriff-core": "^0.19.6",
-    "chalk": "^5.6.2",
+    "chalk": "^6.0.0",
     "esbuild": "^0.28.0",
     "fast-glob": "^3.3.3",
     "json5": "^2.2.3"
@@ -27,12 +27,12 @@
     "globals": "^17.3.0",
     "jiti": "^2.6.1",
     "jsdom": "^29.0.0",
-    "knip": "^6.20.0",
-    "prettier": "^3.8.1",
+    "knip": "^6.26.0",
+    "prettier": "^3.9.4",
     "tslib": "^2.3.0",
     "typescript": "~6.0.0",
     "typescript-eslint": "^8.61.0",
-    "vite": "^8.0.0",
+    "vite": "^8.2.0",
     "vitest": "^4.0.0"
   },
   "exports": {