@trackunit/iris-app-e2e 1.8.90 → 1.8.92-alpha-192bcb42ded.0

package/src/plugins/createLogFile.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogFile = createLogFile;
+const tslib_1 = require("tslib");
+const fs_1 = tslib_1.__importStar(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const writeFileWithPrettier_1 = require("./writeFileWithPrettier");
+const isNetworkCall = (log) => {
+    return log.type === "cy:fetch" || log.type === "cy:request" || log.type === "cy:response" || log.type === "cy:xrh";
+};
+/**
+ * Creates log files for Cypress test runs.
+ * Generates separate files for all logs, errors, and network errors.
+ */
+function createLogFile(nxRoot, logsPath, fileNameWithoutExtension, logs, logWriter) {
+    if (!(0, fs_1.existsSync)(logsPath)) {
+        fs_1.default.mkdirSync(logsPath, { recursive: true });
+    }
+    const logFilePath = path_1.default.join(logsPath, fileNameWithoutExtension);
+    (0, writeFileWithPrettier_1.writeFileWithPrettier)(nxRoot, logFilePath + "-all.json", JSON.stringify(logs), { flag: "a" }, logWriter);
+    const errorCmds = logs.filter(log => log.severity === "error" &&
+        // This seems to be when apollo has cancelled requests it marks it as failed to fetch only on cypress ?!??
+        // might be fixed by https://github.com/Trackunit/manager/pull/12917
+        !log.message.includes("TypeError: Failed to fetch"));
+    if (errorCmds.length > 0) {
+        (0, writeFileWithPrettier_1.writeFileWithPrettier)(nxRoot, logFilePath + "-errors.json", JSON.stringify(errorCmds), {
+            flag: "a",
+        }, logWriter);
+    }
+    const networkErrorsCmds = logs.filter(log => isNetworkCall(log) &&
+        !log.message.includes("Status: 200") &&
+        log.severity !== "success" &&
+        !log.message.includes("sentry.io/api/") &&
+        // This seems to be when apollo has cancelled requests it marks it as failed to fetch only on cypress ?!??
+        !log.message.includes("TypeError: Failed to fetch"));
+    if (networkErrorsCmds.length > 0) {
+        (0, writeFileWithPrettier_1.writeFileWithPrettier)(nxRoot, logFilePath + "-network-errors.json", JSON.stringify(networkErrorsCmds), {
+            flag: "a",
+        }, logWriter);
+    }
+}
+//# sourceMappingURL=createLogFile.js.map

package/src/plugins/defaultPlugins.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupPlugins = exports.defaultCypressConfig = void 0;
+const tslib_1 = require("tslib");
+const crypto_1 = tslib_1.__importDefault(require("crypto"));
+const fs_1 = require("fs");
+const node_xlsx_1 = require("node-xlsx");
+const path_1 = tslib_1.__importDefault(require("path"));
+const Codeowner_1 = require("../utils/Codeowner");
+const fileNameBuilder_1 = require("../utils/fileNameBuilder");
+const createLogFile_1 = require("./createLogFile");
+/**
+ * Utility function to find NX workspace root by looking for nx.json or workspace.json.
+ * This is more reliable than hardcoded relative paths and works from any directory.
+ *
+ * @param startDir Starting directory for the search (defaults to current working directory)
+ * @returns {string} Absolute path to the workspace root
+ * @throws Error if workspace root cannot be found
+ */
+function findWorkspaceRoot(startDir = process.cwd()) {
+    let currentDir = startDir;
+    while (currentDir !== path_1.default.dirname(currentDir)) {
+        if ((0, fs_1.existsSync)(path_1.default.join(currentDir, "nx.json")) || (0, fs_1.existsSync)(path_1.default.join(currentDir, "workspace.json"))) {
+            return currentDir;
+        }
+        currentDir = path_1.default.dirname(currentDir);
+    }
+    throw new Error("Could not find NX workspace root (nx.json or workspace.json not found)");
+}
+/**
+ * Creates default Cypress configuration for E2E testing.
+ * Supports both legacy string parameter (dirname) and new options object for backward compatibility.
+ */
+const defaultCypressConfig = optionsOrDirname => {
+    // Support both old API (string/undefined) and new API (object) for backward compatibility
+    const options = typeof optionsOrDirname === "object" ? optionsOrDirname : {};
+    const { nxRoot: providedNxRoot, outputDirOverride, projectConfig = {}, behaviorConfig = {}, pluginConfig = {}, } = options;
+    // Use NX workspace detection for reliable root finding
+    const nxRoot = providedNxRoot ?? findWorkspaceRoot();
+    // For output path calculation, determine the relative path from caller to workspace root
+    const callerDirname = typeof optionsOrDirname === "string" ? optionsOrDirname : process.cwd();
+    const relativePath = path_1.default.relative(nxRoot, callerDirname);
+    const dotsToNxRoot = relativePath
+        .split(path_1.default.sep)
+        .map(_ => "..")
+        .join("/");
+    const envOutputDirOverride = process.env.NX_E2E_OUTPUT_DIR || outputDirOverride;
+    // Function to build output paths that respects the override
+    const buildOutputPath = (subPath) => {
+        if (envOutputDirOverride) {
+            return path_1.default.join(dotsToNxRoot, envOutputDirOverride, subPath);
+        }
+        return `${dotsToNxRoot}/dist/cypress/${relativePath}/${subPath}`;
+    };
+    return {
+        projectId: projectConfig.projectId ?? process.env.CYPRESS_PROJECT_ID,
+        defaultCommandTimeout: behaviorConfig.defaultCommandTimeout ?? 20000,
+        execTimeout: behaviorConfig.execTimeout ?? 300000,
+        taskTimeout: behaviorConfig.taskTimeout ?? 35000,
+        pageLoadTimeout: behaviorConfig.pageLoadTimeout ?? 35000,
+        // setting to undefined makes no effect on the baseUrl so child projects can override it
+        baseUrl: process.env.NX_FEATURE_BRANCH_BASE_URL ?? undefined,
+        // This avoid issues with SRI hashes changing
+        modifyObstructiveCode: false,
+        requestTimeout: behaviorConfig.requestTimeout ?? 25000,
+        responseTimeout: behaviorConfig.responseTimeout ?? 150000,
+        retries: behaviorConfig.retries ?? {
+            runMode: 3,
+            openMode: 0,
+        },
+        fixturesFolder: projectConfig.fixturesFolder ?? "./src/fixtures",
+        downloadsFolder: pluginConfig.outputPath ?? buildOutputPath("downloads"),
+        logsFolder: pluginConfig.logsFolder ?? buildOutputPath("logs"),
+        chromeWebSecurity: false,
+        reporter: "junit",
+        reporterOptions: {
+            mochaFile: buildOutputPath("results-[hash].xml"),
+        },
+        specPattern: projectConfig.specPattern ?? "src/e2e/**/*.e2e.{js,jsx,ts,tsx}",
+        supportFile: projectConfig.supportFile ?? "src/support/e2e.ts",
+        nxRoot,
+        fileServerFolder: ".",
+        video: true,
+        trashAssetsBeforeRuns: false, // Don't delete videos from previous test runs (important for sequential runs)
+        videosFolder: pluginConfig.videosFolder ?? buildOutputPath("videos"),
+        screenshotsFolder: pluginConfig.screenshotsFolder ?? buildOutputPath("screenshots"),
+        env: {
+            hars_folders: pluginConfig.harFolder ?? buildOutputPath("hars"),
+            CYPRESS_RUN_UNIQUE_ID: crypto_1.default.randomUUID(),
+        },
+    };
+};
+exports.defaultCypressConfig = defaultCypressConfig;
+/**
+ * Sets up Cypress plugins for logging, tasks, and HAR generation.
+ * Configures terminal reporting, XLSX parsing, and HTTP archive recording.
+ */
+const setupPlugins = (on, config, logWriter, installHarGenerator) => {
+    /* ---- BEGIN: Logging setup ---- */
+    // Read options https://github.com/archfz/cypress-terminal-report
+    const options = {
+        printLogsToFile: "always", // Ensures logs are always printed to a file
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        collectTestLogs: (context, logs) => {
+            const testName = (0, fileNameBuilder_1.fileNameBuilder)(context.test, context.state);
+            (0, createLogFile_1.createLogFile)(config.nxRoot, config.logsFolder, testName, logs, logWriter);
+        },
+    };
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    require("cypress-terminal-report/src/installLogsPrinter")(on, options);
+    /* ---- END: Logging setup ---- */
+    /* ---- BEGIN: Task setup ---- */
+    on("task", {
+        parseXlsx(filePath) {
+            return new Promise((resolve, reject) => {
+                try {
+                    const jsonData = (0, node_xlsx_1.parse)((0, fs_1.readFileSync)(filePath));
+                    resolve(jsonData);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        },
+        fileExists(filename) {
+            return (0, fs_1.existsSync)(filename);
+        },
+    });
+    /* ---- END: Task setup ---- */
+    /* ---- BEGIN: codeowner setup ---- */
+    const codeowner = (0, Codeowner_1.toShortTeamName)((0, Codeowner_1.getCodeowner)(config.projectRoot, config.nxRoot));
+    config.env.codeowner = codeowner;
+    /* ---- END: codeowner setup ---- */
+    /* ---- BEGIN: HAR setup ---- */
+    // Installing the HAR geneartor should happen last according to the documentation
+    // https://github.com/NeuraLegion/cypress-har-generator?tab=readme-ov-file#setting-up-the-plugin
+    installHarGenerator(on);
+    /* ---- END: HAR setup ---- */
+    return config;
+};
+exports.setupPlugins = setupPlugins;
+//# sourceMappingURL=defaultPlugins.js.map

package/src/plugins/nxPreset.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNxPreset = createNxPreset;
+const cypress_preset_1 = require("@nx/cypress/plugins/cypress-preset");
+const nx_tsconfig_paths_plugin_1 = require("@nx/vite/plugins/nx-tsconfig-paths.plugin");
+/**
+ * Creates the standard NX E2E preset configuration for Cypress.
+ * This wraps the @nx/cypress preset with our default Vite configuration.
+ *
+ * @param filename - Pass `__filename` from the calling cypress.config.ts
+ * @example
+ * ```ts
+ * import { createNxPreset, CypressPluginConfig, defaultCypressConfig, setupPlugins } from "@trackunit/iris-app-e2e";
+ * import { defineConfig } from "cypress";
+ *
+ * const nxPreset = createNxPreset(__filename);
+ *
+ * export default defineConfig({
+ *   chromeWebSecurity: false,
+ *   e2e: {
+ *     ...nxPreset,
+ *     ...defaultCypressConfig(__dirname),
+ *     async setupNodeEvents(on, config: CypressPluginConfig) {
+ *       await nxPreset.setupNodeEvents?.(on, config);
+ *       return setupPlugins(on, config, formatter, installHarGenerator);
+ *     },
+ *   },
+ * });
+ * ```
+ */
+function createNxPreset(filename) {
+    return (0, cypress_preset_1.nxE2EPreset)(filename, {
+        bundler: "vite",
+        cypressDir: "cypress",
+        viteConfigOverrides: {
+            configFile: false,
+            plugins: [(0, nx_tsconfig_paths_plugin_1.nxViteTsPaths)()],
+        },
+    });
+}
+//# sourceMappingURL=nxPreset.js.map

package/src/plugins/writeFileWithPrettier.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFileWithPrettier = void 0;
+const tslib_1 = require("tslib");
+/* eslint-disable no-console */
+const fs_1 = require("fs");
+const path = tslib_1.__importStar(require("path"));
+/**
+ * Writes a file with Prettier formatting applied.
+ * Automatically detects parser based on file extension.
+ */
+const writeFileWithPrettier = async (nxRoot, filePath, content, writeOptions = { encoding: "utf-8" }, writer) => {
+    const prettierConfigPath = path.join(nxRoot, ".prettierrc");
+    const options = await writer
+        .resolveConfig(prettierConfigPath)
+        .catch(error => console.log("Prettier config error: ", error));
+    if (!options) {
+        throw new Error("Could not find prettier config");
+    }
+    if (filePath.endsWith("json")) {
+        options.parser = "json";
+    }
+    else {
+        options.parser = "typescript";
+    }
+    try {
+        const prettySrc = await writer.format(content, options);
+        (0, fs_1.writeFileSync)(filePath, prettySrc, writeOptions);
+    }
+    catch (error) {
+        console.error("Error in prettier.format:", error);
+    }
+};
+exports.writeFileWithPrettier = writeFileWithPrettier;
+//# sourceMappingURL=writeFileWithPrettier.js.map

package/src/setup/defaultE2ESetup.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupE2E = setupE2E;
+const tslib_1 = require("tslib");
+const installLogsCollector_1 = tslib_1.__importDefault(require("cypress-terminal-report/src/installLogsCollector"));
+const setupHarRecording_1 = require("./setupHarRecording");
+/**
+ * Sets up the E2E testing environment with HAR recording and terminal logging.
+ */
+function setupE2E() {
+    (0, setupHarRecording_1.setupHarRecording)();
+    (0, installLogsCollector_1.default)({
+        xhr: {
+            printHeaderData: true,
+            printRequestData: true,
+        },
+    });
+    Cypress.on("uncaught:exception", (err) => {
+        // eslint-disable-next-line no-console
+        console.log("Caught Error: ", err);
+        // returning false here prevents Cypress from
+        // failing the test
+        return false;
+    });
+}
+const originalDescribe = globalThis.describe;
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+if (originalDescribe) {
+    const codeowner = Cypress.env("codeowner");
+    const addOwnerToTitle = (title) => {
+        return codeowner ? title + ` [${codeowner}]` : title;
+    };
+    function patchedDescribe(title, fn) {
+        return originalDescribe(addOwnerToTitle(title), fn);
+    }
+    patchedDescribe.only = (title, fn) => {
+        return originalDescribe.only(addOwnerToTitle(title), fn);
+    };
+    patchedDescribe.skip = (title, fn) => {
+        return originalDescribe.skip(addOwnerToTitle(title), fn);
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    globalThis.describe = patchedDescribe;
+}
+//# sourceMappingURL=defaultE2ESetup.js.map

package/src/setup/setupHarRecording.js

@@ -0,0 +1,24 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupHarRecording = setupHarRecording;
+require("@neuralegion/cypress-har-generator/commands");
+const fileNameBuilder_1 = require("../utils/fileNameBuilder");
+/**
+ * Sets up HAR (HTTP Archive) recording for E2E tests.
+ * Records network activity and saves HAR files for failed tests.
+ */
+function setupHarRecording() {
+    beforeEach(() => {
+        const harDir = Cypress.env("hars_folders");
+        cy.recordHar({ rootDir: harDir });
+    });
+    afterEach(function () {
+        if (this.currentTest.state === "failed") {
+            const harDir = Cypress.env("hars_folders");
+            const testName = (0, fileNameBuilder_1.fileNameBuilder)(`${Cypress.currentTest.titlePath[0]} - ${Cypress.currentTest.title}`, "failed", Cypress.currentRetry);
+            cy.saveHar({ outDir: harDir, fileName: testName });
+        }
+    });
+}
+//# sourceMappingURL=setupHarRecording.js.map

package/src/support.js

@@ -0,0 +1,13 @@
+"use strict";
+/// <reference path="./types/cypress.d.ts" />
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+/**
+ * Browser-only exports for Cypress support files.
+ * These modules depend on the Cypress global and must only be imported
+ * in Cypress support files, NOT in cypress.config.ts or other Node.js contexts.
+ */
+tslib_1.__exportStar(require("./commands/defaultCommands"), exports);
+tslib_1.__exportStar(require("./setup/defaultE2ESetup"), exports);
+tslib_1.__exportStar(require("./setup/setupHarRecording"), exports);
+//# sourceMappingURL=support.js.map

package/src/utils/Codeowner.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCodeowner = exports.toShortTeamName = exports.parseCodeowners = void 0;
+const tslib_1 = require("tslib");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+/**
+ * Parses lines from a CODEOWNERS‐style file into a mapping of patterns → owners.
+ * Skips blank lines and comments (lines beginning with `#`).
+ *
+ * @param {string[]} lines - Each element is a line from your CODEOWNERS file.
+ * @returns {Record<string, string>} An object whose keys are normalized path patterns (no leading/trailing slashes)
+ *                                  and whose values are the owner (e.g. a GitHub team handle).
+ * @example
+ * ```ts
+ * const lines = [
+ *   "# Our CODEOWNERS",
+ *   "/src @team/backend",
+ *   "README.md    @team/docs",
+ *   "",                 // blank lines ignored
+ *   "# end of file"
+ * ];
+ * const owners = parseCodeowners(lines);
+ * // → { "src": "@team/backend", "README.md": "@team/docs" }
+ * ```
+ */
+const parseCodeowners = (lines) => {
+    const patterns = {};
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) {
+            continue;
+        }
+        const [pattern, owner] = trimmed.split(/\s+/, 2);
+        if (pattern && owner) {
+            const normalizedPattern = pattern.replace(/^\/+|\/+$/g, "");
+            patterns[normalizedPattern] = owner;
+        }
+    }
+    return patterns;
+};
+exports.parseCodeowners = parseCodeowners;
+/**
+ * Converts a full team handle (potentially namespaced and with platform suffix)
+ * into its “short” team name.
+ *
+ * - Strips any leading `@org/` prefix
+ * - Removes `-be` or `-fe` suffix if present
+ *
+ * @param {string} teamName - e.g. `"@trackunit/backend-be"` or `"@trackunit/frontend-fe"`
+ * @returns {string} e.g. `"backend"` or `"frontend"`
+ * @example
+ * ```ts
+ * toShortTeamName("@trackunit/backend-be");   // → "backend"
+ * toShortTeamName("@trackunit/frontend-fe");  // → "frontend"
+ * toShortTeamName("infra");                   // → "infra"
+ * ```
+ */
+const toShortTeamName = (teamName) => {
+    if (!teamName) {
+        return undefined;
+    }
+    let shortName = teamName;
+    if (teamName.startsWith("@")) {
+        shortName = shortName.slice(shortName.indexOf("/") + 1);
+    }
+    if (shortName.endsWith("-be") || shortName.endsWith("-fe")) {
+        shortName = shortName.slice(0, shortName.lastIndexOf("-"));
+    }
+    return shortName;
+};
+exports.toShortTeamName = toShortTeamName;
+/**
+ * Recursively looks up the CODEOWNER for a given file or directory path
+ * by reading your workspace’s CODEOWNERS file.
+ *
+ * Walks up the directory tree until it finds a matching pattern. If no
+ * deeper match is found but there is a `"."` entry, returns that.
+ *
+ * @param {string} currentPath - Absolute path to the file/directory you’re querying.
+ * @param {string} workspaceRoot - Absolute path to your repo/workspace root.
+ * @param {string} [codeownersFileName="TEAM_CODEOWNERS"] - Filename to read at the root.
+ * @returns {string|undefined} The owner handle (e.g. `"@team/backend"`) or `undefined` if none found.
+ * @example
+ * ```ts
+ * // Suppose your repo root has a TEAM_CODEOWNERS file containing:
+ * // src @team/backend
+ * // src/utils @team/utils
+ * // . @team/root
+ *
+ * const owner1 = getCodeowner(
+ *   "/Users/alice/project/src/utils/helpers.ts",
+ *   "/Users/alice/project"
+ * );
+ * // → "@team/utils"
+ *
+ * const owner2 = getCodeowner(
+ *   "/Users/alice/project/other/file.txt",
+ *   "/Users/alice/project"
+ * );
+ * // → "@team/root"  (falls back to the "." entry)
+ * ```
+ */
+const getCodeowner = (currentPath, workspaceRoot, codeownersFileName = "TEAM_CODEOWNERS") => {
+    if (!workspaceRoot) {
+        return undefined;
+    }
+    const codeownersPath = path_1.default.join(workspaceRoot, codeownersFileName);
+    if (!fs_1.default.existsSync(codeownersPath)) {
+        return undefined;
+    }
+    const codeownersLines = fs_1.default.readFileSync(codeownersPath, "utf8").split("\n");
+    const codeowners = (0, exports.parseCodeowners)(codeownersLines);
+    let relPath = path_1.default
+        .relative(workspaceRoot, currentPath)
+        .replace(/\\/g, "/")
+        .replace(/^\/+|\/+$/g, "");
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    while (true) {
+        const codeowner = codeowners[relPath];
+        if (codeowner) {
+            return codeowner;
+        }
+        const parent = path_1.default.posix.dirname(relPath);
+        if ((parent === relPath || parent === ".") && codeowners["."]) {
+            return codeowners["."];
+        }
+        if (parent === relPath || parent === ".") {
+            break;
+        }
+        relPath = parent;
+    }
+    return undefined;
+};
+exports.getCodeowner = getCodeowner;
+//# sourceMappingURL=Codeowner.js.map

package/src/utils/fileNameBuilder.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeForFilename = sanitizeForFilename;
+exports.fileNameBuilder = fileNameBuilder;
+/**
+ * Sanitizes a string to be safe for use in filenames.
+ * Removes special characters and truncates if too long.
+ *
+ * @param str - The string to sanitize (e.g., test suite or test name)
+ * @returns {string} Sanitized string safe for filesystem use
+ */
+function sanitizeForFilename(str) {
+    return str
+        .replace(/[^a-zA-Z0-9-_\s\[\]\(\)]/g, "") // Remove special chars - with exceptions
+        .replace(/-+/g, "-") // Collapse multiple hyphens into one
+        .replace(/\s+/g, " ") // Collapse multiple spaces into one
+        .replace(/^-|-$/g, ""); // Trim leading/trailing hyphens
+}
+/**
+ * Builds a standardized filename for test artifacts (e.g., HAR files, screenshots).
+ * Combines test name, state, and attempt number into a readable filename.
+ *
+ * @param testName - The name of the test (will be sanitized)
+ * @param state - The test state (e.g., 'passed', 'failed')
+ * @param currentRetry - The current retry attempt number (0-based)
+ * @returns {string} A sanitized filename in the format: "testName (state) (attempt N)"
+ * @example
+ * fileNameBuilder("Login Flow", "failed", 0)
+ * // Returns: "Login Flow (failed) (attempt 1)"
+ * @example
+ * fileNameBuilder("Test: with -> special chars", "passed", 2)
+ * // Returns: "Test with - special chars (passed) (attempt 3)"
+ */
+function fileNameBuilder(testName, state, currentRetry) {
+    const fileName = `${testName} ${currentRetry !== undefined ? `(Attempt ${currentRetry + 1})` : ""} (${state.toLowerCase()})`;
+    return sanitizeForFilename(fileName);
+}
+//# sourceMappingURL=fileNameBuilder.js.map

package/src/utils/fileUpdater.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteFileInTree = exports.updateFileInTree = void 0;
+/**
+ *
+ * @param tree File system tree
+ * @param path Path to source file in the Tree
+ * @param updater Function that maps the current file content to a new to be written to the Tree
+ */
+const updateFileInTree = (tree, path, updater) => {
+    if (!tree.exists(path)) {
+        throw new Error("File not found: " + path);
+    }
+    const fileContent = tree.read(path, "utf-8");
+    if (!fileContent) {
+        throw new Error("File is empty: " + path);
+    }
+    const result = updater(fileContent);
+    if (result !== fileContent) {
+        tree.write(path, result);
+    }
+};
+exports.updateFileInTree = updateFileInTree;
+/**
+ *
+ * @param tree File system tree
+ * @param path Path to source file in the Tree
+ */
+const deleteFileInTree = (tree, path) => {
+    if (!tree.exists(path)) {
+        // File doesn't exist, nothing to delete - this is fine
+        return;
+    }
+    tree.delete(path);
+};
+exports.deleteFileInTree = deleteFileInTree;
+//# sourceMappingURL=fileUpdater.js.map

package/index.cjs.default.js

@@ -1 +0,0 @@
-exports._default = require('./index.cjs.js').default;