@softarc/native-federation 4.1.2 → 4.2.0

package/dist/lib/core/build/rewrite-chunk-imports.js

@@ -0,0 +1,74 @@
+import * as ts from "typescript";
+import * as path from "path";
+import { nodeIo } from "../../utils/io/node-io-adapter.js";
+import { toChunkImport } from "../../domain/core/chunk.js";
+function rewriteChunkImports(filePath) {
+  rewriteChunkImportsCore(nodeIo, filePath);
+}
+function rewriteChunkImportsCore(io, filePath) {
+  io.writeText(filePath, transformChunkImports(io.readText(filePath), path.basename(filePath)));
+}
+function transformChunkImports(sourceCode, fileName) {
+  const sourceFile = ts.createSourceFile(
+    fileName,
+    sourceCode,
+    ts.ScriptTarget.ESNext,
+    true,
+    ts.ScriptKind.JS
+  );
+  const printer = ts.createPrinter();
+  function visit(node) {
+    if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
+      const moduleSpecifier = node.moduleSpecifier;
+      if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier)) {
+        const text = moduleSpecifier.text;
+        if (text.startsWith("./")) {
+          const newModuleSpecifier = ts.factory.createStringLiteral(toChunkImport(text));
+          if (ts.isImportDeclaration(node)) {
+            return ts.factory.updateImportDeclaration(
+              node,
+              node.modifiers,
+              node.importClause,
+              newModuleSpecifier,
+              node.assertClause
+            );
+          } else {
+            return ts.factory.updateExportDeclaration(
+              node,
+              node.modifiers,
+              node.isTypeOnly,
+              node.exportClause,
+              newModuleSpecifier,
+              node.assertClause
+            );
+          }
+        }
+      }
+    }
+    if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+      const [arg] = node.arguments;
+      if (arg && ts.isStringLiteral(arg)) {
+        const text = arg.text;
+        if (text.startsWith("./")) {
+          const newArg = ts.factory.createStringLiteral(toChunkImport(text));
+          return ts.factory.updateCallExpression(node, node.expression, node.typeArguments, [
+            newArg
+          ]);
+        }
+      }
+    }
+    return ts.visitEachChild(node, visit, void 0);
+  }
+  const transformed = ts.transform(sourceFile, [(_) => (node) => ts.visitNode(node, visit)]);
+  const updatedSourceFile = transformed.transformed[0];
+  return printer.printFile(updatedSourceFile);
+}
+function isSourceFile(fileName) {
+  return !!fileName.match(/.(m|c)?js$/);
+}
+export {
+  isSourceFile,
+  rewriteChunkImports,
+  rewriteChunkImportsCore,
+  transformChunkImports
+};

package/dist/lib/core/cache/cache-persistence.d.ts

@@ -0,0 +1,22 @@
+import type { NormalizedExternalConfig } from '../../domain/config/external-config.contract.js';
+import type { ChunkInfo, IntegrityMap, SharedInfo } from '../../domain/core/federation-info.contract.js';
+import type { FileReaderPort, FileWriterPort, HashPort } from '../../domain/utils/io-port.contract.js';
+export declare const getDefaultCachePath: (workspaceRoot: string) => string;
+export declare const getFilename: (title: string, dev?: boolean) => string;
+export declare const getChecksum: (shared: Record<string, NormalizedExternalConfig>, dev: "1" | "0", builderVersion?: string) => string;
+export declare const getChecksumCore: (hash: HashPort, shared: Record<string, NormalizedExternalConfig>, dev: "1" | "0", builderVersion?: string) => string;
+export type CacheMetadata = {
+    checksum: string;
+    externals: SharedInfo[];
+    chunks?: ChunkInfo;
+    integrity?: IntegrityMap;
+    files: string[];
+};
+type CachePort = FileReaderPort & FileWriterPort;
+export declare const cacheEntryCore: (io: CachePort, pathToCache: string, fileName: string) => {
+    getMetadata: (checksum: string) => CacheMetadata | undefined;
+    persist: (payload: CacheMetadata) => void;
+    copyFiles: (fullOutputPath: string) => void;
+    clear: () => void;
+};
+export {};

package/dist/lib/core/cache/cache-persistence.js

@@ -0,0 +1,63 @@
+import path from "path";
+import { nodeIo } from "../../utils/io/node-io-adapter.js";
+import { logger } from "../../utils/logger.js";
+const getDefaultCachePath = (workspaceRoot) => path.join(workspaceRoot, "node_modules/.cache/native-federation");
+const getFilename = (title, dev) => {
+  const devSuffix = dev ? "-dev" : "";
+  return `${title}${devSuffix}.meta.json`;
+};
+const getChecksum = (shared, dev, builderVersion = "") => getChecksumCore(nodeIo, shared, dev, builderVersion);
+const getChecksumCore = (hash, shared, dev, builderVersion = "") => {
+  const denseExternals = Object.keys(shared).sort().reduce((clean, external) => {
+    return clean + ":" + external + (shared[external].version ? `@${shared[external].version}` : "");
+  }, "deps");
+  return hash.hash("sha256", denseExternals + `:dev=${dev}:builder=${builderVersion}`).hex();
+};
+const cacheEntryCore = (io, pathToCache, fileName) => {
+  const metadataFile = path.join(pathToCache, fileName);
+  const readMetadata = () => JSON.parse(io.readText(metadataFile));
+  return {
+    getMetadata: (checksum) => {
+      if (!io.exists(pathToCache) || !io.exists(metadataFile)) return void 0;
+      const cachedResult = readMetadata();
+      if (cachedResult.checksum !== checksum) return void 0;
+      return cachedResult;
+    },
+    persist: (payload) => {
+      io.writeText(metadataFile, JSON.stringify(payload));
+    },
+    copyFiles: (fullOutputPath) => {
+      if (!io.exists(metadataFile))
+        throw new Error("Error copying artifacts to dist, metadata file could not be found.");
+      const cachedResult = readMetadata();
+      io.mkdirp(fullOutputPath);
+      cachedResult.files.forEach((file) => {
+        const cachedFile = path.join(pathToCache, file);
+        const distFileName = path.join(fullOutputPath, file);
+        if (io.exists(cachedFile)) io.copyFile(cachedFile, distFileName);
+      });
+    },
+    clear: () => {
+      if (!io.exists(pathToCache)) {
+        io.mkdirp(pathToCache);
+        logger.debug(`Creating cache folder '${pathToCache}' for '${fileName}'.`);
+        return;
+      }
+      if (!io.exists(metadataFile)) return;
+      logger.debug(`Purging cached bundle '${metadataFile}'.`);
+      const cachedResult = readMetadata();
+      cachedResult.files.forEach((file) => {
+        const cachedFile = path.join(pathToCache, file);
+        if (io.exists(cachedFile)) io.remove(cachedFile);
+      });
+      io.remove(metadataFile);
+    }
+  };
+};
+export {
+  cacheEntryCore,
+  getChecksum,
+  getChecksumCore,
+  getDefaultCachePath,
+  getFilename
+};

package/{src/lib/core → dist/lib/core/cache}/federation-cache.d.ts

@@ -1,5 +1,5 @@
-import type { FederationCache } from '../domain/core/federation-cache.contract.js';
-import type { ChunkInfo, IntegrityMap, SharedInfo } from '../domain/core/federation-info.contract.js';
+import type { FederationCache } from '../../domain/core/federation-cache.contract.js';
+import type { ChunkInfo, IntegrityMap, SharedInfo } from '../../domain/core/federation-info.contract.js';
 export declare function createFederationCache(cachePath: string): FederationCache<undefined>;
 export declare function createFederationCache<TBundlerCache>(cachePath: string, bundlerCache: TBundlerCache): FederationCache<TBundlerCache>;
 export declare function addExternalsToCache(cache: FederationCache, { externals, chunks, integrity, }: {

package/dist/lib/core/cache/federation-cache.js

@@ -0,0 +1,22 @@
+function createFederationCache(cachePath, bundlerCache) {
+  return { externals: [], cachePath, bundlerCache };
+}
+function addExternalsToCache(cache, {
+  externals,
+  chunks,
+  integrity
+}) {
+  cache.externals.push(...externals);
+  if (chunks) {
+    if (!cache.chunks) cache.chunks = {};
+    cache.chunks = { ...cache.chunks, ...chunks };
+  }
+  if (integrity) {
+    if (!cache.integrity) cache.integrity = {};
+    cache.integrity = { ...cache.integrity, ...integrity };
+  }
+}
+export {
+  addExternalsToCache,
+  createFederationCache
+};

package/dist/lib/core/federation-builder.js

@@ -0,0 +1,53 @@
+import { getConfigContext, usePackageJson, useWorkspace } from "../config/configuration-context.js";
+import { getBuildAdapter, setBuildAdapter } from "./build/build-adapter.js";
+import { buildForFederation } from "./build/build-for-federation.js";
+import { getExternals } from "./build/get-externals.js";
+import { normalizeFederationOptions } from "./normalize-options.js";
+import { rebuildForFederation } from "./build/rebuild-for-federation.js";
+let externals = [];
+let config;
+let options;
+let fedInfo;
+async function init(params) {
+  setBuildAdapter(params.adapter);
+  useWorkspace(params.options.workspaceRoot);
+  usePackageJson(params.options.packageJson);
+  params.options.workspaceRoot = getConfigContext().workspaceRoot ?? params.options.workspaceRoot;
+  const normalized = await normalizeFederationOptions(params.options);
+  options = normalized.options;
+  config = normalized.config;
+  externals = getExternals(config);
+}
+async function build(opts = {}) {
+  if (!fedInfo) {
+    fedInfo = await buildForFederation(config, options, externals, opts.signal);
+  } else {
+    fedInfo = await rebuildForFederation(
+      config,
+      options,
+      externals,
+      opts.modifiedFiles ?? [],
+      opts.signal
+    );
+  }
+}
+async function close() {
+  return getBuildAdapter().dispose();
+}
+const federationBuilder = {
+  init,
+  build,
+  close,
+  get federationInfo() {
+    return fedInfo;
+  },
+  get externals() {
+    return externals;
+  },
+  get config() {
+    return config;
+  }
+};
+export {
+  federationBuilder
+};

package/{src → dist}/lib/core/normalize-options.d.ts

@@ -1,6 +1,14 @@
 import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
 import type { FederationOptions, NormalizedFederationOptions } from '../domain/core/federation-options.contract.js';
+import type { FileReaderPort } from '../domain/utils/io-port.contract.js';
 import { type FederationCache } from '../../domain.js';
+import { getUsedDependenciesFactory } from '../config/get-used-dependencies.js';
+type ConfigLoader = (fullConfigPath: string) => Promise<NormalizedFederationConfig>;
+interface NormalizeFederationDeps {
+    io: FileReaderPort;
+    loadConfig: ConfigLoader;
+    usedDependenciesFactory?: typeof getUsedDependenciesFactory;
+}
 export declare function normalizeFederationOptions(options: FederationOptions): Promise<{
     config: NormalizedFederationConfig;
     options: NormalizedFederationOptions<undefined>;
@@ -9,4 +17,8 @@ export declare function normalizeFederationOptions<TBundlerCache>(options: Feder
     config: NormalizedFederationConfig;
     options: NormalizedFederationOptions<TBundlerCache>;
 }>;
-export declare function resolveProjectName(name?: string): string;
+export declare function normalizeFederationOptionsCore<TBundlerCache = undefined>(deps: NormalizeFederationDeps, options: FederationOptions, cache?: FederationCache<TBundlerCache>): Promise<{
+    config: NormalizedFederationConfig;
+    options: NormalizedFederationOptions<TBundlerCache>;
+}>;
+export {};

package/dist/lib/core/normalize-options.js

@@ -0,0 +1,67 @@
+import * as path from "path";
+import { pathToFileURL } from "url";
+import { nodeIo } from "../utils/io/node-io-adapter.js";
+import { removeUnusedDeps } from "../config/remove-unused-deps.js";
+import { createFederationCache } from "./cache/federation-cache.js";
+import { getDefaultCachePath } from "./cache/cache-persistence.js";
+import { getUsedDependenciesFactory } from "../config/get-used-dependencies.js";
+import { logger } from "../utils/logger.js";
+import { normalizePackageName } from "../utils/normalize.js";
+const defaultConfigLoader = async (fullConfigPath) => (await import(pathToFileURL(fullConfigPath).href))?.default;
+async function normalizeFederationOptions(options, cache) {
+  return normalizeFederationOptionsCore(
+    { io: nodeIo, loadConfig: defaultConfigLoader },
+    options,
+    cache
+  );
+}
+async function normalizeFederationOptionsCore(deps, options, cache) {
+  const fullConfigPath = path.join(options.workspaceRoot, options.federationConfig);
+  if (!deps.io.exists(fullConfigPath)) {
+    throw new Error("Expected " + fullConfigPath);
+  }
+  let config = await deps.loadConfig(fullConfigPath);
+  const federationCache = cache ?? createFederationCache(
+    getDefaultCachePath(options.workspaceRoot)
+  );
+  const normalizedOptions = {
+    ...options,
+    entryPoints: options.entryPoints ?? Object.values(config.exposes ?? {}).map((e) => e.file),
+    projectName: resolveProjectName(options.projectName ?? config.name),
+    cacheExternalArtifacts: options.cacheExternalArtifacts ?? true,
+    federationCache
+  };
+  if (config.features.ignoreUnusedDeps) {
+    const getUsedDeps = (deps.usedDependenciesFactory ?? getUsedDependenciesFactory)(
+      options.workspaceRoot,
+      options.entryPoints
+    );
+    config = removeUnusedDeps(getUsedDeps(config), config);
+    logger.info("Removed unused dependencies.");
+    logger.debug(
+      'This can be disabled per dependency/external using the "includeSecondaries: {keepAll: true}" property. Or in general by disabling the "ignoreUnusedDeps" feature. '
+    );
+  } else {
+    const withWildcard = Object.keys(config.sharedMappings).some((m) => m.includes("*"));
+    if (withWildcard) {
+      logger.warn(
+        "Sharing mapped paths with wildcards (*) is only supported with ignoreUnusedDeps feature."
+      );
+      config.sharedMappings = Object.entries(config.sharedMappings).filter(([_path]) => !_path.includes("*")).reduce((acc, [_path, _import]) => ({ ...acc, [_path]: _import }), {});
+    }
+  }
+  return { config, options: normalizedOptions };
+}
+function resolveProjectName(name) {
+  if (!name || name.length < 1) {
+    logger.warn(
+      "Project name in 'federation.config.js' is empty, defaulting to 'shell' cache folder (could collide with other projects in the workspace)."
+    );
+    return "shell";
+  }
+  return normalizePackageName(name);
+}
+export {
+  normalizeFederationOptions,
+  normalizeFederationOptionsCore
+};

package/dist/lib/core/output/write-federation-info.d.ts

@@ -0,0 +1,5 @@
+import type { FederationInfo } from '../../domain/core/federation-info.contract.js';
+import type { FileWriterPort } from '../../domain/utils/io-port.contract.js';
+import type { FederationOptions } from '../../domain/core/federation-options.contract.js';
+export declare function writeFederationInfoCore(io: FileWriterPort, federationInfo: FederationInfo, fedOptions: FederationOptions): void;
+export declare function writeFederationInfo(federationInfo: FederationInfo, fedOptions: FederationOptions): void;

package/dist/lib/core/output/write-federation-info.js

@@ -0,0 +1,17 @@
+import * as path from "path";
+import { nodeIo } from "../../utils/io/node-io-adapter.js";
+function writeFederationInfoCore(io, federationInfo, fedOptions) {
+  const metaDataPath = path.join(
+    fedOptions.workspaceRoot,
+    fedOptions.outputPath,
+    "remoteEntry.json"
+  );
+  io.writeText(metaDataPath, JSON.stringify(federationInfo, null, 2));
+}
+function writeFederationInfo(federationInfo, fedOptions) {
+  writeFederationInfoCore(nodeIo, federationInfo, fedOptions);
+}
+export {
+  writeFederationInfo,
+  writeFederationInfoCore
+};

package/dist/lib/core/output/write-import-map.d.ts

@@ -0,0 +1,11 @@
+import type { ChunkInfo, IntegrityMap, SharedInfo } from '../../domain/core/federation-info.contract.js';
+import type { FileWriterPort } from '../../domain/utils/io-port.contract.js';
+import type { FederationOptions } from '../../domain/core/federation-options.contract.js';
+export declare function writeImportMapCore(io: FileWriterPort, sharedInfo: {
+    externals: SharedInfo[];
+    chunks?: ChunkInfo;
+}, fedOption: FederationOptions, fileIntegrity?: IntegrityMap): void;
+export declare function writeImportMap(sharedInfo: {
+    externals: SharedInfo[];
+    chunks?: ChunkInfo;
+}, fedOption: FederationOptions, fileIntegrity?: IntegrityMap): void;

package/dist/lib/core/output/write-import-map.js

@@ -0,0 +1,42 @@
+import * as path from "path";
+import { toChunkImport } from "../../domain/core/chunk.js";
+import { nodeIo } from "../../utils/io/node-io-adapter.js";
+function writeImportMapCore(io, sharedInfo, fedOption, fileIntegrity) {
+  const imports = sharedInfo.externals.reduce(
+    (acc, cur) => {
+      return {
+        ...acc,
+        [cur.packageName]: cur.outFileName
+      };
+    },
+    {}
+  );
+  if (sharedInfo.chunks) {
+    Object.values(sharedInfo.chunks).forEach((c) => {
+      c.forEach((e) => {
+        const key = toChunkImport(e);
+        imports[key] = e;
+      });
+    });
+  }
+  const importMap = { imports };
+  if (fileIntegrity) {
+    const integrity = {};
+    for (const url of Object.values(imports)) {
+      const sri = fileIntegrity[url];
+      if (sri) integrity[url] = sri;
+    }
+    if (Object.keys(integrity).length > 0) {
+      importMap.integrity = integrity;
+    }
+  }
+  const importMapPath = path.join(fedOption.workspaceRoot, fedOption.outputPath, "importmap.json");
+  io.writeText(importMapPath, JSON.stringify(importMap, null, 2));
+}
+function writeImportMap(sharedInfo, fedOption, fileIntegrity) {
+  writeImportMapCore(nodeIo, sharedInfo, fedOption, fileIntegrity);
+}
+export {
+  writeImportMap,
+  writeImportMapCore
+};

package/dist/lib/core/rebuild-queue.js

@@ -0,0 +1,61 @@
+import { logger } from "../utils/logger.js";
+class RebuildQueue {
+  activeBuilds = /* @__PURE__ */ new Map();
+  buildCounter = 0;
+  async track(rebuildFn, interruptPromise) {
+    const buildId = ++this.buildCounter;
+    const pendingCancellations = Array.from(this.activeBuilds.values()).map((buildControl) => {
+      buildControl.controller.abort();
+      return buildControl.buildFinished.promise;
+    });
+    if (pendingCancellations.length > 0) {
+      logger.info(`Aborting ${pendingCancellations.length} bundling task(s)..`);
+      await Promise.all(pendingCancellations);
+    }
+    let resolveCompletion;
+    const completionPromise = new Promise((resolve) => {
+      resolveCompletion = resolve;
+    });
+    const control = {
+      controller: new AbortController(),
+      buildFinished: {
+        resolve: resolveCompletion,
+        promise: completionPromise
+      }
+    };
+    this.activeBuilds.set(buildId, control);
+    const buildPromise = rebuildFn(control.controller.signal).then((result) => ({ type: "completed", result })).catch((error) => ({ type: "completed", result: { success: false, error } }));
+    let trackResult;
+    try {
+      if (interruptPromise) {
+        const interruptResult = interruptPromise.then((value) => ({
+          type: "interrupted",
+          value
+        }));
+        const raceResult = await Promise.race([buildPromise, interruptResult]);
+        if (raceResult.type === "interrupted") {
+          control.controller.abort();
+          await buildPromise;
+          trackResult = raceResult;
+        } else {
+          trackResult = raceResult;
+        }
+      } else {
+        trackResult = await buildPromise;
+      }
+    } finally {
+      control.buildFinished.resolve();
+      this.activeBuilds.delete(buildId);
+    }
+    return trackResult;
+  }
+  dispose() {
+    for (const buildControl of this.activeBuilds.values()) {
+      buildControl.controller.abort();
+    }
+    this.activeBuilds.clear();
+  }
+}
+export {
+  RebuildQueue
+};

package/{src → dist}/lib/domain/config/external-config.contract.d.ts

@@ -31,13 +31,13 @@ export interface NormalizedExternalConfig {
     };
 }
 export type IncludeSecondariesOptions = {
-    skip: string | string[];
+    skip?: string | string[];
     resolveGlob?: boolean;
     keepAll?: boolean;
 } | boolean;
 export type SharedExternalsConfig = Record<string, ExternalConfig>;
 export type NormalizedSharedExternalsConfig = Record<string, NormalizedExternalConfig>;
-export type ShareAllExternalsOptions = ExternalConfig & {
+export type ShareAllExternalsOptions = Omit<ExternalConfig, 'includeSecondaries'> & {
     includeSecondaries?: IncludeSecondariesOptions;
 };
 export type ShareExternalsOptions = Record<string, ShareAllExternalsOptions>;

package/{src → dist}/lib/domain/config/federation-config.contract.d.ts

@@ -1,9 +1,13 @@
 import type { PreparedSkipList, SkipList } from './skip-list.contract.js';
 import type { PathToImport } from '../utils/mapped-path.contract.js';
 import type { NormalizedSharedExternalsConfig, SharedExternalsConfig } from './external-config.contract.js';
+export type ExposeEntry = {
+    file: string;
+    element?: string;
+};
 export interface FederationConfig {
     name?: string;
-    exposes?: Record<string, string>;
+    exposes?: Record<string, string | ExposeEntry>;
     shared?: SharedExternalsConfig;
     platform?: 'browser' | 'node';
     sharedMappings?: Array<string>;
@@ -21,7 +25,7 @@ export interface FederationConfig {
 export interface NormalizedFederationConfig {
     $type: 'classic';
     name: string;
-    exposes: Record<string, string>;
+    exposes: Record<string, ExposeEntry>;
     shared: NormalizedSharedExternalsConfig;
     sharedMappings: PathToImport;
     skip: PreparedSkipList;

package/dist/lib/domain/core/build-notification-options.contract.js

@@ -0,0 +1,9 @@
+var BuildNotificationType = /* @__PURE__ */ ((BuildNotificationType2) => {
+  BuildNotificationType2["COMPLETED"] = "federation-rebuild-complete";
+  BuildNotificationType2["ERROR"] = "federation-rebuild-error";
+  BuildNotificationType2["CANCELLED"] = "federation-rebuild-cancelled";
+  return BuildNotificationType2;
+})(BuildNotificationType || {});
+export {
+  BuildNotificationType
+};

package/dist/lib/domain/core/chunk.js

@@ -0,0 +1,12 @@
+const CHUNK_PREFIX = "@nf-internal";
+function toChunkImport(fileName) {
+  if (fileName.startsWith("./")) {
+    fileName = fileName.slice(2);
+  }
+  const packageName = fileName.replace(/.(m|c)?js$/, "");
+  return CHUNK_PREFIX + "/" + packageName;
+}
+export {
+  CHUNK_PREFIX,
+  toChunkImport
+};

package/{src → dist}/lib/domain/core/federation-info.contract.d.ts

@@ -24,6 +24,7 @@ export type IntegrityMap = Record<string, string>;
 export interface ExposesInfo {
     key: string;
     outFileName: string;
+    element?: string;
     dev?: {
         entryPoint: string;
     };

package/{src → dist}/lib/domain/core/index.d.ts

@@ -4,3 +4,4 @@ export type { FederationOptions, NormalizedFederationOptions, } from './federati
 export type { EntryPoint, NFBuildAdapterOptions, NFBuildAdapter, NFBuildAdapterResult, NFBuildAdapterContext, } from './build-adapter.contract.js';
 export { CHUNK_PREFIX, toChunkImport } from './chunk.js';
 export type { FederationCache } from './federation-cache.contract.js';
+export type { FederationManifest } from './manifest.contract.js';

package/dist/lib/domain/core/index.js

@@ -0,0 +1,9 @@
+import {
+  BuildNotificationType
+} from "./build-notification-options.contract.js";
+import { CHUNK_PREFIX, toChunkImport } from "./chunk.js";
+export {
+  BuildNotificationType,
+  CHUNK_PREFIX,
+  toChunkImport
+};

package/dist/lib/domain/core/manifest.contract.d.ts

@@ -0,0 +1,5 @@
+export type FederationManifest = Record<string, string | {
+    url: string;
+    integrity?: string;
+    main?: string;
+}>;

package/dist/lib/domain/utils/io-port.contract.d.ts

@@ -0,0 +1,45 @@
+export type HashAlgorithm = 'md5' | 'sha256' | 'sha384' | 'sha512';
+export interface Digest {
+    hex(): string;
+    base64(): string;
+}
+export interface FileReaderPort {
+    readText(path: string): string;
+    readBytes(path: string): Uint8Array;
+    exists(path: string): boolean;
+    /** False on ENOENT, never throws. */
+    isFile(path: string): boolean;
+    /** False on ENOENT, never throws. */
+    isDirectory(path: string): boolean;
+    /** Immediate child entry names (not full paths). Empty array on ENOENT, never throws. */
+    readDir(path: string): string[];
+}
+export interface FileWriterPort {
+    writeText(path: string, data: string): void;
+    mkdirp(path: string): void;
+    copyFile(from: string, to: string): void;
+    remove(path: string): void;
+}
+export interface GlobPort {
+    globFiles(pattern: string, opts: {
+        cwd: string;
+    }): string[];
+}
+export interface HashPort {
+    hash(algorithm: HashAlgorithm, data: Uint8Array | string): Digest;
+}
+export interface WatchHandle {
+    close(): void;
+}
+export interface WatchPort {
+    /**
+     * For a recursive directory watch `onEvent` receives the changed entry's
+     * filename relative to `path`; for a file it receives the path itself (or
+     * null when the platform omits it).
+     */
+    watch(path: string, opts: {
+        recursive: boolean;
+    }, onEvent: (filename: string | null) => void): WatchHandle;
+}
+export interface IoPort extends FileReaderPort, FileWriterPort, GlobPort, HashPort, WatchPort {
+}