@capillarytech/cap-ui-utils 3.1.1 → 3.1.2

package/e2e/utils/{requestRecorderUtil.ts → requestRecorderUtil.js}

@@ -1,133 +1,107 @@
-import fs from 'fs';
-import path from 'path';
-import debugMode from './debugModeUtil';
-
-/**
- * Records request payloads (POST / PATCH / DELETE) sent from the UI during a
- * test run and saves them to JSON files under reports/debug/request-payloads/.
- *
- * Off by default; enabled only when FULL_DEBUG_MODE=true. When off, every
- * method is a no-op so there is zero overhead.
- *
- * One JSON file is written per test, containing an array of all the
- * POST / PATCH / DELETE requests captured while that test was running.
- */
-
-interface InitiatorFrame {
-    functionName: string;
-    url: string;
-    line: number;
-}
-
-interface RequestInitiator {
-    // 'script' (a JS handler fired it), 'parser', 'preflight', 'other', ...
-    type: string;
-    // Top JS call frames that triggered the request — i.e. which handler fired it.
-    stack: InitiatorFrame[];
-}
-
-interface RecordedRequest {
-    requestId: string;
-    method: string;
-    url: string;
-    timestamp: string;
-    postData: string | null;
-    headers: Record<string, string>;
-    // Which app code initiated the request (from CDP initiator).
-    initiator: RequestInitiator | null;
-}
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const debugModeUtil_1 = __importDefault(require("./debugModeUtil"));
 const RECORDED_METHODS = ['POST', 'PATCH', 'DELETE', 'PUT'];
 // How many call frames to keep — enough to identify the handler without bloat.
 const MAX_INITIATOR_FRAMES = 3;
-
 class RequestRecorder {
-    // Off by default; record only when capture is enabled for this module
-    // (FULL_DEBUG_MODE=true and, if DEBUG_MODULES is set, module is listed).
-    private enabled = debugMode.isCaptureEnabled();
-    private outputDir = path.join(process.cwd(), 'reports', 'debug', 'request-payloads');
-    private currentTestTitle = '';
-    private buffer: RecordedRequest[] = [];
-    private seenRequestIds = new Set<string>();
-
-    isEnabled(): boolean {
+    constructor() {
+        // Off by default; record only when capture is enabled for this module
+        // (FULL_DEBUG_MODE=true and, if DEBUG_MODULES is set, module is listed).
+        this.enabled = debugModeUtil_1.default.isCaptureEnabled();
+        this.outputDir = path_1.default.join(process.cwd(), 'reports', 'debug', 'request-payloads');
+        this.currentTestTitle = '';
+        this.buffer = [];
+        this.seenRequestIds = new Set();
+    }
+    isEnabled() {
         return this.enabled;
     }
-
     /** Reset the buffer and remember the test we are currently recording for. */
-    startTest(testTitle: string): void {
-        if (!this.enabled) return;
+    startTest(testTitle) {
+        if (!this.enabled)
+            return;
         this.currentTestTitle = testTitle || 'unknown_test';
         this.buffer = [];
         this.seenRequestIds.clear();
     }
-
     /**
      * Capture a single request from a CDP Network.requestWillBeSent event.
      * Only POST / PATCH / DELETE requests matching baseUrl are recorded.
      * Large request bodies are fetched via Network.getRequestPostData when
      * the event payload does not inline them.
      */
-    async record(params: any, baseUrl: string): Promise<void> {
-        if (!this.enabled) return;
+    async record(params, baseUrl) {
+        var _a, _b, _c;
+        if (!this.enabled)
+            return;
         try {
-            const request = params?.request;
-            if (!request) return;
-
+            const request = params === null || params === void 0 ? void 0 : params.request;
+            if (!request)
+                return;
             const method = (request.method || '').toUpperCase();
-            if (!RECORDED_METHODS.includes(method)) return;
-            if (baseUrl && !String(request.url).startsWith(baseUrl)) return;
-
+            if (!RECORDED_METHODS.includes(method))
+                return;
+            if (baseUrl && !String(request.url).startsWith(baseUrl))
+                return;
             // CDP can emit requestWillBeSent more than once per request; dedupe by id.
             const requestId = String(params.requestId);
-            if (this.seenRequestIds.has(requestId)) return;
+            if (this.seenRequestIds.has(requestId))
+                return;
             this.seenRequestIds.add(requestId);
-
-            const entry: RecordedRequest = {
+            const entry = {
                 requestId,
                 method,
                 url: request.url,
                 timestamp: new Date().toISOString(),
-                postData: request.postData ?? null,
-                headers: request.headers ?? {},
-                initiator: this.extractInitiator(params?.initiator),
+                postData: (_a = request.postData) !== null && _a !== void 0 ? _a : null,
+                headers: (_b = request.headers) !== null && _b !== void 0 ? _b : {},
+                initiator: this.extractInitiator(params === null || params === void 0 ? void 0 : params.initiator),
             };
             // Preserve ordering: push synchronously, backfill body if needed.
             this.buffer.push(entry);
-
             if (entry.postData == null && request.hasPostData) {
                 try {
-                    const res: any = await browser.cdp('Network', 'getRequestPostData', {
+                    const res = await browser.cdp('Network', 'getRequestPostData', {
                         requestId: params.requestId,
                     });
-                    entry.postData = res?.postData ?? null;
-                } catch (err) {
+                    entry.postData = (_c = res === null || res === void 0 ? void 0 : res.postData) !== null && _c !== void 0 ? _c : null;
+                }
+                catch (err) {
                     console.log(`[requestRecorder] could not fetch post data: ${err}`);
                 }
             }
-        } catch (err) {
+        }
+        catch (err) {
             console.log(`[requestRecorder] failed to record request: ${err}`);
         }
     }
-
     /**
      * Reduce a CDP initiator to a compact, comparable shape: the request type
      * and the top few JS call frames (the handler that fired the request).
      * CDP line/column numbers are 0-based, so +1 for human-readable lines.
      */
-    private extractInitiator(initiator: any): RequestInitiator | null {
-        if (!initiator) return null;
-        const frames: InitiatorFrame[] = [];
-        const callFrames = initiator?.stack?.callFrames;
+    extractInitiator(initiator) {
+        var _a;
+        if (!initiator)
+            return null;
+        const frames = [];
+        const callFrames = (_a = initiator === null || initiator === void 0 ? void 0 : initiator.stack) === null || _a === void 0 ? void 0 : _a.callFrames;
         if (Array.isArray(callFrames)) {
             for (const f of callFrames.slice(0, MAX_INITIATOR_FRAMES)) {
                 frames.push({
-                    functionName: f?.functionName || '(anonymous)',
-                    url: f?.url || '',
-                    line: typeof f?.lineNumber === 'number' ? f.lineNumber + 1 : -1,
+                    functionName: (f === null || f === void 0 ? void 0 : f.functionName) || '(anonymous)',
+                    url: (f === null || f === void 0 ? void 0 : f.url) || '',
+                    line: typeof (f === null || f === void 0 ? void 0 : f.lineNumber) === 'number' ? f.lineNumber + 1 : -1,
                 });
             }
-        } else if (initiator.url) {
+        }
+        else if (initiator.url) {
             // parser-initiated requests carry url/lineNumber directly.
             frames.push({
                 functionName: '',
@@ -137,24 +111,22 @@ class RequestRecorder {
         }
         return { type: initiator.type || 'other', stack: frames };
     }
-
     /** Write the buffered requests for the current test to a JSON file. */
-    flushTest(): void {
-        if (!this.enabled) return;
+    flushTest() {
+        if (!this.enabled)
+            return;
         try {
-            if (this.buffer.length === 0) return;
-
+            if (this.buffer.length === 0)
+                return;
             const moduleName = process.env.module || 'unknown_module';
-            const dir = path.join(this.outputDir, moduleName);
-            fs.mkdirSync(dir, { recursive: true });
-
+            const dir = path_1.default.join(this.outputDir, moduleName);
+            fs_1.default.mkdirSync(dir, { recursive: true });
             const safeTitle = this.currentTestTitle
                 .replace(/[^a-zA-Z0-9_-]+/g, '_')
                 .slice(0, 120);
             // Stable filename (no timestamp) so the same test maps to the same
             // path across runs/zips — enables zip-to-zip payload diffing.
             const fileName = `${safeTitle}.json`;
-
             const payload = {
                 test: this.currentTestTitle,
                 module: moduleName,
@@ -162,17 +134,17 @@ class RequestRecorder {
                 requestCount: this.buffer.length,
                 requests: this.buffer,
             };
-
-            fs.writeFileSync(path.join(dir, fileName), JSON.stringify(payload, null, 2));
-            console.log(`[requestRecorder] saved ${this.buffer.length} request(s) to ${path.join(dir, fileName)}`);
-        } catch (err) {
+            fs_1.default.writeFileSync(path_1.default.join(dir, fileName), JSON.stringify(payload, null, 2));
+            console.log(`[requestRecorder] saved ${this.buffer.length} request(s) to ${path_1.default.join(dir, fileName)}`);
+        }
+        catch (err) {
             console.log(`[requestRecorder] failed to write payload file: ${err}`);
-        } finally {
+        }
+        finally {
             this.buffer = [];
             this.seenRequestIds.clear();
             this.currentTestTitle = '';
         }
     }
 }
-
-export default new RequestRecorder();
+exports.default = new RequestRecorder();

package/e2e/utils/{screenshotRecorderUtil.ts → screenshotRecorderUtil.js}

@@ -1,80 +1,60 @@
-import fs from 'fs';
-import path from 'path';
-import debugMode from './debugModeUtil';
-
-/**
- * Captures a full-page screenshot after every click and saves them under
- * reports/debug/screenshots/<module>/<test>/<NNN>_<command>.png.
- *
- * Off by default; enabled only when FULL_DEBUG_MODE=true. When off, every
- * method is a no-op so there is zero overhead.
- *
- * Driven by the WDIO afterCommand hook. Only click commands trigger a capture,
- * so other commands (typing, lookups, navigation) don't spam the report.
- *
- * Also writes a steps.json per test mapping each click (step index) to its
- * screenshot file and the wall-clock time it fired. The compare tool uses the
- * click times to attribute recorded request payloads to the click that
- * triggered them (request.timestamp falls between consecutive click times).
- */
-
-interface RecordedStep {
-    step: number;
-    file: string;
-    command: string;
-    clickTime: string;
-}
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const debugModeUtil_1 = __importDefault(require("./debugModeUtil"));
 // WDIO command names that represent a click worth screenshotting.
 const INTERACTION_COMMANDS = new Set([
     'click',
     'doubleClick',
 ]);
-
 // afterCommand fires before the post-click content has rendered; wait this long
 // so the screenshot reflects the settled page. Tunable via env.
 const SETTLE_MS = Number(process.env.FULL_DEBUG_SCREENSHOT_DELAY_MS) || 500;
-
 // Hard cap on a single CDP screenshot. The capture can hang indefinitely when it
 // fires while the page is mid-navigation (e.g. during login), which would block
 // the awaiting afterCommand hook and stall the whole run until the Mocha hook
 // timeout. Bounding it guarantees screenshots can never block automations.
 const CAPTURE_TIMEOUT_MS = Number(process.env.FULL_DEBUG_SCREENSHOT_TIMEOUT_MS) || 8000;
-
 class ScreenshotRecorder {
-    private enabled = debugMode.isCaptureEnabled();
-    private outputDir = path.join(process.cwd(), 'reports', 'debug', 'screenshots');
-    private currentTestTitle = '';
-    private counter = 0;
-    // Last saved image; used to drop byte-identical duplicate captures.
-    private lastImage: Buffer | null = null;
-    // Guard against re-entrancy: our own cdp/screenshot calls also fire afterCommand.
-    private capturing = false;
-    // Per-test record of clicks → screenshot file + time, for request correlation.
-    private steps: RecordedStep[] = [];
-
-    isEnabled(): boolean {
+    constructor() {
+        this.enabled = debugModeUtil_1.default.isCaptureEnabled();
+        this.outputDir = path_1.default.join(process.cwd(), 'reports', 'debug', 'screenshots');
+        this.currentTestTitle = '';
+        this.counter = 0;
+        // Last saved image; used to drop byte-identical duplicate captures.
+        this.lastImage = null;
+        // Guard against re-entrancy: our own cdp/screenshot calls also fire afterCommand.
+        this.capturing = false;
+        // Per-test record of clicks → screenshot file + time, for request correlation.
+        this.steps = [];
+    }
+    isEnabled() {
         return this.enabled;
     }
-
     /** Reset the per-test counter and remember the current test. */
-    startTest(testTitle: string): void {
-        if (!this.enabled) return;
+    startTest(testTitle) {
+        if (!this.enabled)
+            return;
         this.currentTestTitle = testTitle || 'unknown_test';
         this.counter = 0;
         this.lastImage = null;
         this.steps = [];
     }
-
     /** Capture a full-page screenshot if commandName is a click. */
-    async captureAfter(commandName: string): Promise<void> {
-        if (!this.enabled || this.capturing) return;
-        if (!INTERACTION_COMMANDS.has(commandName)) return;
+    async captureAfter(commandName) {
+        if (!this.enabled || this.capturing)
+            return;
+        if (!INTERACTION_COMMANDS.has(commandName))
+            return;
         // No active test means we're in the login/setup phase (the root before-all
         // hook). Capturing here is pointless and, worse, the CDP screenshot can hang
         // mid-navigation and block that hook until its Mocha timeout. Skip it.
-        if (!this.currentTestTitle) return;
-
+        if (!this.currentTestTitle)
+            return;
         this.capturing = true;
         // Stamp the click time before the settle pause so it lines up with when
         // the click actually fired (and thus with the requests it triggered).
@@ -82,20 +62,18 @@ class ScreenshotRecorder {
         try {
             // Let the post-click content render before capturing.
             await browser.pause(SETTLE_MS);
-
             // captureBeyondViewport => full scrollable page, not just the viewport.
             // Bound the CDP call: it can hang indefinitely if it fires while the page
             // is mid-navigation, which would block the awaiting afterCommand hook.
-            const capturePromise: Promise<any> = browser.cdp('Page', 'captureScreenshot', {
+            const capturePromise = browser.cdp('Page', 'captureScreenshot', {
                 format: 'png',
                 captureBeyondViewport: true,
             });
             // If the timeout wins, the CDP promise may still settle (or reject) later;
             // swallow it so a late rejection never surfaces as an unhandled rejection.
-            capturePromise.catch(() => {});
-
-            let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
-            const res: any = await Promise.race([
+            capturePromise.catch(() => { });
+            let timeoutHandle;
+            const res = await Promise.race([
                 capturePromise,
                 new Promise((resolve) => {
                     timeoutHandle = setTimeout(() => resolve(null), CAPTURE_TIMEOUT_MS);
@@ -104,71 +82,72 @@ class ScreenshotRecorder {
             // Clear the fallback timer once the race settles so a pending timeout
             // can't keep the Node event loop alive (delaying process exit by up to
             // CAPTURE_TIMEOUT_MS) when the CDP call won.
-            if (timeoutHandle) clearTimeout(timeoutHandle);
-            if (!res?.data) return;
-
+            if (timeoutHandle)
+                clearTimeout(timeoutHandle);
+            if (!(res === null || res === void 0 ? void 0 : res.data))
+                return;
             const image = Buffer.from(res.data, 'base64');
             // afterCommand fires twice per click; once settled both frames are
             // identical, so skip the byte-identical repeat.
-            if (this.lastImage && this.lastImage.equals(image)) return;
+            if (this.lastImage && this.lastImage.equals(image))
+                return;
             this.lastImage = image;
-
             const moduleName = process.env.module || 'unknown_module';
             const safeTitle = (this.currentTestTitle || '_pre-test')
                 .replace(/[^a-zA-Z0-9_-]+/g, '_')
                 .slice(0, 120);
-            const dir = path.join(this.outputDir, moduleName, safeTitle);
-            fs.mkdirSync(dir, { recursive: true });
-
+            const dir = path_1.default.join(this.outputDir, moduleName, safeTitle);
+            fs_1.default.mkdirSync(dir, { recursive: true });
             this.counter += 1;
             const seq = String(this.counter).padStart(3, '0');
             const fileName = `${seq}_${commandName}.png`;
-            fs.writeFileSync(path.join(dir, fileName), image);
-
+            fs_1.default.writeFileSync(path_1.default.join(dir, fileName), image);
             this.steps.push({
                 step: this.counter,
                 file: fileName,
                 command: commandName,
                 clickTime,
             });
-        } catch (err) {
+        }
+        catch (err) {
             console.log(`[screenshotRecorder] failed to capture after ${commandName}: ${err}`);
-        } finally {
+        }
+        finally {
             this.capturing = false;
         }
     }
-
     /**
      * Write the per-test steps.json alongside this test's screenshots, mapping
      * each click step to its screenshot file and the time it fired. Used by the
      * compare tool to attribute request payloads to the click that triggered
      * them. No-op when nothing was captured.
      */
-    flushTest(): void {
-        if (!this.enabled) return;
+    flushTest() {
+        if (!this.enabled)
+            return;
         try {
-            if (this.steps.length === 0) return;
-
+            if (this.steps.length === 0)
+                return;
             const moduleName = process.env.module || 'unknown_module';
             const safeTitle = (this.currentTestTitle || '_pre-test')
                 .replace(/[^a-zA-Z0-9_-]+/g, '_')
                 .slice(0, 120);
-            const dir = path.join(this.outputDir, moduleName, safeTitle);
-            fs.mkdirSync(dir, { recursive: true });
-
+            const dir = path_1.default.join(this.outputDir, moduleName, safeTitle);
+            fs_1.default.mkdirSync(dir, { recursive: true });
             const payload = {
                 test: this.currentTestTitle,
                 module: moduleName,
                 stepCount: this.steps.length,
                 steps: this.steps,
             };
-            fs.writeFileSync(path.join(dir, 'steps.json'), JSON.stringify(payload, null, 2));
-        } catch (err) {
+            fs_1.default.writeFileSync(path_1.default.join(dir, 'steps.json'), JSON.stringify(payload, null, 2));
+        }
+        catch (err) {
             console.log(`[screenshotRecorder] failed to write steps.json: ${err}`);
-        } finally {
+        }
+        finally {
             this.steps = [];
         }
     }
 }
-
-export default new ScreenshotRecorder();
+exports.default = new ScreenshotRecorder();

package/e2e/utils/setupMock.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mockResponse_1 = require("./mockResponse");
+class setupMock {
+    async mockBeamerAPIForPopup() {
+        const beamerReq1 = await browser.mock("https://backend.getbeamer.com/initialize" + "**", {
+            method: "get",
+        });
+        beamerReq1.respond(mockResponse_1.beamerApiResp);
+        const beamerReq2 = await browser.mock("https://backend.getbeamer.com/numberFeatures" + "**", {
+            method: "get",
+        });
+        beamerReq2.respond([{}], {
+            statusCode: 404,
+        });
+    }
+}
+exports.default = new setupMock();

package/e2e/utils/unmatchedBracesUtil.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectAndRestore = exports.focusEmailEditorAddNewLineAtEnd = exports.componentWithLabelErrorSpan = exports.invalidLabelErrorSpan = exports.invalidLabelErrorFooterContainer = exports.INVALID_LABEL_ERROR_TEXT = exports.UNSUPPORTED_TAG = exports.UNMATCHED_BRACES_SNIPPET = void 0;
+const elementUtil_1 = __importDefault(require("./elementUtil"));
+/** Invalid snippet used to trigger unmatched-braces validation across Engage and Adiona flows. */
+exports.UNMATCHED_BRACES_SNIPPET = "{{ my_standard_tag";
+/** Unsupported/unrecognised tag used to trigger the send-for-approval server-side validation error. */
+exports.UNSUPPORTED_TAG = "{{my_invalid_standard_tag}}";
+/** Full footer / inline error copy for standard-tag validation (SMS, MPush, Web Push, etc.). */
+exports.INVALID_LABEL_ERROR_TEXT = "Invalid label, please close all curly braces";
+/**
+ * Footer error container for "Invalid label…" type errors (SMS, Journey SMS).
+ * XPath: //div[contains(@class,'error-container')]//div[text()='<message>']
+ */
+function invalidLabelErrorFooterContainer(errorMessage) {
+    return $(`//div[contains(@class,'error-container')]//div[text()='${errorMessage}']`);
+}
+exports.invalidLabelErrorFooterContainer = invalidLabelErrorFooterContainer;
+/**
+ * Inline error span for "Invalid label…" (Viber, Zalo, Journey Zalo).
+ * XPath: //span[contains(@class,'error-message') and contains(.,'Invalid label')]
+ */
+function invalidLabelErrorSpan() {
+    return $("//span[contains(@class,'error-message') and contains(.,'Invalid label')]");
+}
+exports.invalidLabelErrorSpan = invalidLabelErrorSpan;
+/**
+ * Validation error span below a component-with-label input (MPush Title / Message).
+ * XPath: //div[contains(@class,'component-with-label-label') and normalize-space()='<label>']
+ *        /ancestor::div[contains(@class,'component-with-label')]//span[contains(@class,'error-message')]
+ * Use for channels where the error appears inline under the input rather than in the footer.
+ */
+function componentWithLabelErrorSpan(label) {
+    return $(`//div[contains(@class,'component-with-label-label') and normalize-space()='${label}']/ancestor::div[contains(@class,'component-with-label')]//span[contains(@class,'error-message')]`);
+}
+exports.componentWithLabelErrorSpan = componentWithLabelErrorSpan;
+/**
+ * CodeMirror email editor: click the last cm-line at a stable left-edge offset to acquire focus,
+ * wait for the editor to be focused, then press End + Enter to position the cursor on a new last line.
+ * Call this before typing a snippet into the editor.
+ *
+ * @param codeMirrorEditor   The CodeMirror content-editable div (aria-placeholder contains "Write your HTML email code here").
+ * @param codeMirrorLastLine The last `.cm-line` div inside that editor.
+ */
+async function focusEmailEditorAddNewLineAtEnd(codeMirrorEditor, codeMirrorLastLine) {
+    await codeMirrorEditor.waitForDisplayed({ timeout: 90000 });
+    await codeMirrorLastLine.waitForDisplayed({ timeout: 10000 });
+    const size = await codeMirrorLastLine.getSize();
+    const xOffset = Math.round(2 - size.width / 2);
+    await codeMirrorLastLine.click({ x: xOffset, y: 0 });
+    await browser.waitUntil(async () => {
+        const focused = await browser.execute(() => {
+            const codeMirrorEditorEl = document.querySelector('div[aria-placeholder*="Write your HTML email code here"]');
+            if (!codeMirrorEditorEl)
+                return false;
+            const active = document.activeElement;
+            const editorFocused = active === codeMirrorEditorEl || (active && codeMirrorEditorEl.contains(active));
+            const cmEditor = codeMirrorEditorEl.closest(".cm-editor");
+            const hasCmFocused = (cmEditor && cmEditor.classList.contains("cm-focused")) ||
+                (active && active.classList.contains("cm-focused"));
+            return !!(editorFocused || hasCmFocused);
+        });
+        return focused === true;
+    }, {
+        timeout: 10000,
+        timeoutMsg: "CodeMirror editor did not receive focus after clicking last line",
+        interval: 100,
+    });
+    await browser.keys(["End"]);
+    await browser.keys(["Enter"]);
+}
+exports.focusEmailEditorAddNewLineAtEnd = focusEmailEditorAddNewLineAtEnd;
+/**
+ * Inject unmatched-braces snippet, try submit (if clickable), assert via callback, then restore field.
+ * Not used for Email (CodeMirror debounce / waitUntil sequencing is bespoke).
+ */
+async function injectAndRestore(targetInput, submitButton, originalValue, assertFn) {
+    await elementUtil_1.default.enterText(targetInput, exports.UNMATCHED_BRACES_SNIPPET);
+    await elementUtil_1.default.clickIfClickable(submitButton);
+    await assertFn();
+    await elementUtil_1.default.clearByBackspace(exports.UNMATCHED_BRACES_SNIPPET, targetInput);
+    await elementUtil_1.default.typeText(targetInput, originalValue);
+}
+exports.injectAndRestore = injectAndRestore;