@eventcatalog/core 2.14.2 → 2.15.0

package/{scripts/watcher.js → dist/chunk-7HYM3M5I.js}

@@ -1,24 +1,15 @@
-import watcher from '@parcel/watcher';
-import fs from 'node:fs';
-import { mapCatalogToAstro } from './map-catalog-to-astro.js';
-import { rimrafSync } from 'rimraf';
-import { addPropertyToFrontMatter } from './eventcatalog-config-file-utils.js';
+import {
+  addPropertyToFrontMatter
+} from "./chunk-E7TXTI7G.js";
+import {
+  mapCatalogToAstro
+} from "./chunk-PK2EQVPD.js";
 
-/**
- * @typedef {Object} Event
- * @property {string} path
- * @property {"create"|"update"|"delete"} type
- *
- * @typedef {(err: Error | null, events: Event[]) => unknown} SubscribeCallback
- */
-
-/**
- *
- * @param {string} projectDirectory
- * @param {string} catalogDirectory
- * @param {SubscribeCallback|undefined} callback
- */
-export async function watch(projectDirectory, catalogDirectory, callback = undefined) {
+// src/watcher.js
+import watcher from "@parcel/watcher";
+import fs from "node:fs";
+import { rimrafSync } from "rimraf";
+async function watch(projectDirectory, catalogDirectory, callback = void 0) {
   const subscription = await watcher.subscribe(
     projectDirectory,
     compose(
@@ -31,36 +22,29 @@ export async function watch(projectDirectory, catalogDirectory, callback = undef
         if (err) {
           return;
         }
-
         for (let event of events) {
           const { path: filePath, type } = event;
-
           const astroPaths = mapCatalogToAstro({
             filePath,
             astroDir: catalogDirectory,
-            projectDir: projectDirectory,
+            projectDir: projectDirectory
           });
-
           for (const astroPath of astroPaths) {
             switch (type) {
-              case 'create':
-              case 'update':
+              case "create":
+              case "update":
                 try {
-                  // EventCatalog requires the original path to be in the frontmatter for Schemas and Changelogs
-                  if (astroPath.endsWith('.mdx')) {
-                    const content = fs.readFileSync(astroPath, 'utf-8');
-                    const frontmatter = addPropertyToFrontMatter(content, 'pathToFile', filePath);
+                  if (astroPath.endsWith(".mdx")) {
+                    const content = fs.readFileSync(astroPath, "utf-8");
+                    const frontmatter = addPropertyToFrontMatter(content, "pathToFile", filePath);
                     fs.writeFileSync(astroPath, frontmatter);
                   }
                 } catch (error) {
-                  // silent fail
                 }
-
                 if (fs.statSync(filePath).isDirectory()) fs.mkdirSync(astroPath, { recursive: true });
                 else retryEPERM(fs.cpSync)(filePath, astroPath);
-
                 break;
-              case 'delete':
+              case "delete":
                 retryEPERM(rimrafSync)(astroPath);
                 break;
             }
@@ -70,20 +54,13 @@ export async function watch(projectDirectory, catalogDirectory, callback = undef
       callback
     ),
     {
-      ignore: [`**/${catalogDirectory}/!(${projectDirectory})**`],
+      ignore: [`**/${catalogDirectory}/!(${projectDirectory})**`]
     }
   );
-
   return () => subscription.unsubscribe();
 }
-
-/**
- *
- * @param  {...Function} fns
- * @returns {SubscribeCallback}
- */
 function compose(...fns) {
-  return function (err, events) {
+  return function(err, events) {
     fns.filter(Boolean).forEach((fn, i) => {
       try {
         fn(err, events);
@@ -94,24 +71,24 @@ function compose(...fns) {
     });
   };
 }
-
-const MAX_RETRIES = 5;
-const DELAY_MS = 100;
-
-// In win32 some tests failed when attempting copy the file at the same time
-// that another process is editing it.
+var MAX_RETRIES = 5;
+var DELAY_MS = 100;
 function retryEPERM(fn) {
   return (...args) => {
     let retries = 0;
-
     while (retries < MAX_RETRIES) {
       try {
         return fn(...args);
       } catch (err) {
-        if (err.code !== 'EPERM') throw err;
-        setTimeout(() => {}, DELAY_MS);
+        if (err.code !== "EPERM") throw err;
+        setTimeout(() => {
+        }, DELAY_MS);
         retries += 1;
       }
     }
   };
 }
+
+export {
+  watch
+};

package/dist/chunk-E7TXTI7G.js

@@ -0,0 +1,78 @@
+// src/eventcatalog-config-file-utils.js
+import { readFile, writeFile, rm } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { copyFile } from "node:fs/promises";
+import path from "node:path";
+import { v4 as uuidV4 } from "uuid";
+import { pathToFileURL } from "url";
+import matter from "gray-matter";
+async function cleanup(projectDirectory) {
+  const filePath = path.join(projectDirectory, "eventcatalog.config.mjs");
+  if (existsSync(filePath)) {
+    await rm(filePath);
+  }
+}
+var getEventCatalogConfigFile = async (projectDirectory) => {
+  try {
+    let configFilePath = path.join(projectDirectory, "eventcatalog.config.js");
+    const filePath = path.join(projectDirectory, "package.json");
+    const packageJson = JSON.parse(await readFile(filePath, "utf-8"));
+    if (packageJson?.type !== "module") {
+      await copyFile(configFilePath, path.join(projectDirectory, "eventcatalog.config.mjs"));
+      configFilePath = path.join(projectDirectory, "eventcatalog.config.mjs");
+    }
+    const configFileURL = pathToFileURL(configFilePath).href;
+    const config = await import(
+      /* @vite-ignore */
+      configFileURL
+    );
+    return config.default;
+  } finally {
+    await cleanup(projectDirectory);
+  }
+};
+var writeEventCatalogConfigFile = async (projectDirectory, newConfig) => {
+  try {
+    const configFilePath = path.join(projectDirectory, "eventcatalog.config.js");
+    let content = await readFile(configFilePath, "utf8");
+    const startIndex = content.indexOf("export default {");
+    if (startIndex === -1) {
+      return;
+    }
+    Object.entries(newConfig).forEach(([key, value]) => {
+      const valueString = JSON.stringify(value, null, 2).replace(/"/g, "'").replace(/\n/g, "\n  ");
+      const keyRegex = new RegExp(`(${key}\\s*:)([^,}]+)`, "g");
+      if (content.match(keyRegex)) {
+        content = content.replace(keyRegex, `$1 ${valueString}`);
+      } else {
+        const insertPosition = content.indexOf("{", startIndex) + 1;
+        content = content.slice(0, insertPosition) + `
+  ${key}: ${valueString},` + content.slice(insertPosition);
+      }
+    });
+    await writeFile(configFilePath, content);
+  } finally {
+    await cleanup(projectDirectory);
+  }
+};
+var verifyRequiredFieldsAreInCatalogConfigFile = async (projectDirectory) => {
+  try {
+    const config = await getEventCatalogConfigFile(projectDirectory);
+    if (!config.cId) {
+      await writeEventCatalogConfigFile(projectDirectory, { cId: uuidV4() });
+    }
+  } catch (error) {
+  }
+};
+function addPropertyToFrontMatter(input, newProperty, newValue) {
+  const file = matter(input);
+  return matter.stringify(file.content, { ...file.data, [newProperty]: newValue });
+}
+
+export {
+  cleanup,
+  getEventCatalogConfigFile,
+  writeEventCatalogConfigFile,
+  verifyRequiredFieldsAreInCatalogConfigFile,
+  addPropertyToFrontMatter
+};

package/dist/chunk-KI4KAUWW.js

@@ -0,0 +1,30 @@
+import {
+  raiseEvent
+} from "./chunk-65VQIGAP.js";
+import {
+  getEventCatalogConfigFile,
+  verifyRequiredFieldsAreInCatalogConfigFile
+} from "./chunk-E7TXTI7G.js";
+
+// src/analytics/log-build.js
+var main = async (projectDir) => {
+  if (process.env.NODE_ENV === "CI") return;
+  try {
+    await verifyRequiredFieldsAreInCatalogConfigFile(projectDir);
+    const configFile = await getEventCatalogConfigFile(projectDir);
+    const { cId, organizationName, generators = [] } = configFile;
+    const generatorNames = generators.length > 0 ? generators.map((generator) => generator[0]) : ["none"];
+    await raiseEvent({
+      command: "build",
+      org: organizationName,
+      cId,
+      generators: generatorNames.toString()
+    });
+  } catch (error) {
+  }
+};
+var log_build_default = main;
+
+export {
+  log_build_default
+};

package/dist/chunk-O6BGVVOW.js

@@ -0,0 +1,86 @@
+import {
+  addPropertyToFrontMatter,
+  verifyRequiredFieldsAreInCatalogConfigFile
+} from "./chunk-E7TXTI7G.js";
+import {
+  mapCatalogToAstro
+} from "./chunk-PK2EQVPD.js";
+
+// src/catalog-to-astro-content-directory.js
+import { glob } from "glob";
+import * as path from "node:path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+import os from "node:os";
+var __filename = fileURLToPath(import.meta.url);
+var rootPkg = path.resolve(path.dirname(__filename), "../");
+var copyFiles = async (source, target) => {
+  const files = await glob(path.join(source, "**"), {
+    nodir: true,
+    windowsPathsNoEscape: os.platform() == "win32"
+  });
+  for (const file of files) {
+    mapCatalogToAstro({
+      filePath: file,
+      astroDir: target,
+      projectDir: source
+    }).map((astroPath) => {
+      fs.cpSync(file, astroPath);
+      return { oldPath: file, newPath: astroPath };
+    }).map(({ oldPath, newPath }) => {
+      if (!oldPath.endsWith(".md") && !oldPath.endsWith(".mdx")) return;
+      try {
+        const content = fs.readFileSync(newPath, "utf-8");
+        const frontmatter = addPropertyToFrontMatter(content, "pathToFile", oldPath);
+        fs.writeFileSync(newPath, frontmatter);
+      } catch (error) {
+      }
+    });
+  }
+};
+var ensureAstroCollectionNotEmpty = async (astroDir) => {
+  const COLLECTIONS = [
+    "events",
+    "commands",
+    "services",
+    "users",
+    "teams",
+    "domains",
+    "flows",
+    "pages",
+    "changelogs",
+    "queries",
+    "channels"
+  ];
+  const emptyCollections = [];
+  for (const collection of COLLECTIONS) {
+    const markdownFiles = await glob(path.join(astroDir, "src/content/", collection, "**"), {
+      nodir: true,
+      windowsPathsNoEscape: os.platform() == "win32"
+    });
+    if (markdownFiles.length === 0) emptyCollections.push(collection);
+  }
+  const defaultCollectionFilesDir = path.join(rootPkg, "default-files-for-collections");
+  for (const collection of emptyCollections) {
+    const defaultFile = path.join(defaultCollectionFilesDir, `${collection}.md`);
+    const targetDir = path.join(astroDir, "src/content/", collection);
+    if (!fs.existsSync(targetDir)) {
+      fs.mkdirSync(targetDir, { recursive: true });
+    }
+    fs.cpSync(defaultFile, path.join(targetDir, `${collection}.md`));
+  }
+};
+var catalogToAstro = async (source, astroDir) => {
+  const astroContentDir = path.join(astroDir, "src/content/");
+  const astroConfigFile = fs.readFileSync(path.join(astroContentDir, "config.ts"));
+  fs.rmSync(astroContentDir, { recursive: true });
+  fs.mkdirSync(astroContentDir);
+  fs.writeFileSync(path.join(astroContentDir, "config.ts"), astroConfigFile);
+  await verifyRequiredFieldsAreInCatalogConfigFile(source);
+  await copyFiles(source, astroDir);
+  await ensureAstroCollectionNotEmpty(astroDir);
+};
+
+export {
+  catalogToAstro
+};

package/dist/chunk-PK2EQVPD.js

@@ -0,0 +1,89 @@
+// src/map-catalog-to-astro.js
+import path from "node:path";
+var COLLECTION_KEYS = [
+  "events",
+  "commands",
+  "services",
+  "users",
+  "teams",
+  "domains",
+  "flows",
+  "pages",
+  "changelogs",
+  "queries",
+  "channels"
+];
+function mapCatalogToAstro({ filePath, astroDir, projectDir }) {
+  const relativeFilePath = removeBasePath(filePath, projectDir);
+  if (!isCatalogRelated(relativeFilePath)) {
+    return [];
+  }
+  const baseTargetPaths = getBaseTargetPaths(relativeFilePath);
+  const relativeTargetPath = getRelativeTargetPath(relativeFilePath);
+  return baseTargetPaths.map(
+    (base) => path.join(astroDir, base, relativeTargetPath.replace("index.md", "index.mdx").replace("changelog.md", "changelog.mdx"))
+  );
+}
+function removeBasePath(fullPath, basePath) {
+  const relativePath = path.relative(basePath, fullPath);
+  return relativePath.startsWith("..") ? fullPath : relativePath;
+}
+function isCollectionKey(key) {
+  return COLLECTION_KEYS.includes(key);
+}
+function isCatalogRelated(filePath) {
+  const filePathArr = filePath.split(path.sep).filter(Boolean);
+  if ([
+    "eventcatalog.config.js",
+    // config file at root
+    "eventcatalog.styles.css",
+    // custom styles file at root
+    "components",
+    // custom components
+    "public",
+    // public assets
+    ...COLLECTION_KEYS
+  ].includes(filePathArr[0])) {
+    return true;
+  }
+  return false;
+}
+function getBaseTargetPaths(filePath) {
+  const filePathArr = filePath.split(path.sep).filter(Boolean);
+  if (isCollectionKey(filePathArr[0])) {
+    if (filePathArr[filePathArr.length - 1] == "changelog.md") {
+      return [path.join("src", "content", "changelogs")];
+    }
+    if (filePathArr[filePathArr.length - 1].match(/\.md$/)) {
+      return [path.join("src", "content")];
+    }
+    const hasExtension = (str) => /\.[a-zA-Z0-9]{2,}$/.test(str);
+    if (hasExtension(filePath)) {
+      return [path.join("public", "generated"), path.join("src", "catalog-files")];
+    }
+    return [path.join("public", "generated"), path.join("src", "catalog-files"), path.join("src", "content")];
+  }
+  if (filePathArr[0] == "components") {
+    return [path.join("src", "custom-defined-components")];
+  }
+  if (filePathArr[0] == "public") {
+    return [path.join("public")];
+  }
+  return [path.join("/")];
+}
+function getRelativeTargetPath(filePath) {
+  const filePathArr = filePath.split(path.sep).filter(Boolean);
+  if (filePathArr[0] == "public" || filePathArr[0] == "components") {
+    filePathArr.shift();
+  }
+  const relativePath = [];
+  for (let i = filePathArr.length - 1; i >= 0; i--) {
+    relativePath.unshift(filePathArr[i]);
+    if (isCollectionKey(filePathArr[i])) break;
+  }
+  return path.join(...relativePath);
+}
+
+export {
+  mapCatalogToAstro
+};

package/dist/chunk-TGOUSS6C.js

@@ -0,0 +1,9 @@
+// package.json
+var version = "2.15.0";
+
+// src/constants.ts
+var VERSION = version;
+
+export {
+  VERSION
+};

package/dist/chunk-YEQVKHST.js

@@ -0,0 +1,56 @@
+import {
+  cleanup,
+  getEventCatalogConfigFile
+} from "./chunk-E7TXTI7G.js";
+
+// src/generate.js
+import path from "node:path";
+function getDefaultExport(importedModule) {
+  if (importedModule === null || typeof importedModule !== "object") {
+    throw new Error("Invalid module");
+  }
+  if (typeof importedModule.default === "object" && importedModule.default !== null) {
+    return importedModule.default.default || importedModule.default;
+  }
+  if (typeof importedModule.default !== "undefined") {
+    return importedModule.default;
+  }
+  return importedModule;
+}
+var generate = async (PROJECT_DIRECTORY) => {
+  try {
+    const config = await getEventCatalogConfigFile(PROJECT_DIRECTORY);
+    const { generators = [] } = config;
+    if (!generators.length) {
+      console.log("No configured generators found, skipping generation");
+      return;
+    }
+    for (const generator of generators) {
+      let plugin = generator[0];
+      const pluginConfig = generator[1];
+      if (plugin.startsWith("./")) {
+        plugin = path.join(PROJECT_DIRECTORY, plugin);
+      }
+      if (plugin.includes("<rootDir>")) {
+        plugin = plugin.replace("<rootDir>", PROJECT_DIRECTORY);
+      }
+      try {
+        const importedGenerator = await import(plugin);
+        const generator2 = getDefaultExport(importedGenerator);
+        await generator2({ eventCatalogConfig: {} }, pluginConfig);
+      } catch (error) {
+        console.error("Error loading plugin:", error);
+        await cleanup(PROJECT_DIRECTORY);
+        return;
+      }
+    }
+    await cleanup(PROJECT_DIRECTORY);
+  } catch (error) {
+    console.error(error);
+    await cleanup(PROJECT_DIRECTORY);
+  }
+};
+
+export {
+  generate
+};

package/dist/constants.cjs

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  VERSION: () => VERSION
+});
+module.exports = __toCommonJS(constants_exports);
+
+// package.json
+var version = "2.15.0";
+
+// src/constants.ts
+var VERSION = version;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VERSION
+});

package/dist/constants.d.cts

@@ -0,0 +1,3 @@
+declare const VERSION: string;
+
+export { VERSION };

package/dist/constants.d.ts

@@ -0,0 +1,3 @@
+declare const VERSION: string;
+
+export { VERSION };

package/dist/constants.js

@@ -0,0 +1,6 @@
+import {
+  VERSION
+} from "./chunk-TGOUSS6C.js";
+export {
+  VERSION
+};

package/dist/eventcatalog-config-file-utils.cjs

@@ -0,0 +1,116 @@
+"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/eventcatalog-config-file-utils.js
+var eventcatalog_config_file_utils_exports = {};
+__export(eventcatalog_config_file_utils_exports, {
+  addPropertyToFrontMatter: () => addPropertyToFrontMatter,
+  cleanup: () => cleanup,
+  getEventCatalogConfigFile: () => getEventCatalogConfigFile,
+  verifyRequiredFieldsAreInCatalogConfigFile: () => verifyRequiredFieldsAreInCatalogConfigFile,
+  writeEventCatalogConfigFile: () => writeEventCatalogConfigFile
+});
+module.exports = __toCommonJS(eventcatalog_config_file_utils_exports);
+var import_promises = require("fs/promises");
+var import_node_fs = require("fs");
+var import_promises2 = require("fs/promises");
+var import_node_path = __toESM(require("path"), 1);
+var import_uuid = require("uuid");
+var import_url = require("url");
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+async function cleanup(projectDirectory) {
+  const filePath = import_node_path.default.join(projectDirectory, "eventcatalog.config.mjs");
+  if ((0, import_node_fs.existsSync)(filePath)) {
+    await (0, import_promises.rm)(filePath);
+  }
+}
+var getEventCatalogConfigFile = async (projectDirectory) => {
+  try {
+    let configFilePath = import_node_path.default.join(projectDirectory, "eventcatalog.config.js");
+    const filePath = import_node_path.default.join(projectDirectory, "package.json");
+    const packageJson = JSON.parse(await (0, import_promises.readFile)(filePath, "utf-8"));
+    if (packageJson?.type !== "module") {
+      await (0, import_promises2.copyFile)(configFilePath, import_node_path.default.join(projectDirectory, "eventcatalog.config.mjs"));
+      configFilePath = import_node_path.default.join(projectDirectory, "eventcatalog.config.mjs");
+    }
+    const configFileURL = (0, import_url.pathToFileURL)(configFilePath).href;
+    const config = await import(
+      /* @vite-ignore */
+      configFileURL
+    );
+    return config.default;
+  } finally {
+    await cleanup(projectDirectory);
+  }
+};
+var writeEventCatalogConfigFile = async (projectDirectory, newConfig) => {
+  try {
+    const configFilePath = import_node_path.default.join(projectDirectory, "eventcatalog.config.js");
+    let content = await (0, import_promises.readFile)(configFilePath, "utf8");
+    const startIndex = content.indexOf("export default {");
+    if (startIndex === -1) {
+      return;
+    }
+    Object.entries(newConfig).forEach(([key, value]) => {
+      const valueString = JSON.stringify(value, null, 2).replace(/"/g, "'").replace(/\n/g, "\n  ");
+      const keyRegex = new RegExp(`(${key}\\s*:)([^,}]+)`, "g");
+      if (content.match(keyRegex)) {
+        content = content.replace(keyRegex, `$1 ${valueString}`);
+      } else {
+        const insertPosition = content.indexOf("{", startIndex) + 1;
+        content = content.slice(0, insertPosition) + `
+  ${key}: ${valueString},` + content.slice(insertPosition);
+      }
+    });
+    await (0, import_promises.writeFile)(configFilePath, content);
+  } finally {
+    await cleanup(projectDirectory);
+  }
+};
+var verifyRequiredFieldsAreInCatalogConfigFile = async (projectDirectory) => {
+  try {
+    const config = await getEventCatalogConfigFile(projectDirectory);
+    if (!config.cId) {
+      await writeEventCatalogConfigFile(projectDirectory, { cId: (0, import_uuid.v4)() });
+    }
+  } catch (error) {
+  }
+};
+function addPropertyToFrontMatter(input, newProperty, newValue) {
+  const file = (0, import_gray_matter.default)(input);
+  return import_gray_matter.default.stringify(file.content, { ...file.data, [newProperty]: newValue });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addPropertyToFrontMatter,
+  cleanup,
+  getEventCatalogConfigFile,
+  verifyRequiredFieldsAreInCatalogConfigFile,
+  writeEventCatalogConfigFile
+});

package/dist/eventcatalog-config-file-utils.d.cts

@@ -0,0 +1,7 @@
+declare function cleanup(projectDirectory: any): Promise<void>;
+declare function addPropertyToFrontMatter(input: any, newProperty: any, newValue: any): string;
+declare function getEventCatalogConfigFile(projectDirectory: any): Promise<any>;
+declare function writeEventCatalogConfigFile(projectDirectory: any, newConfig: any): Promise<void>;
+declare function verifyRequiredFieldsAreInCatalogConfigFile(projectDirectory: any): Promise<void>;
+
+export { addPropertyToFrontMatter, cleanup, getEventCatalogConfigFile, verifyRequiredFieldsAreInCatalogConfigFile, writeEventCatalogConfigFile };

package/dist/eventcatalog-config-file-utils.d.ts

@@ -0,0 +1,7 @@
+declare function cleanup(projectDirectory: any): Promise<void>;
+declare function addPropertyToFrontMatter(input: any, newProperty: any, newValue: any): string;
+declare function getEventCatalogConfigFile(projectDirectory: any): Promise<any>;
+declare function writeEventCatalogConfigFile(projectDirectory: any, newConfig: any): Promise<void>;
+declare function verifyRequiredFieldsAreInCatalogConfigFile(projectDirectory: any): Promise<void>;
+
+export { addPropertyToFrontMatter, cleanup, getEventCatalogConfigFile, verifyRequiredFieldsAreInCatalogConfigFile, writeEventCatalogConfigFile };