pw-core 1.1.0 → 1.2.1

package/dist/page/types/validation.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Extracts placeholder names from a `{name}` pattern string.
+ */
+export type ExtractPlaceholders<S extends string> = S extends `${string}{${infer Name}}${infer Rest}` ? Name | ExtractPlaceholders<Rest> : never;
+/**
+ * Checks recursively if a pattern string contains duplicate placeholders.
+ */
+export type HasDuplicatePlaceholders<S extends string, Seen extends string = never> = S extends `${string}{${infer Name}}${infer Rest}` ? Name extends Seen ? true : HasDuplicatePlaceholders<Rest, Seen | Name> : false;
+/**
+ * Returns the subset of `Placeholders` whose names are NOT found as
+ * substrings of `TestId`. Evaluates to `never` when all are present.
+ */
+export type MissingInTestId<TestId extends string, Placeholders extends string> = Placeholders extends any ? TestId extends `${string}${Placeholders}${string}` ? never : Placeholders : never;
+/**
+ * Validates a dynamic entry by mapping each of its properties to their expected types.
+ *
+ * By checking properties individually, TypeScript reports the error exactly on the offending line
+ * (e.g. on the wrong value or unknown key) instead of marking the entire object as invalid.
+ */
+export type ValidateDynamicEntryProperties<Pattern extends string, Entry, TargetKey extends 'testId' | 'selector'> = {
+    [Key in keyof Entry | ExtractPlaceholders<Pattern> | TargetKey]: Key extends TargetKey ? Entry extends Record<TargetKey, infer TPat> ? TPat extends string ? [MissingInTestId<TPat, ExtractPlaceholders<Pattern>>] extends [never] ? [Exclude<ExtractPlaceholders<TPat>, ExtractPlaceholders<Pattern>>] extends [never] ? string : {
+        [P in `Error: ${TargetKey} contains unknown placeholder(s): ${Exclude<ExtractPlaceholders<TPat>, ExtractPlaceholders<Pattern>> & string}`]: never;
+    } : {
+        [P in `Error: ${TargetKey} must contain all placeholder names: missing ${MissingInTestId<TPat, ExtractPlaceholders<Pattern>> & string}`]: never;
+    } : {
+        [P in `Error: ${TargetKey} must be a string`]: never;
+    } : {
+        [P in `Error: Dynamic entry must include a ${TargetKey} property`]: never;
+    } : Key extends ExtractPlaceholders<Pattern> ? Key extends keyof Entry ? Entry[Key] extends readonly string[] ? readonly string[] : {
+        [P in `Error: Placeholder key must be an array: ${Key & string}`]: never;
+    } : {
+        [P in `Error: Missing placeholder key: ${Key & string}`]: never;
+    } : {
+        [P in `Error: Only placeholder keys and '${TargetKey}' are allowed`]: never;
+    };
+};
+/**
+ * Replaces every `{Name}` placeholder in `Pattern` with `Capitalize<Value>`
+ * where `Value` is drawn from the corresponding array in `Entry`.
+ * Template-literal unions distribute automatically, producing the full cartesian product.
+ */
+export type ReplacePattern<Pattern extends string, Entry> = Pattern extends `${infer Before}{${infer Name}}${infer After}` ? Name extends keyof Entry ? Entry[Name] extends readonly string[] ? `${Before}${Capitalize<Entry[Name][number]>}${ReplacePattern<After, Entry> & string}` : never : never : Pattern;
+/**
+ * Expands a dynamic key pattern into the union of all concrete (camelCased) keys.
+ */
+export type ExpandDynamicKey<Pattern extends string, Entry> = Uncapitalize<ReplacePattern<Pattern, Entry>>;
+/**
+ * Resolves every key in a testIds record:
+ * - string values → the key itself (static locator)
+ * - object values → the expanded dynamic key union
+ */
+export type ResolvedTestIdKeys<I> = {
+    [K in keyof I & string]: I[K] extends string ? K : ExpandDynamicKey<K, I[K]>;
+}[keyof I & string];
+export type AllExpandedTestIdKeys<I> = {
+    [P in keyof I & string]: I[P] extends string ? P : ExpandDynamicKey<P, I[P]>;
+}[keyof I & string];
+export type AllOtherExpandedTestIdKeys<I, K extends keyof I> = {
+    [P in Exclude<keyof I, K> & string]: I[P] extends string ? P : ExpandDynamicKey<P, I[P]>;
+}[Exclude<keyof I, K> & string];
+export type ValidateTestIds<I, TargetKey extends 'testId' | 'selector', S> = {
+    [K in keyof I & string]: I[K] extends string ? K extends AllOtherExpandedTestIdKeys<I, K> | AllExpandedTestIdKeys<S> ? {
+        [P in `Error: Duplicate key "${K}" is defined in multiple entries`]: never;
+    } : string : ExpandDynamicKey<K, I[K]> & (AllOtherExpandedTestIdKeys<I, K> | AllExpandedTestIdKeys<S>) extends never ? K extends `${string}{${string}}${string}` ? HasDuplicatePlaceholders<K> extends true ? {
+        [P in 'Error: Pattern contains duplicate placeholders']: never;
+    } : ValidateDynamicEntryProperties<K, I[K], TargetKey> : I[K] : {
+        [P in `Error: Dynamic locator "${K}" expands to duplicate key(s): ${ExpandDynamicKey<K, I[K]> & (AllOtherExpandedTestIdKeys<I, K> | AllExpandedTestIdKeys<S>) & string}`]: never;
+    };
+};

package/dist/page/types/validation.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/page/utils/caller-location.d.ts

@@ -0,0 +1,5 @@
+export declare function getCallerLocation(): {
+    file: string;
+    line: number;
+    column: number;
+} | undefined;

package/dist/page/utils/caller-location.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCallerLocation = getCallerLocation;
+// Global stack trace filter to remove pw-core internal frames from all error stacks.
+// This ensures that Playwright's auto-generated steps and expectations are attributed
+// directly to the user's project files instead of showing internal pw-core library paths.
+const originalPrepare = Error.prepareStackTrace;
+Error.prepareStackTrace = (err, stack) => {
+    const filteredStack = stack.filter((frame) => {
+        const file = frame.getFileName();
+        if (!file)
+            return true;
+        const normalized = file.replace(/\\/g, '/');
+        if (normalized.includes('pw-core/src') ||
+            normalized.includes('pw-core/dist') ||
+            normalized.includes('node_modules/pw-core')) {
+            return false;
+        }
+        return true;
+    });
+    if (originalPrepare) {
+        try {
+            return originalPrepare(err, filteredStack);
+        }
+        catch {
+            // Fallback if originalPrepare fails on filtered stack
+        }
+    }
+    const errString = err.toString ? err.toString() : String(err);
+    return (errString +
+        '\n' +
+        filteredStack
+            .map((frame) => {
+            try {
+                return '    at ' + frame.toString();
+            }
+            catch {
+                return '    at <unknown>';
+            }
+        })
+            .join('\n'));
+};
+function getCallerLocation() {
+    const originalPrepareStackTrace = Error.prepareStackTrace;
+    try {
+        const err = {};
+        Error.prepareStackTrace = (_err, stack) => stack;
+        Error.captureStackTrace(err);
+        const stack = err.stack;
+        if (!stack)
+            return undefined;
+        for (let i = 1; i < stack.length; i++) {
+            const frame = stack[i];
+            const file = frame.getFileName();
+            if (!file)
+                continue;
+            const normalizedFile = file.replace(/\\/g, '/');
+            // Skip internal node_modules, node built-ins, and pw-core source/dist files
+            if (normalizedFile.includes('node_modules') ||
+                normalizedFile.includes('pw-core/src') ||
+                normalizedFile.includes('pw-core/dist') ||
+                normalizedFile.includes('playwright/lib') ||
+                normalizedFile.includes('@playwright') ||
+                normalizedFile.startsWith('node:') ||
+                !normalizedFile.includes('/')) {
+                continue;
+            }
+            const line = frame.getLineNumber();
+            const column = frame.getColumnNumber();
+            if (!line)
+                continue;
+            return { file, line, column: column ?? 1 };
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        Error.prepareStackTrace = originalPrepareStackTrace;
+    }
+}

package/dist/page/utils/formatter.js

@@ -15,7 +15,14 @@ function formatStepDescription(methodName, target, args) {
     const targetStr = formatTarget(target);
     if (methodName === 'fill' && args[0] !== undefined) {
         const options = args[1];
-        const shouldMask = !(options && typeof options === 'object' && options.mask === false);
+        let shouldMask = false;
+        if (options && typeof options === 'object' && options.mask !== undefined) {
+            shouldMask = options.mask === true;
+        }
+        else {
+            const targetStrLower = targetStr.toLowerCase();
+            shouldMask = targetStrLower.includes('pass') || targetStrLower.includes('pw');
+        }
         const displayValue = shouldMask ? '*'.repeat(String(args[0]).length) : args[0];
         return `Fill "${targetStr}" with "${displayValue}"`;
     }
@@ -30,7 +37,10 @@ function formatStepDescription(methodName, target, args) {
     if (methodName === 'uncheck')
         return `Uncheck "${targetStr}"`;
     const formattedMethod = methodName.charAt(0).toUpperCase() + methodName.slice(1);
-    const cleanArgs = args.filter(a => typeof a === 'string' || typeof a === 'number').map(a => `"${a}"`).join(', ');
+    const cleanArgs = args
+        .filter((a) => typeof a === 'string' || typeof a === 'number')
+        .map((a) => `"${a}"`)
+        .join(', ');
     return `${formattedMethod} "${targetStr}"${cleanArgs ? ' with ' + cleanArgs : ''}`;
 }
 function formatAssertionDescription(target, matcherName, isNegated, args) {
@@ -42,8 +52,8 @@ function formatAssertionDescription(target, matcherName, isNegated, args) {
         toBeEnabled: isNegated ? 'is not enabled' : 'is enabled',
         toBeDisabled: isNegated ? 'is not disabled' : 'is disabled',
         toBeChecked: isNegated ? 'is not checked' : 'is checked',
-        toHaveText: (isNegated ? 'does not have text "' : 'has text "') + args.map(a => String(a)).join(', ') + '"',
-        toContainText: (isNegated ? 'does not contain "' : 'contains "') + args.map(a => String(a)).join(', ') + '"',
+        toHaveText: (isNegated ? 'does not have text "' : 'has text "') + args.map((a) => String(a)).join(', ') + '"',
+        toContainText: (isNegated ? 'does not contain "' : 'contains "') + args.map((a) => String(a)).join(', ') + '"',
         toHaveCount: (isNegated ? 'does not have count of "' : 'has count of "') + args[0] + '"'
     };
     return `${prefix} ${matcherMap[matcherName] || `${isNegated ? 'not ' : ''}${matcherName}`}`;

package/dist/types/methods.d.ts

@@ -0,0 +1,4 @@
+import { zeroArgMethodsList, oneArgMethodsList } from '../constants/methods';
+export type AllowedZeroArgMethods = (typeof zeroArgMethodsList)[number];
+export type AllowedOneArgMethods = (typeof oneArgMethodsList)[number];
+export type AllowedMethodKeys = AllowedZeroArgMethods | AllowedOneArgMethods;

package/dist/types/methods.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/strategies.d.ts

@@ -0,0 +1,17 @@
+import { rolesList, strategyList } from '../constants/strategies';
+export type RoleType = (typeof rolesList)[number];
+export type StrategyType = (typeof strategyList)[number];
+export type PlaywrightRoleOptions = {
+    exact?: boolean;
+    checked?: boolean;
+    disabled?: boolean;
+    expanded?: boolean;
+    includeHidden?: boolean;
+    level?: number;
+    pressed?: boolean;
+    selected?: boolean;
+};
+export type PlaywrightTextOptions = {
+    exact?: boolean;
+};
+export type LocatorStrategyOptions<S extends string> = S extends RoleType ? PlaywrightRoleOptions : S extends 'text' | 'label' | 'title' | 'placeholder' | 'altText' ? PlaywrightTextOptions : {};

package/dist/types/strategies.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pw-core",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "workspaces": [
     "examples",
     "create-pw-core"
@@ -23,6 +23,9 @@
     "typescript"
   ],
   "main": "./dist/index.js",
+  "bin": {
+    "pw-core": "./dist/cli.js"
+  },
   "types": "./dist/index.d.ts",
   "files": [
     "dist",
@@ -58,10 +61,14 @@
   "devDependencies": {
     "@playwright/test": "^1.61.0",
     "@types/node": "^20.11.0",
+    "prettier": "^3.9.4",
     "rimraf": "^6.0.1",
     "typescript": "^5.3.3"
   },
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "playwright-core": "^1.61.1"
   }
 }