@eventcatalog/core 4.6.1 → 4.6.3

package/dist/federation/federate.d.ts

@@ -0,0 +1,81 @@
+import { ResolvedGraph, HydrateResult, Conflict } from '@eventcatalog/sdk';
+import { FederationSourceConfig } from '../eventcatalog.config.js';
+import { PublicAssetCompositionResult } from './public-assets.js';
+import { FederationSourceProvider } from './types.js';
+
+type FederationProgressEvent = {
+    type: 'configured';
+    sources: number;
+} | {
+    type: 'cleanup:complete';
+    federated: boolean;
+    publicFiles: number;
+    lock: boolean;
+} | {
+    type: 'cache:disabled';
+} | {
+    type: 'source:start';
+    source: FederationSourceConfig;
+    current: number;
+    total: number;
+} | {
+    type: 'source:complete';
+    source: FederationSourceConfig;
+    current: number;
+    total: number;
+    commit: string;
+    resources: number;
+    generated: boolean;
+} | {
+    type: 'local:start';
+} | {
+    type: 'local:complete';
+    resources: number;
+} | {
+    type: 'resolving';
+    resources: number;
+    localResources: number;
+} | {
+    type: 'resolved';
+    graph: ResolvedGraph;
+} | {
+    type: 'hydrating';
+    outDir: string;
+} | {
+    type: 'hydrate:cache';
+    files: number;
+} | {
+    type: 'hydrate:file';
+    files: number;
+    source: string;
+    path: string;
+} | {
+    type: 'public:complete';
+    result: PublicAssetCompositionResult;
+} | {
+    type: 'complete';
+    result: FederateCatalogResult;
+};
+type FederateCatalogResult = {
+    sources: number;
+    resources: number;
+    graph: ResolvedGraph;
+    hydrate: HydrateResult;
+    public: PublicAssetCompositionResult;
+    outDir: string;
+    lockPath: string;
+};
+type FederateCatalogOptions = {
+    provider?: FederationSourceProvider;
+    onProgress?: (event: FederationProgressEvent) => void;
+    now?: () => Date;
+    useCache?: boolean;
+    isFederationEnabled?: () => Promise<boolean>;
+};
+declare class FederationConflictError extends Error {
+    conflicts: Conflict[];
+    constructor(conflicts: Conflict[]);
+}
+declare const federateCatalog: (projectDirectory: string, options?: FederateCatalogOptions) => Promise<FederateCatalogResult | null>;
+
+export { type FederateCatalogResult, FederationConflictError, type FederationProgressEvent, federateCatalog };

package/dist/federation/federate.js

@@ -0,0 +1,12 @@
+import {
+  FederationConflictError,
+  federateCatalog
+} from "../chunk-ZR6AH5Z2.js";
+import "../chunk-R7Z5ALYI.js";
+import "../chunk-352FGP6W.js";
+import "../chunk-5EPNFDT5.js";
+import "../chunk-6QENHZZP.js";
+export {
+  FederationConflictError,
+  federateCatalog
+};

package/dist/federation/github-source-provider.cjs

@@ -0,0 +1,157 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/federation/github-source-provider.ts
+var github_source_provider_exports = {};
+__export(github_source_provider_exports, {
+  createGitHubSourceProvider: () => createGitHubSourceProvider
+});
+module.exports = __toCommonJS(github_source_provider_exports);
+var import_node_child_process = require("child_process");
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_os = __toESM(require("os"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var import_node_util = require("util");
+var import_sdk = __toESM(require("@eventcatalog/sdk"), 1);
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var parseGitHubSource = (source) => {
+  const match = /^github:([^/]+)\/(.+)$/.exec(source.source);
+  if (!match) throw new Error(`Unsupported federation source "${source.source}". Expected github:owner/repository.`);
+  return { owner: match[1], repository: match[2] };
+};
+var assertSafeCatalogPath = (source) => {
+  const catalogPath = source.path ?? ".";
+  const normalized = import_node_path.default.posix.normalize(catalogPath.replaceAll("\\", "/"));
+  if (catalogPath.includes("\\") || import_node_path.default.posix.isAbsolute(normalized) || normalized === ".." || normalized.startsWith("../")) {
+    throw new Error(`Catalog path "${catalogPath}" escapes source "${source.id}"`);
+  }
+};
+var encodePath = (value) => value.split("/").filter(Boolean).map(encodeURIComponent).join("/");
+var rawUrl = (source, ref, filePath) => {
+  const { owner, repository } = parseGitHubSource(source);
+  return `https://raw.githubusercontent.com/${encodeURIComponent(owner)}/${encodeURIComponent(repository)}/${encodeURIComponent(
+    ref
+  )}/${encodePath(filePath)}`;
+};
+var contentsApiUrl = (source, ref, filePath) => {
+  const { owner, repository } = parseGitHubSource(source);
+  return `https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repository)}/contents/${encodePath(
+    filePath
+  )}?ref=${encodeURIComponent(ref)}`;
+};
+var fetchBytes = async (source, ref, filePath, fetcher, token) => {
+  const url = token ? contentsApiUrl(source, ref, filePath) : rawUrl(source, ref, filePath);
+  const response = token ? await fetcher(url, {
+    headers: {
+      Accept: "application/vnd.github.raw+json",
+      Authorization: `Bearer ${token}`,
+      "X-GitHub-Api-Version": "2026-03-10"
+    }
+  }) : await fetcher(url);
+  if (response.status === 404) return void 0;
+  if (!response.ok) throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+  return Buffer.from(await response.arrayBuffer());
+};
+var getGitEnvironment = (token) => {
+  if (!token) return process.env;
+  const inheritedCount = Number.parseInt(process.env.GIT_CONFIG_COUNT ?? "0", 10);
+  const configIndex = Number.isInteger(inheritedCount) && inheritedCount >= 0 ? inheritedCount : 0;
+  return {
+    ...process.env,
+    GIT_CONFIG_COUNT: String(configIndex + 1),
+    [`GIT_CONFIG_KEY_${configIndex}`]: "http.https://github.com/.extraheader",
+    [`GIT_CONFIG_VALUE_${configIndex}`]: `AUTHORIZATION: basic ${Buffer.from(`x-access-token:${token}`).toString("base64")}`
+  };
+};
+var createCheckout = (executeFile, token) => async (source, ref, callback) => {
+  const { owner, repository } = parseGitHubSource(source);
+  const catalogPath = import_node_path.default.posix.normalize(source.path ?? ".");
+  const directory = await import_promises.default.mkdtemp(import_node_path.default.join(import_node_os.default.tmpdir(), "eventcatalog-federation-"));
+  const env = getGitEnvironment(token);
+  try {
+    const git = (args) => executeFile("git", args, { cwd: directory, env, encoding: "utf8" });
+    await git(["init", "--quiet"]);
+    await git(["remote", "add", "origin", `https://github.com/${owner}/${repository}.git`]);
+    if (catalogPath !== ".") {
+      await git(["sparse-checkout", "init", "--cone"]);
+      await git(["sparse-checkout", "set", catalogPath]);
+    }
+    await git(["fetch", "--quiet", "--depth", "1", "origin", ref]);
+    await git(["checkout", "--quiet", "--detach", "FETCH_HEAD"]);
+    return await callback(directory);
+  } finally {
+    await import_promises.default.rm(directory, { recursive: true, force: true });
+  }
+};
+var generateIndex = async (source, ref, checkout, executeFile) => checkout(source, ref, async (directory) => {
+  const { stdout } = await executeFile("git", ["rev-parse", "HEAD"], { cwd: directory, encoding: "utf8" });
+  const commit = stdout.trim();
+  const catalogDirectory = import_node_path.default.resolve(directory, source.path ?? ".");
+  const relativeCatalogDirectory = import_node_path.default.relative(directory, catalogDirectory);
+  if (relativeCatalogDirectory.startsWith("..") || import_node_path.default.isAbsolute(relativeCatalogDirectory)) {
+    throw new Error(`Catalog path "${source.path}" escapes source "${source.id}"`);
+  }
+  const index = await (0, import_sdk.default)(catalogDirectory).buildIndex({ source: source.id, commit });
+  return { bytes: Buffer.from(JSON.stringify(index)), index, commit, generated: true };
+});
+var fetchPublishedIndex = async (source, ref, fetcher, token) => {
+  const indexPath = import_node_path.default.posix.join(source.path ?? ".", "catalog.index.json");
+  const bytes = await fetchBytes(source, ref, indexPath, fetcher, token);
+  if (!bytes) return void 0;
+  const index = (0, import_sdk.parseIndex)(JSON.parse(bytes.toString("utf8")));
+  if (index.source !== source.id) {
+    throw new Error(`Published index source "${index.source}" does not match configured id "${source.id}"`);
+  }
+  return { bytes, index, commit: index.commit, generated: false };
+};
+var createGitHubSourceProvider = (options = {}) => {
+  const fetcher = options.fetch ?? ((url, init) => fetch(url, init));
+  const executeFile = options.execFile ?? ((file, args, execOptions) => execFileAsync(file, args, execOptions));
+  const configuredToken = options.token ?? process.env.EVENTCATALOG_GITHUB_TOKEN ?? process.env.GITHUB_TOKEN;
+  const token = configuredToken?.trim() || void 0;
+  const checkout = options.checkout ?? createCheckout(executeFile, token);
+  return {
+    async resolve(source) {
+      assertSafeCatalogPath(source);
+      const ref = source.ref ?? "main";
+      return await fetchPublishedIndex(source, ref, fetcher, token) ?? generateIndex(source, ref, checkout, executeFile);
+    },
+    async fetchContent({ source, commit, path: artifactPath }) {
+      assertSafeCatalogPath(source);
+      const catalogPath = import_node_path.default.posix.join(source.path ?? ".", artifactPath);
+      const content = await fetchBytes(source, commit, catalogPath, fetcher, token);
+      if (!content) throw new Error(`Federated artifact not found for "${source.id}": ${artifactPath}`);
+      return content;
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createGitHubSourceProvider
+});

package/dist/federation/github-source-provider.d.cts

@@ -0,0 +1,24 @@
+import { FederationSourceConfig } from '../eventcatalog.config.cjs';
+import { FederationSourceProvider } from './types.cjs';
+import '@eventcatalog/sdk';
+
+type FetchResponse = Pick<Response, 'status' | 'statusText' | 'ok' | 'arrayBuffer'>;
+type FetchFunction = (url: string, init?: RequestInit) => Promise<FetchResponse>;
+type ExecFileFunction = (file: string, args: string[], options: {
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+    encoding: 'utf8';
+}) => Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+type CheckoutFunction = <T>(source: FederationSourceConfig, ref: string, callback: (directory: string) => Promise<T>) => Promise<T>;
+type GitHubSourceProviderOptions = {
+    fetch?: FetchFunction;
+    checkout?: CheckoutFunction;
+    execFile?: ExecFileFunction;
+    token?: string;
+};
+declare const createGitHubSourceProvider: (options?: GitHubSourceProviderOptions) => FederationSourceProvider;
+
+export { type GitHubSourceProviderOptions, createGitHubSourceProvider };

package/dist/federation/github-source-provider.d.ts

@@ -0,0 +1,24 @@
+import { FederationSourceConfig } from '../eventcatalog.config.js';
+import { FederationSourceProvider } from './types.js';
+import '@eventcatalog/sdk';
+
+type FetchResponse = Pick<Response, 'status' | 'statusText' | 'ok' | 'arrayBuffer'>;
+type FetchFunction = (url: string, init?: RequestInit) => Promise<FetchResponse>;
+type ExecFileFunction = (file: string, args: string[], options: {
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+    encoding: 'utf8';
+}) => Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+type CheckoutFunction = <T>(source: FederationSourceConfig, ref: string, callback: (directory: string) => Promise<T>) => Promise<T>;
+type GitHubSourceProviderOptions = {
+    fetch?: FetchFunction;
+    checkout?: CheckoutFunction;
+    execFile?: ExecFileFunction;
+    token?: string;
+};
+declare const createGitHubSourceProvider: (options?: GitHubSourceProviderOptions) => FederationSourceProvider;
+
+export { type GitHubSourceProviderOptions, createGitHubSourceProvider };

package/dist/federation/github-source-provider.js

@@ -0,0 +1,6 @@
+import {
+  createGitHubSourceProvider
+} from "../chunk-352FGP6W.js";
+export {
+  createGitHubSourceProvider
+};

package/dist/federation/public-assets.cjs

@@ -0,0 +1,167 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/federation/public-assets.ts
+var public_assets_exports = {};
+__export(public_assets_exports, {
+  composePublicAssets: () => composePublicAssets
+});
+module.exports = __toCommonJS(public_assets_exports);
+var import_node_crypto = require("crypto");
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var getContentHash = (content) => `sha256:${(0, import_node_crypto.createHash)("sha256").update(content).digest("hex")}`;
+var getFileHash = async (filePath) => {
+  try {
+    const stat = await import_promises.default.lstat(filePath);
+    return stat.isFile() ? getContentHash(await import_promises.default.readFile(filePath)) : void 0;
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+};
+var getSafePath = (directory, relativePath) => {
+  const normalizedPath = import_node_path.default.posix.normalize(relativePath);
+  const unsafe = relativePath.length === 0 || relativePath.includes("\0") || relativePath.includes("\\") || import_node_path.default.posix.isAbsolute(relativePath) || /^[a-zA-Z]:\//.test(relativePath) || normalizedPath !== relativePath || normalizedPath === ".." || normalizedPath.startsWith("../");
+  if (unsafe) return void 0;
+  const resolvedDirectory = import_node_path.default.resolve(directory);
+  const resolvedPath = import_node_path.default.resolve(resolvedDirectory, relativePath);
+  const relativeResolvedPath = import_node_path.default.relative(resolvedDirectory, resolvedPath);
+  if (relativeResolvedPath === "" || relativeResolvedPath === ".." || relativeResolvedPath.startsWith(`..${import_node_path.default.sep}`) || import_node_path.default.isAbsolute(relativeResolvedPath)) {
+    return void 0;
+  }
+  return resolvedPath;
+};
+var listFiles = async (directory, relativeDirectory = "") => {
+  let entries;
+  try {
+    entries = await import_promises.default.readdir(import_node_path.default.join(directory, relativeDirectory), { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  const files = await Promise.all(
+    entries.map(async (entry) => {
+      const relativePath = import_node_path.default.join(relativeDirectory, entry.name);
+      if (entry.isDirectory()) return listFiles(directory, relativePath);
+      return entry.isFile() ? [relativePath.split(import_node_path.default.sep).join("/")] : [];
+    })
+  );
+  return files.flat().sort();
+};
+var pathExists = async (filePath) => {
+  try {
+    await import_promises.default.lstat(filePath);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+};
+var hasBlockingParent = async (publicDirectory, destinationPath) => {
+  let currentPath = import_node_path.default.dirname(destinationPath);
+  while (currentPath !== publicDirectory) {
+    try {
+      if (!(await import_promises.default.lstat(currentPath)).isDirectory()) return true;
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    currentPath = import_node_path.default.dirname(currentPath);
+  }
+  return false;
+};
+var pruneEmptyDirectories = async (publicDirectory, filePath) => {
+  let currentPath = import_node_path.default.dirname(filePath);
+  while (currentPath !== publicDirectory) {
+    try {
+      await import_promises.default.rmdir(currentPath);
+    } catch (error) {
+      if (!["ENOENT", "ENOTEMPTY"].includes(error.code ?? "")) throw error;
+      if (error.code === "ENOTEMPTY") return;
+    }
+    currentPath = import_node_path.default.dirname(currentPath);
+  }
+};
+var composePublicAssets = async ({
+  projectDirectory,
+  federatedDirectory,
+  assets,
+  previousFiles = {},
+  collisionPaths = /* @__PURE__ */ new Set()
+}) => {
+  const publicDirectory = import_node_path.default.resolve(projectDirectory, "public");
+  const federatedPublicDirectory = import_node_path.default.resolve(federatedDirectory, "public");
+  const sourceFiles = await listFiles(federatedPublicDirectory);
+  const sourceFileSet = new Set(sourceFiles);
+  const managedFiles = /* @__PURE__ */ new Set();
+  for (const [relativePath, previousFile] of Object.entries(previousFiles)) {
+    const destinationPath = getSafePath(publicDirectory, relativePath);
+    if (destinationPath && await getFileHash(destinationPath) === previousFile.hash) managedFiles.add(relativePath);
+  }
+  let removed = 0;
+  for (const relativePath of managedFiles) {
+    if (sourceFileSet.has(relativePath)) continue;
+    const destinationPath = getSafePath(publicDirectory, relativePath);
+    if (!destinationPath) continue;
+    await import_promises.default.rm(destinationPath, { force: true });
+    await pruneEmptyDirectories(publicDirectory, destinationPath);
+    removed += 1;
+  }
+  const publicAssetsByPath = new Map(
+    assets.filter((asset) => asset.path.startsWith("public/")).map((asset) => [asset.path.slice("public/".length), asset])
+  );
+  const files = {};
+  let copied = 0;
+  let skipped = 0;
+  let overwritten = 0;
+  for (const relativePath of sourceFiles) {
+    const sourcePath = getSafePath(federatedPublicDirectory, relativePath);
+    const destinationPath = getSafePath(publicDirectory, relativePath);
+    if (!sourcePath || !destinationPath) throw new Error(`Unsafe federated public asset path "${relativePath}"`);
+    const mainCatalogOwnsPath = await pathExists(destinationPath) && !managedFiles.has(relativePath) || await hasBlockingParent(publicDirectory, destinationPath);
+    if (mainCatalogOwnsPath) {
+      skipped += 1;
+      continue;
+    }
+    const asset = publicAssetsByPath.get(relativePath);
+    if (!asset) throw new Error(`Cannot identify the source of federated public asset "${relativePath}"`);
+    const content = await import_promises.default.readFile(sourcePath);
+    await import_promises.default.mkdir(import_node_path.default.dirname(destinationPath), { recursive: true });
+    await import_promises.default.writeFile(destinationPath, content);
+    files[relativePath] = { source: asset.resolvedFrom.source, hash: getContentHash(content) };
+    copied += 1;
+    if (collisionPaths.has(`public/${relativePath}`)) overwritten += 1;
+  }
+  await import_promises.default.rm(federatedPublicDirectory, { recursive: true, force: true });
+  return { files, copied, skipped, overwritten, removed };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  composePublicAssets
+});

package/dist/federation/public-assets.d.cts

@@ -0,0 +1,24 @@
+import { ResolvedAsset } from '@eventcatalog/sdk';
+
+type FederatedPublicFile = {
+    source: string;
+    hash: string;
+};
+type FederatedPublicFiles = Record<string, FederatedPublicFile>;
+type PublicAssetCompositionResult = {
+    files: FederatedPublicFiles;
+    copied: number;
+    skipped: number;
+    overwritten: number;
+    removed: number;
+};
+type ComposePublicAssetsOptions = {
+    projectDirectory: string;
+    federatedDirectory: string;
+    assets: ResolvedAsset[];
+    previousFiles?: FederatedPublicFiles;
+    collisionPaths?: Set<string>;
+};
+declare const composePublicAssets: ({ projectDirectory, federatedDirectory, assets, previousFiles, collisionPaths, }: ComposePublicAssetsOptions) => Promise<PublicAssetCompositionResult>;
+
+export { type FederatedPublicFile, type FederatedPublicFiles, type PublicAssetCompositionResult, composePublicAssets };

package/dist/federation/public-assets.d.ts

@@ -0,0 +1,24 @@
+import { ResolvedAsset } from '@eventcatalog/sdk';
+
+type FederatedPublicFile = {
+    source: string;
+    hash: string;
+};
+type FederatedPublicFiles = Record<string, FederatedPublicFile>;
+type PublicAssetCompositionResult = {
+    files: FederatedPublicFiles;
+    copied: number;
+    skipped: number;
+    overwritten: number;
+    removed: number;
+};
+type ComposePublicAssetsOptions = {
+    projectDirectory: string;
+    federatedDirectory: string;
+    assets: ResolvedAsset[];
+    previousFiles?: FederatedPublicFiles;
+    collisionPaths?: Set<string>;
+};
+declare const composePublicAssets: ({ projectDirectory, federatedDirectory, assets, previousFiles, collisionPaths, }: ComposePublicAssetsOptions) => Promise<PublicAssetCompositionResult>;
+
+export { type FederatedPublicFile, type FederatedPublicFiles, type PublicAssetCompositionResult, composePublicAssets };

package/dist/federation/public-assets.js

@@ -0,0 +1,6 @@
+import {
+  composePublicAssets
+} from "../chunk-5EPNFDT5.js";
+export {
+  composePublicAssets
+};

package/dist/federation/types.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/federation/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/federation/types.d.cts

@@ -0,0 +1,19 @@
+import { Index } from '@eventcatalog/sdk';
+import { FederationSourceConfig } from '../eventcatalog.config.cjs';
+
+type ResolvedFederationSource = {
+    bytes: Buffer;
+    index: Index;
+    commit: string;
+    generated: boolean;
+};
+type FederationSourceProvider = {
+    resolve(source: FederationSourceConfig): Promise<ResolvedFederationSource>;
+    fetchContent(request: {
+        source: FederationSourceConfig;
+        commit: string;
+        path: string;
+    }): Promise<Buffer>;
+};
+
+export type { FederationSourceProvider, ResolvedFederationSource };

package/dist/federation/types.d.ts

@@ -0,0 +1,19 @@
+import { Index } from '@eventcatalog/sdk';
+import { FederationSourceConfig } from '../eventcatalog.config.js';
+
+type ResolvedFederationSource = {
+    bytes: Buffer;
+    index: Index;
+    commit: string;
+    generated: boolean;
+};
+type FederationSourceProvider = {
+    resolve(source: FederationSourceConfig): Promise<ResolvedFederationSource>;
+    fetchContent(request: {
+        source: FederationSourceConfig;
+        commit: string;
+        path: string;
+    }): Promise<Buffer>;
+};
+
+export type { FederationSourceProvider, ResolvedFederationSource };

package/dist/generate.cjs

@@ -108,7 +108,7 @@ var getEventCatalogConfigFile = async (projectDirectory) => {
 var import_picocolors = __toESM(require("picocolors"), 1);
 
 // package.json
-var version = "4.6.1";
+var version = "4.6.3";
 
 // src/constants.ts
 var VERSION = version;

package/dist/generate.js

@@ -1,8 +1,8 @@
 import {
   generate
-} from "./chunk-N3YKQTGX.js";
-import "./chunk-MTXVQ4VP.js";
-import "./chunk-X7XI7NEP.js";
+} from "./chunk-4BBXOL6K.js";
+import "./chunk-FZJDCQZE.js";
+import "./chunk-LB5VXS6X.js";
 import "./chunk-6QENHZZP.js";
 export {
   generate

package/dist/utils/cli-logger.cjs

@@ -36,7 +36,7 @@ module.exports = __toCommonJS(cli_logger_exports);
 var import_picocolors = __toESM(require("picocolors"), 1);
 
 // package.json
-var version = "4.6.1";
+var version = "4.6.3";
 
 // src/constants.ts
 var VERSION = version;

package/dist/utils/cli-logger.js

@@ -1,7 +1,7 @@
 import {
   logger
-} from "../chunk-MTXVQ4VP.js";
-import "../chunk-X7XI7NEP.js";
+} from "../chunk-FZJDCQZE.js";
+import "../chunk-LB5VXS6X.js";
 export {
   logger
 };