@sun-asterisk/sungen 3.2.24-beta.6 → 3.2.25

package/dist/generators/test-generator/utils/format-pattern.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Format placeholders → a regex source, for `see [T] <type> matches "<format>"`.
+ *
+ * QA specs state a label's contract as a SHAPE, not a value: "Format: yyyy/mm/dd ~ yyyy/mm/dd",
+ * "Format: 残りX個". Neither existing text assertion can express that — an exact-value assert
+ * pins data that changes daily (red while the app is right), and `contains` proves almost
+ * nothing ("abc ~ def" passes). This translator keeps the spec's own vocabulary in the Gherkin
+ * so the step reads like the requirement, and no regex reaches a file QA has to review.
+ *
+ * Tokens (everything else is a literal, regex-escaped):
+ *   yyyy → a 4-digit year          mm | dd | hh | ss → a zero-padded 2-digit part
+ *   X    → an integer, thousand separators allowed (the app renders prices as "2,800円")
+ *   *    → any run of characters, for a label that carries surrounding content
+ *
+ * A token only counts when it is not glued to an ASCII letter, so a literal English prefix
+ * survives ("Comment" keeps its "mm"; "yyyy/mm/dd" does not). Japanese/symbol literals are
+ * unaffected either way.
+ */
+/**
+ * Translate a format string into an ANCHORED regex source (no delimiters, no flags).
+ * Anchored because the spec means the whole label: "Format: X件" is not satisfied by "12件です".
+ * Use the `*` token where the label legitimately carries more (a fused mobile node).
+ */
+export declare function formatToRegexSource(format: string): string;
+/** True when the string carries at least one token — i.e. it is a FORMAT, not a plain value. */
+export declare function hasFormatToken(format: string): boolean;
+/**
+ * The same pattern as a JS **regex literal**, ready to paste into generated code.
+ *
+ * Not a string: `new RegExp('^\d{4}$')` is a trap — in a single-quoted JS literal `\d` collapses
+ * to `d`, so the compiled test would silently match the letter instead of a digit. A regex literal
+ * carries the backslashes verbatim; only `/` needs escaping, and date formats are full of them.
+ */
+export declare function formatToRegexLiteral(format: string): string;
+//# sourceMappingURL=format-pattern.d.ts.map

package/dist/generators/test-generator/utils/format-pattern.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-pattern.d.ts","sourceRoot":"","sources":["../../../../src/generators/test-generator/utils/format-pattern.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAgBH;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAwB1D;AAED,gGAAgG;AAChG,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE3D"}

package/dist/generators/test-generator/utils/format-pattern.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * Format placeholders → a regex source, for `see [T] <type> matches "<format>"`.
+ *
+ * QA specs state a label's contract as a SHAPE, not a value: "Format: yyyy/mm/dd ~ yyyy/mm/dd",
+ * "Format: 残りX個". Neither existing text assertion can express that — an exact-value assert
+ * pins data that changes daily (red while the app is right), and `contains` proves almost
+ * nothing ("abc ~ def" passes). This translator keeps the spec's own vocabulary in the Gherkin
+ * so the step reads like the requirement, and no regex reaches a file QA has to review.
+ *
+ * Tokens (everything else is a literal, regex-escaped):
+ *   yyyy → a 4-digit year          mm | dd | hh | ss → a zero-padded 2-digit part
+ *   X    → an integer, thousand separators allowed (the app renders prices as "2,800円")
+ *   *    → any run of characters, for a label that carries surrounding content
+ *
+ * A token only counts when it is not glued to an ASCII letter, so a literal English prefix
+ * survives ("Comment" keeps its "mm"; "yyyy/mm/dd" does not). Japanese/symbol literals are
+ * unaffected either way.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatToRegexSource = formatToRegexSource;
+exports.hasFormatToken = hasFormatToken;
+exports.formatToRegexLiteral = formatToRegexLiteral;
+/** Longest-first: `yyyy` must win over a bare `yy`-style prefix of another token. */
+const TOKENS = [
+    ['yyyy', '\\d{4}'],
+    ['mm', '\\d{2}'],
+    ['dd', '\\d{2}'],
+    ['hh', '\\d{2}'],
+    ['ss', '\\d{2}'],
+    ['X', '\\d+(?:,\\d{3})*'],
+    ['*', '[\\s\\S]*'],
+];
+const isAsciiLetter = (ch) => !!ch && /[A-Za-z]/.test(ch);
+const escapeLiteral = (ch) => ch.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/**
+ * Translate a format string into an ANCHORED regex source (no delimiters, no flags).
+ * Anchored because the spec means the whole label: "Format: X件" is not satisfied by "12件です".
+ * Use the `*` token where the label legitimately carries more (a fused mobile node).
+ */
+function formatToRegexSource(format) {
+    let out = '';
+    let i = 0;
+    while (i < format.length) {
+        const prev = i > 0 ? format[i - 1] : undefined;
+        let matched = false;
+        for (const [token, regex] of TOKENS) {
+            if (!format.startsWith(token, i))
+                continue;
+            // `*` is punctuation — the letter-adjacency rule protects word-like tokens only.
+            if (token !== '*') {
+                const next = format[i + token.length];
+                if (isAsciiLetter(prev) || isAsciiLetter(next))
+                    continue;
+            }
+            out += regex;
+            i += token.length;
+            matched = true;
+            break;
+        }
+        if (!matched) {
+            out += escapeLiteral(format[i]);
+            i += 1;
+        }
+    }
+    return `^${out}$`;
+}
+/** True when the string carries at least one token — i.e. it is a FORMAT, not a plain value. */
+function hasFormatToken(format) {
+    return formatToRegexSource(format) !== `^${format.split('').map(escapeLiteral).join('')}$`;
+}
+/**
+ * The same pattern as a JS **regex literal**, ready to paste into generated code.
+ *
+ * Not a string: `new RegExp('^\d{4}$')` is a trap — in a single-quoted JS literal `\d` collapses
+ * to `d`, so the compiled test would silently match the letter instead of a digit. A regex literal
+ * carries the backslashes verbatim; only `/` needs escaping, and date formats are full of them.
+ */
+function formatToRegexLiteral(format) {
+    return `/${formatToRegexSource(format).replace(/\//g, '\\/')}/`;
+}
+//# sourceMappingURL=format-pattern.js.map

package/dist/generators/test-generator/utils/format-pattern.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-pattern.js","sourceRoot":"","sources":["../../../../src/generators/test-generator/utils/format-pattern.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;GAiBG;;AAqBH,kDAwBC;AAGD,wCAEC;AASD,oDAEC;AA3DD,qFAAqF;AACrF,MAAM,MAAM,GAA4B;IACtC,CAAC,MAAM,EAAE,QAAQ,CAAC;IAClB,CAAC,IAAI,EAAE,QAAQ,CAAC;IAChB,CAAC,IAAI,EAAE,QAAQ,CAAC;IAChB,CAAC,IAAI,EAAE,QAAQ,CAAC;IAChB,CAAC,IAAI,EAAE,QAAQ,CAAC;IAChB,CAAC,GAAG,EAAE,kBAAkB,CAAC;IACzB,CAAC,GAAG,EAAE,WAAW,CAAC;CACnB,CAAC;AAEF,MAAM,aAAa,GAAG,CAAC,EAAsB,EAAW,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;AACvF,MAAM,aAAa,GAAG,CAAC,EAAU,EAAU,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC;AAExF;;;;GAIG;AACH,SAAgB,mBAAmB,CAAC,MAAc;IAChD,IAAI,GAAG,GAAG,EAAE,CAAC;IACb,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;QACzB,MAAM,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC/C,IAAI,OAAO,GAAG,KAAK,CAAC;QACpB,KAAK,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,MAAM,EAAE,CAAC;YACpC,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC,CAAC;gBAAE,SAAS;YAC3C,iFAAiF;YACjF,IAAI,KAAK,KAAK,GAAG,EAAE,CAAC;gBAClB,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;gBACtC,IAAI,aAAa,CAAC,IAAI,CAAC,IAAI,aAAa,CAAC,IAAI,CAAC;oBAAE,SAAS;YAC3D,CAAC;YACD,GAAG,IAAI,KAAK,CAAC;YACb,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC;YAClB,OAAO,GAAG,IAAI,CAAC;YACf,MAAM;QACR,CAAC;QACD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,GAAG,IAAI,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;YAChC,CAAC,IAAI,CAAC,CAAC;QACT,CAAC;IACH,CAAC;IACD,OAAO,IAAI,GAAG,GAAG,CAAC;AACpB,CAAC;AAED,gGAAgG;AAChG,SAAgB,cAAc,CAAC,MAAc;IAC3C,OAAO,mBAAmB,CAAC,MAAM,CAAC,KAAK,IAAI,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC;AAC7F,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,oBAAoB,CAAC,MAAc;IACjD,OAAO,IAAI,mBAAmB,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC;AAClE,CAAC"}

package/dist/generators/test-generator/utils/js-literal-scanner.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Minimal left-to-right lexer that segments generated JS into the four contexts a
+ * post-processor must tell apart: string/template literals, regex literals,
+ * comments, and everything else.
+ *
+ * WHY this exists instead of a regex pass per context: independent global regexes
+ * have no idea where a literal actually STARTS. `String.replace` retries at every
+ * offset, so a pattern that wants "quote … marker … quote" happily pairs the
+ * CLOSING quote of one literal with the OPENING quote of the next and rewrites the
+ * code in between. Field report (3.2.23, every version 2.0.0+):
+ *
+ *   await page.getByText('Tìm thấy').filter({ hasText: /^§marker§$/ }).waitFor({ state: 'visible' });
+ *
+ * The marker sits in a REGEX literal, but the string-literal pass matched from the
+ * `'` after `thấy` to the `'` before `visible` and emitted
+ * `getByText('Tìm thấy`)` … `state: `visible' })` — the whole .spec.ts stopped
+ * parsing. Scanning once, in order, makes that class of fault unrepresentable: a
+ * quote can only ever open a literal when the scanner is not already inside one.
+ *
+ * Deliberately NOT a full JS parser — it only needs to find literal boundaries:
+ *   - `${…}` inside a template literal is body text, not nested code (matches what
+ *     the previous passes did, and generated templates never nest a literal there).
+ *   - A `'`/`"` literal must close on its own line; an unterminated one is treated
+ *     as ordinary code so a stray apostrophe (prose in a comment) cannot desync the
+ *     rest of the file. Backticks may span lines, but an unterminated one to EOF is
+ *     likewise demoted to code.
+ *   - A `/` opens a regex only in expression position and only when it closes on the
+ *     same line. Both guards keep a division (or a stray slash) from swallowing the
+ *     literals after it.
+ */
+export type SegmentKind = 'code' | 'string' | 'regex' | 'comment';
+export interface Segment {
+    kind: SegmentKind;
+    /** Verbatim source slice, INCLUDING delimiters (quotes, slashes, `//`). */
+    text: string;
+}
+/**
+ * Split `code` into ordered segments. Concatenating every `text` reproduces the
+ * input byte for byte — callers rewrite only the segments they care about.
+ */
+export declare function scanSegments(code: string): Segment[];
+//# sourceMappingURL=js-literal-scanner.d.ts.map

package/dist/generators/test-generator/utils/js-literal-scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"js-literal-scanner.d.ts","sourceRoot":"","sources":["../../../../src/generators/test-generator/utils/js-literal-scanner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,SAAS,CAAC;AAElE,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,WAAW,CAAC;IAClB,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC;CACd;AAyCD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,EAAE,CAiDpD"}

package/dist/generators/test-generator/utils/js-literal-scanner.js

@@ -0,0 +1,142 @@
+"use strict";
+/**
+ * Minimal left-to-right lexer that segments generated JS into the four contexts a
+ * post-processor must tell apart: string/template literals, regex literals,
+ * comments, and everything else.
+ *
+ * WHY this exists instead of a regex pass per context: independent global regexes
+ * have no idea where a literal actually STARTS. `String.replace` retries at every
+ * offset, so a pattern that wants "quote … marker … quote" happily pairs the
+ * CLOSING quote of one literal with the OPENING quote of the next and rewrites the
+ * code in between. Field report (3.2.23, every version 2.0.0+):
+ *
+ *   await page.getByText('Tìm thấy').filter({ hasText: /^§marker§$/ }).waitFor({ state: 'visible' });
+ *
+ * The marker sits in a REGEX literal, but the string-literal pass matched from the
+ * `'` after `thấy` to the `'` before `visible` and emitted
+ * `getByText('Tìm thấy`)` … `state: `visible' })` — the whole .spec.ts stopped
+ * parsing. Scanning once, in order, makes that class of fault unrepresentable: a
+ * quote can only ever open a literal when the scanner is not already inside one.
+ *
+ * Deliberately NOT a full JS parser — it only needs to find literal boundaries:
+ *   - `${…}` inside a template literal is body text, not nested code (matches what
+ *     the previous passes did, and generated templates never nest a literal there).
+ *   - A `'`/`"` literal must close on its own line; an unterminated one is treated
+ *     as ordinary code so a stray apostrophe (prose in a comment) cannot desync the
+ *     rest of the file. Backticks may span lines, but an unterminated one to EOF is
+ *     likewise demoted to code.
+ *   - A `/` opens a regex only in expression position and only when it closes on the
+ *     same line. Both guards keep a division (or a stray slash) from swallowing the
+ *     literals after it.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanSegments = scanSegments;
+/** Chars that, immediately before a `/`, make it division or a member access — never a regex. */
+const NOT_REGEX_PREFIX = /[\w$)\]]/;
+const REGEX_FLAGS = /[dgimsuvy]/;
+/** Index just past the closing quote, or -1 when the literal never closes (see module note). */
+function scanQuoted(code, start, quote) {
+    const spansLines = quote === '`';
+    for (let i = start + 1; i < code.length; i++) {
+        const c = code[i];
+        if (c === '\\') {
+            i++;
+            continue;
+        }
+        if (c === quote)
+            return i + 1;
+        if (c === '\n' && !spansLines)
+            return -1;
+    }
+    return -1;
+}
+/** Index just past the regex's flags, or -1 when it is not a single-line regex literal. */
+function scanRegex(code, start) {
+    // Expression-position guard: skip back over spaces/tabs to the last significant char.
+    let p = start - 1;
+    while (p >= 0 && (code[p] === ' ' || code[p] === '\t'))
+        p--;
+    if (p >= 0 && NOT_REGEX_PREFIX.test(code[p]))
+        return -1;
+    let inClass = false;
+    for (let i = start + 1; i < code.length; i++) {
+        const c = code[i];
+        if (c === '\n')
+            return -1;
+        if (c === '\\') {
+            i++;
+            continue;
+        }
+        if (inClass) {
+            if (c === ']')
+                inClass = false;
+            continue;
+        }
+        if (c === '[') {
+            inClass = true;
+            continue;
+        }
+        if (c === '/') {
+            let j = i + 1;
+            while (j < code.length && REGEX_FLAGS.test(code[j]))
+                j++;
+            return j;
+        }
+    }
+    return -1;
+}
+/**
+ * Split `code` into ordered segments. Concatenating every `text` reproduces the
+ * input byte for byte — callers rewrite only the segments they care about.
+ */
+function scanSegments(code) {
+    const out = [];
+    let codeStart = 0;
+    let i = 0;
+    const flushCode = (end) => {
+        if (end > codeStart)
+            out.push({ kind: 'code', text: code.slice(codeStart, end) });
+    };
+    const take = (kind, end) => {
+        flushCode(i);
+        out.push({ kind, text: code.slice(i, end) });
+        i = codeStart = end;
+    };
+    while (i < code.length) {
+        const c = code[i];
+        // Comments first: a `//` or `/*` reached in code position can never be a regex,
+        // and consuming them keeps an apostrophe in prose from opening a literal.
+        if (c === '/' && code[i + 1] === '/') {
+            const nl = code.indexOf('\n', i);
+            take('comment', nl === -1 ? code.length : nl);
+            continue;
+        }
+        if (c === '/' && code[i + 1] === '*') {
+            const close = code.indexOf('*/', i + 2);
+            take('comment', close === -1 ? code.length : close + 2);
+            continue;
+        }
+        if (c === '\'' || c === '"' || c === '`') {
+            const end = scanQuoted(code, i, c);
+            if (end !== -1) {
+                take('string', end);
+                continue;
+            }
+            i++; // unterminated → ordinary code
+            continue;
+        }
+        if (c === '/') {
+            const end = scanRegex(code, i);
+            if (end !== -1) {
+                take('regex', end);
+                continue;
+            }
+            i++; // division or stray slash → ordinary code
+            continue;
+        }
+        i++;
+    }
+    flushCode(code.length);
+    return out;
+}
+//# sourceMappingURL=js-literal-scanner.js.map

package/dist/generators/test-generator/utils/js-literal-scanner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"js-literal-scanner.js","sourceRoot":"","sources":["../../../../src/generators/test-generator/utils/js-literal-scanner.ts"],"names":[],"mappings":"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"}

package/dist/generators/test-generator/utils/mask-refs-for-matching.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Mask the CONTENT of selector refs `[...]` and data placeholders `{{...}}` before verb matching,
+ * keeping the delimiters. A step's verb/keywords come from the SENTENCE — never from a selector or
+ * variable NAME — but matchers scan `step.text` with substring checks (e.g. `includes('click')`),
+ * so a data ref like `{{double_click_guard_account.email}}` would spuriously satisfy the click
+ * matcher and pre-empt fill. The content is replaced with an inert placeholder (`~` — carries no
+ * verb/keyword/digit substring) rather than emptied, so structural matchers that require a NON-EMPTY
+ * ref survive too — e.g. `expect {{a}} is {{b}}` matches `\{\{[^}]+\}\}`, and `in [X] table` /
+ * `/\bto\s+\[/` keep their delimiters. The resolver/generator always receives the ORIGINAL step, so
+ * value extraction and codegen are unaffected.
+ *
+ * Lives in `utils/` rather than in `patterns/index.ts` so the Gherkin parser can reuse it for
+ * state-clause extraction (SG-E021) without importing the pattern registry — which would pull the
+ * whole capability graph into the parser and close a require cycle. `patterns/index.ts` re-exports
+ * it, so its historical import path still resolves.
+ */
+export declare function maskRefsForMatching(text: string): string;
+//# sourceMappingURL=mask-refs-for-matching.d.ts.map

package/dist/generators/test-generator/utils/mask-refs-for-matching.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mask-refs-for-matching.d.ts","sourceRoot":"","sources":["../../../../src/generators/test-generator/utils/mask-refs-for-matching.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAIxD"}

package/dist/generators/test-generator/utils/mask-refs-for-matching.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maskRefsForMatching = maskRefsForMatching;
+/**
+ * Mask the CONTENT of selector refs `[...]` and data placeholders `{{...}}` before verb matching,
+ * keeping the delimiters. A step's verb/keywords come from the SENTENCE — never from a selector or
+ * variable NAME — but matchers scan `step.text` with substring checks (e.g. `includes('click')`),
+ * so a data ref like `{{double_click_guard_account.email}}` would spuriously satisfy the click
+ * matcher and pre-empt fill. The content is replaced with an inert placeholder (`~` — carries no
+ * verb/keyword/digit substring) rather than emptied, so structural matchers that require a NON-EMPTY
+ * ref survive too — e.g. `expect {{a}} is {{b}}` matches `\{\{[^}]+\}\}`, and `in [X] table` /
+ * `/\bto\s+\[/` keep their delimiters. The resolver/generator always receives the ORIGINAL step, so
+ * value extraction and codegen are unaffected.
+ *
+ * Lives in `utils/` rather than in `patterns/index.ts` so the Gherkin parser can reuse it for
+ * state-clause extraction (SG-E021) without importing the pattern registry — which would pull the
+ * whole capability graph into the parser and close a require cycle. `patterns/index.ts` re-exports
+ * it, so its historical import path still resolves.
+ */
+function maskRefsForMatching(text) {
+    return text
+        .replace(/\{\{[^}]*\}\}/g, '{{~}}')
+        .replace(/\[[^\]]*\]/g, '[~]');
+}
+//# sourceMappingURL=mask-refs-for-matching.js.map

package/dist/generators/test-generator/utils/mask-refs-for-matching.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mask-refs-for-matching.js","sourceRoot":"","sources":["../../../../src/generators/test-generator/utils/mask-refs-for-matching.ts"],"names":[],"mappings":";;AAgBA,kDAIC;AApBD;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,mBAAmB,CAAC,IAAY;IAC9C,OAAO,IAAI;SACR,OAAO,CAAC,gBAAgB,EAAE,OAAO,CAAC;SAClC,OAAO,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;AACnC,CAAC"}

package/dist/generators/test-generator/utils/runtime-data-transformer.d.ts

@@ -1,6 +1,14 @@
 /**
  * Replace __SUNGEN_TD$…$__ markers with testData.get() calls in generated code.
- * Four passes: comments, string literals, regex literals, then bare identifiers.
+ *
+ * The code is scanned ONCE into literal/regex/comment/code segments and each
+ * segment is rewritten for the context it is actually in. This replaced four
+ * independent global-regex passes whose ordering was the defect: the string pass
+ * ran first and, finding no marker inside a genuine literal, re-matched from that
+ * literal's CLOSING quote — pairing it with the OPENING quote of the next literal
+ * and rewriting the regex literal between them into a broken backtick template
+ * (`getByText('Tìm thấy`)` … `state: `visible' })`, a .spec.ts that would not
+ * parse at all). See js-literal-scanner.ts for the full field report.
  */
 export declare function transformToRuntimeData(code: string, accessor?: string): string;
 export declare function hasRuntimeDataMarkers(code: string): boolean;

package/dist/generators/test-generator/utils/runtime-data-transformer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-data-transformer.d.ts","sourceRoot":"","sources":["../../../../src/generators/test-generator/utils/runtime-data-transformer.ts"],"names":[],"mappings":"AAoDA;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAmB,GAAG,MAAM,CAwD1F;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE3D"}
+{"version":3,"file":"runtime-data-transformer.d.ts","sourceRoot":"","sources":["../../../../src/generators/test-generator/utils/runtime-data-transformer.ts"],"names":[],"mappings":"AA0CA;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAmB,GAAG,MAAM,CAG1F;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE3D"}

package/dist/generators/test-generator/utils/runtime-data-transformer.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformToRuntimeData = transformToRuntimeData;
 exports.hasRuntimeDataMarkers = hasRuntimeDataMarkers;
+const js_literal_scanner_1 = require("./js-literal-scanner");
 /**
  * Wire format of a runtime test-data marker: `__SUNGEN_TD$<key>$__`.
  *
@@ -18,12 +19,12 @@ exports.hasRuntimeDataMarkers = hasRuntimeDataMarkers;
  * swallowed one `_` of the `___` run and decoding produced `get('code_')` plus
  * a detached `ACCESS_TOKEN`. `$` is also identifier-safe — the whole marker
  * still parses as ONE bare JS token, so it survives the bare-identifier
- * (numeric) positions Pass 3 handles.
+ * (numeric) positions the code context handles.
  *
- * Single source of truth: every pass and every whole-literal probe below is
- * built from these constants. Invariant: every marker producer goes through
- * DataResolver.encodeMarker and every consumer through this module — a
- * drifting hand-copied char class is what let the suffix bug hide.
+ * Single source of truth: every context below is built from these constants.
+ * Invariant: every marker producer goes through DataResolver.encodeMarker and
+ * every consumer through this module — a drifting hand-copied char class is what
+ * let the suffix bug hide.
  */
 const MARKER_KEY = '[A-Za-z0-9_-]+';
 // Templates that embed a value into a regex literal run it through the escapeRegex
@@ -31,82 +32,142 @@ const MARKER_KEY = '[A-Za-z0-9_-]+';
 // arrive here spelled `__SUNGEN_TD\$key\$__`. `\\\\?` accepts that optional backslash
 // before each delimiter; the replacement consumes it, so no escape leaks to output.
 const DELIM = '\\\\?\\$';
-/** Marker with no capture group — for "contains a marker" positions inside bigger regexes. */
+/** Marker with no capture group — for "contains a marker" probes. */
 const MARKER = `__SUNGEN_TD${DELIM}${MARKER_KEY}${DELIM}__`;
 /** Marker capturing the encoded key. */
 const MARKER_CAP = `__SUNGEN_TD${DELIM}(${MARKER_KEY})${DELIM}__`;
 const MARKER_PATTERN = new RegExp(MARKER);
-// Pass 0: full-line // comments carrying a marker (anchored — see pass comment).
-const RE_COMMENT_LINE = new RegExp(`^(\\s*)\\/\\/(.*)${MARKER_CAP}(.*)$`, 'gm');
-// Pass 1: a quoted string literal containing at least one marker. Covers ', " and
-// backtick containers; `\\.` lets an ESCAPED quote (`'it\'s {{x}}'`) sit inside the
-// body instead of terminating the literal early. The single-char branch excludes `\`
-// so every backslash is consumed by exactly ONE branch — an ambiguous `(?!\1).`
-// alternative enumerates 2^n segmentations when a marker-less escape-heavy literal
-// (escapeQuotes output: multi-line Flutter content-desc) fails to match, hanging
-// the generate run. `\n` exclusion just makes the dot's no-newline behavior explicit.
-const RE_STRING_LITERAL = new RegExp('([\'"`])((?:\\\\.|(?!\\1)[^\\\\\\n])*?' + MARKER + '(?:\\\\.|(?!\\1)[^\\\\\\n])*)\\1', 'g');
-// Pass 2: a single-line regex literal containing at least one marker.
-const RE_REGEX_LITERAL = new RegExp(`\\/((?:[^/\\\\\\n]|\\\\.)*?${MARKER}(?:[^/\\\\\\n]|\\\\.)*)\\/([gimsuy]*)`, 'g');
-// Whole-literal probe: the body is EXACTLY one marker (bare accessor call, no template).
+/** Whole-literal probe: the body is EXACTLY one marker (bare accessor call, no template). */
 const RE_WHOLE_MARKER = new RegExp(`^${MARKER_CAP}$`);
-// Every marker occurrence, capturing the key (Pass 3 + interpolation).
+/** Every marker occurrence, capturing the key. */
 const RE_MARKER_G = new RegExp(MARKER_CAP, 'g');
 /**
  * Replace __SUNGEN_TD$…$__ markers with testData.get() calls in generated code.
- * Four passes: comments, string literals, regex literals, then bare identifiers.
+ *
+ * The code is scanned ONCE into literal/regex/comment/code segments and each
+ * segment is rewritten for the context it is actually in. This replaced four
+ * independent global-regex passes whose ordering was the defect: the string pass
+ * ran first and, finding no marker inside a genuine literal, re-matched from that
+ * literal's CLOSING quote — pairing it with the OPENING quote of the next literal
+ * and rewriting the regex literal between them into a broken backtick template
+ * (`getByText('Tìm thấy`)` … `state: `visible' })`, a .spec.ts that would not
+ * parse at all). See js-literal-scanner.ts for the full field report.
  */
 function transformToRuntimeData(code, accessor = 'testData') {
-    // Pass 0: Comments — replace markers in // comments with decoded key name.
-    // Prevents Pass 2 from misinterpreting // comment markers as regex delimiters.
-    // ANCHORED to line start (^\s*//) so a `//` INSIDE a string literal on a code line
-    // — e.g. a URL `https://careerforum.aki-inc.jp/` in a selector name — is NOT mistaken
-    // for a comment. Before this anchor, such a URL preceding a marker on the same line
-    // made Pass 0 strip the marker to its bare key, so Pass 1 never wrapped it in
-    // testData.get() (silent: `toHaveAttribute('href', 'official_site_url')`). Generated
-    // comments are always full-line, so anchoring loses nothing.
-    code = code.replace(RE_COMMENT_LINE, (_, indent, before, enc, after) => `${indent}//${before}${decodeKey(enc)}${after}`);
-    // Pass 1: String literal context — a literal may carry SEVERAL markers
-    // ('/{{code}}/car-search?{{prefill}}' compiles to two markers in ONE literal).
-    // Match the whole quoted literal that contains at least one marker, then
-    // interpolate EVERY marker inside it. The old shape (one marker + lazy
-    // prefix/suffix) swallowed trailing markers into its suffix verbatim; they
-    // escaped the quote context (the literal had become a backtick template) and
-    // Pass 3's numeric catch-all emitted them as literal
-    // `Number(testData.get(...))` TEXT inside the template — a compiling spec
-    // navigating to a garbage URL.
-    // 'marker'          → testData.get('key')
-    // 'a__m1__b__m2__c' → `a${testData.get('k1')}b${testData.get('k2')}c`
-    code = code.replace(RE_STRING_LITERAL, (_, _quote, body) => {
-        const whole = RE_WHOLE_MARKER.exec(body);
-        if (whole)
-            return `${accessor}.get('${decodeKey(whole[1])}')`;
-        return `\`${interpolateMarkers(body, accessor)}\``;
-    });
-    // Pass 2: Regex literal context — /…$marker$…/ → new RegExp(`…`). Same
-    // several-markers-per-literal rule as Pass 1 (/{{min}}-{{max}} items/).
-    // Only matches within a single line (no newlines in the body).
-    code = code.replace(RE_REGEX_LITERAL, (_, body, flags) => {
-        const flagStr = flags ? `, '${flags}'` : '';
-        const whole = RE_WHOLE_MARKER.exec(body);
-        if (whole)
-            return `new RegExp(${accessor}.get('${decodeKey(whole[1])}')${flagStr})`;
-        return `new RegExp(\`${interpolateMarkers(body, accessor)}\`${flagStr})`;
-    });
-    // Pass 3: Bare-identifier context — any marker left after the string/regex passes
-    // sits as a bare token in a numeric position (e.g. `toHaveCount(__marker__)` from the
-    // table/list count templates). testData.get() returns a string, so coerce with Number().
-    code = code.replace(RE_MARKER_G, (_, enc) => `Number(${accessor}.get('${decodeKey(enc)}'))`);
-    return code;
+    if (!MARKER_PATTERN.test(code))
+        return code;
+    return (0, js_literal_scanner_1.scanSegments)(code).map((seg) => transformSegment(seg, accessor)).join('');
 }
 function hasRuntimeDataMarkers(code) {
     return MARKER_PATTERN.test(code);
 }
+function transformSegment(seg, accessor) {
+    if (!MARKER_PATTERN.test(seg.text))
+        return seg.text;
+    switch (seg.kind) {
+        // Decode to the plain key: a marker in a comment documents the ref, it is not code.
+        case 'comment':
+            return seg.text.replace(RE_MARKER_G, (_, enc) => decodeKey(enc));
+        case 'string':
+            return transformStringLiteral(seg.text, accessor);
+        case 'regex':
+            return transformRegexLiteral(seg.text, accessor);
+        // Bare-token position (e.g. `toHaveCount(__marker__)` from the table/list count
+        // templates). testData.get() returns a string, so coerce with Number().
+        case 'code':
+            return seg.text.replace(RE_MARKER_G, (_, enc) => `Number(${accessor}.get('${decodeKey(enc)}'))`);
+    }
+}
+/**
+ * 'marker'          → testData.get('key')
+ * 'a__m1__b__m2__c' → `a${testData.get('k1')}b${testData.get('k2')}c`
+ *
+ * A literal may carry SEVERAL markers ('/{{code}}/car-search?{{prefill}}' compiles
+ * to two markers in ONE literal), so every marker inside it is interpolated.
+ */
+function transformStringLiteral(text, accessor) {
+    const quote = text[0];
+    const body = text.slice(1, -1);
+    const whole = RE_WHOLE_MARKER.exec(body);
+    if (whole)
+        return `${accessor}.get('${decodeKey(whole[1])}')`;
+    return `\`${interpolateMarkers(escapeForTemplate(body, quote === '`'), accessor)}\``;
+}
+/**
+ * /…$marker$…/flags → new RegExp(`…`, 'flags'). Same several-markers rule as above.
+ *
+ * Two regex-only twists on top of the string path:
+ * - The runtime VALUE is literal text (test-data holds data, not patterns), so every
+ *   accessor is wrapped in the runtime escapeRegExp helper — a value containing
+ *   `( [ $ . * +` must not throw a SyntaxError or silently widen the match. The helper
+ *   lives in the synced specs/regex-escape.ts; the generator imports it when the
+ *   transformed body references it. Templates that intend PATTERN semantics (attribute
+ *   `pattern:`) emit a string container instead of a regex literal, so they skip this.
+ * - Marker-less SEGMENTS get their backslashes doubled for the template context: regex
+ *   source text like a hand-written `\s*` (or escapeRegex output `\)`) means one thing
+ *   in a /…/ literal but loses its backslash when the template cooks one escape level —
+ *   the constructed RegExp would read `s*` / a bare `)`. Segments are escaped AFTER the
+ *   markers are cut out, so an escapeRegex-spelled marker delimiter (`\$`) is never
+ *   double-escaped into something the marker regex can no longer see.
+ */
+function transformRegexLiteral(text, accessor) {
+    // Flags never contain `/`, so the last slash always closes the pattern.
+    const close = text.lastIndexOf('/');
+    const body = text.slice(1, close);
+    const flags = text.slice(close + 1);
+    const flagStr = flags ? `, '${flags}'` : '';
+    const whole = RE_WHOLE_MARKER.exec(body);
+    if (whole)
+        return `new RegExp(escapeRegExp(${accessor}.get('${decodeKey(whole[1])}'))${flagStr})`;
+    return `new RegExp(\`${interpolateMarkersInRegexBody(body, accessor)}\`${flagStr})`;
+}
 function decodeKey(encoded) {
     return encoded.replace(/_D_/g, '.');
 }
-/** Replace every marker in a literal's body with a `${accessor.get('key')}` interpolation. */
+/** Replace every marker in a body with a `${accessor.get('key')}` interpolation. */
 function interpolateMarkers(body, accessor) {
     return body.replace(RE_MARKER_G, (_, enc) => `\${${accessor}.get('${decodeKey(enc)}')}`);
 }
+/**
+ * Regex-body variant: markers are cut out FIRST, each accessor is wrapped in the
+ * runtime escapeRegExp helper, and only the marker-less segments between them are
+ * re-escaped for the template context (backslashes doubled, backtick/`${` neutralized).
+ */
+function interpolateMarkersInRegexBody(body, accessor) {
+    let out = '';
+    let last = 0;
+    for (const m of body.matchAll(RE_MARKER_G)) {
+        out += escapeRegexSegmentForTemplate(body.slice(last, m.index)) +
+            `\${escapeRegExp(${accessor}.get('${decodeKey(m[1])}'))}`;
+        last = m.index + m[0].length;
+    }
+    return out + escapeRegexSegmentForTemplate(body.slice(last));
+}
+/**
+ * Regex pattern text moving into a template literal: the template layer cooks one
+ * level of escapes BEFORE RegExp ever sees the string, so `\)` arrives as a bare `)`
+ * (SyntaxError: unmatched paren) and `\.` as a match-anything dot. Double the
+ * backslashes and neutralize the template's own metacharacters so the constructed
+ * RegExp source equals the original pattern text.
+ */
+const escapeRegexSegmentForTemplate = (segment) => segment.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$\{/g, '\\${');
+/**
+ * Both rewrites move a body into a backtick template, where a raw backtick or `${`
+ * would be read as syntax rather than text — a `'…'` selector value or a regex
+ * pattern is allowed to contain either (escapeQuotes/escapeRegex escape neither).
+ * Escape before interpolating so the `${…}` this module inserts is the only live one.
+ * An already-backtick container needs no pass: its body was valid template text.
+ *
+ * PRECONDITION: the body must already have its backslashes DOUBLED — which every caller
+ * satisfies, because every dynamic value reaches a literal through escapeQuotes or
+ * escapeRegex (template-engine.ts) and both double `\` before anything else. An unpaired
+ * backslash immediately before a backtick would make the pass below emit `\\\``, i.e. an
+ * escaped backslash followed by a LIVE backtick, ending the template early. If you
+ * hand-write a backslash into a .hbs template, keep it paired.
+ */
+function escapeForTemplate(body, alreadyTemplate) {
+    if (alreadyTemplate)
+        return body;
+    return body.replace(/`/g, '\\`').replace(/\$\{/g, '\\${');
+}
 //# sourceMappingURL=runtime-data-transformer.js.map