@sungen/driver-ui 3.2.5 → 3.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sungen/driver-ui",
-  "version": "3.2.5",
+  "version": "3.2.7",
   "description": "Sungen UI capability (Playwright) — step patterns, viewpoint gate, and phase hooks. Plugs into @sun-asterisk/sungen via the capability SPI.",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -13,7 +13,7 @@
   "author": "eqe team (engineer & quality) — Sun Asterisk",
   "license": "MIT",
   "dependencies": {
-    "@sun-asterisk/sungen": "3.2.5"
+    "@sun-asterisk/sungen": "3.2.7"
   },
   "peerDependencies": {
     "@playwright/test": "^1.57.0"

package/src/patterns/assertion-patterns.ts

@@ -1,5 +1,6 @@
 import { ParsedStep } from '@sun-asterisk/sungen';
 import { StepPattern, StepTemplateData } from '@sun-asterisk/sungen';
+import { pathToRegexSource } from '../utils/url-path-regex';
 
 /**
  * Assertion patterns: visibility, text content, state, attributes
@@ -73,7 +74,10 @@ export const assertionPatterns: StepPattern[] = [
        step.text.includes('sees')) &&
       step.elementType === 'page',
     resolver: (step, context): StepTemplateData => {
-      let path = step.featurePath || '/';
+      // Fallback is the feature's declared Path (context.featurePath) — the page under test.
+      // `step.featurePath` is never populated by the parser, so it always degraded to '/'.
+      const fallbackPath = context.featurePath || '/';
+      let path = fallbackPath;
 
       // If selector is present, extract path from selector's value attribute
       if (step.selectorRef) {
@@ -84,16 +88,20 @@ export const assertionPatterns: StepPattern[] = [
             step.elementType,
             step.nth
           );
-          // Use selector's value as the path for URL assertion
-          path = resolved.value || path;
+          // Only a `page`-type entry carries a URL in `value`. Selector keys can collide across
+          // types (a single `読取結果一覧` entry of type `role` reused for a page assertion), and a
+          // key-only lookup happily returns that button entry — whose `value` ('button') is not a
+          // URL. Guard on the entry kind: use `value` only for a page selector, else fall back to
+          // the feature path rather than compiling `toHaveURL(/button/)`.
+          path = resolved.selectorType === 'page' ? (resolved.value || fallbackPath) : fallbackPath;
         } catch (error) {
           // Fallback to feature path if selector not found
-          path = step.featurePath || '/';
+          path = fallbackPath;
         }
       }
 
-      // Convert path to regex-safe string
-      const pathRegex = path.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
+      // Convert path to regex-safe string (dynamic :id segments → [^/]+ wildcard)
+      const pathRegex = pathToRegexSource(path);
       return {
         templateName: 'page-assertion',
         data: { pathRegex },

package/src/patterns/interaction-patterns.ts

@@ -1,5 +1,6 @@
 import { ParsedStep } from '@sun-asterisk/sungen';
 import { StepPattern } from '@sun-asterisk/sungen';
+import { escapeRegex, pathToRegexSource } from '../utils/url-path-regex';
 
 /**
  * Extract Playwright waitFor state from step text.
@@ -296,14 +297,20 @@ export const interactionPatterns: StepPattern[] = [
     matcher: (step: ParsedStep) =>
       (step.text.includes('wait for') || step.text.includes('waits for')) && step.elementType === 'page',
     resolver: (step, context) => {
-      let path = step.featurePath || '/';
+      // Fallback is the feature's declared Path (context.featurePath) — `step.featurePath` is
+      // never populated by the parser, so it always degraded to '/'.
+      const fallbackPath = context.featurePath || '/';
+      let path = fallbackPath;
 
       if (step.selectorRef) {
         try {
           const resolved = context.selectorResolver.resolveSelector(
             step.selectorRef, context.featureName, step.elementType, step.nth
           );
-          path = resolved.value || path;
+          // Only a `page`-type entry carries a URL in `value`. A key collision with a non-page
+          // entry (e.g. a role/button sharing the key) must fall back to featurePath, never feed
+          // its value ('button') into waitForURL. See page-assertion for the mirror guard.
+          path = resolved.selectorType === 'page' ? (resolved.value || fallbackPath) : fallbackPath;
         } catch (error) {
           // fallback to featurePath
         }
@@ -313,11 +320,12 @@ export const interactionPatterns: StepPattern[] = [
       let pathRegex: string;
       if (isAbsoluteUrl) {
         const url = new URL(path);
-        const hostEscaped = url.hostname.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
-        const pathEscaped = url.pathname !== '/' ? url.pathname.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&') : '';
+        const hostEscaped = escapeRegex(url.hostname);
+        // Dynamic :id segments in the path → [^/]+ wildcard (host stays literal)
+        const pathEscaped = url.pathname !== '/' ? pathToRegexSource(url.pathname) : '';
         pathRegex = hostEscaped + pathEscaped;
       } else {
-        pathRegex = path.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
+        pathRegex = pathToRegexSource(path);
       }
 
       return {

package/src/utils/url-path-regex.ts

@@ -0,0 +1,31 @@
+/**
+ * URL-path → RegExp-source conversion for page URL assertions (`toHaveURL`) and
+ * navigation waits (`waitForURL`).
+ *
+ * A selector's `value` may carry dynamic route placeholders (`:id`, `:receptionId`,
+ * …), e.g. `/cn22/view/so/ocr/results/:id`. A live URL populates those segments with
+ * real values (`…/results/rec-dummy-000017`), so a fully-escaped literal pattern would
+ * never match. Placeholder segments become a single-segment wildcard (`[^/]+`); every
+ * other segment is escaped so its regex metacharacters stay literal.
+ */
+
+const REGEX_SPECIALS = /[.*+?^${}()|[\]\\/]/g;
+
+/** Escape a literal string for safe use inside a RegExp source. */
+export function escapeRegex(text: string): string {
+  return text.replace(REGEX_SPECIALS, '\\$&');
+}
+
+/**
+ * Convert a URL path into a RegExp source string, turning dynamic route
+ * placeholders (`:name`) into `[^/]+` wildcards while escaping literal segments.
+ * `/` is emitted as the escaped `\/` so the result drops straight into `/…/`.
+ */
+export function pathToRegexSource(path: string): string {
+  return path
+    .split('/')
+    .map((segment) =>
+      /^:[A-Za-z_][A-Za-z0-9_]*$/.test(segment) ? '[^/]+' : escapeRegex(segment)
+    )
+    .join('\\/');
+}