playwright-cucumber-ts-steps 1.3.2 → 1.3.4

package/dist/backend/utils/fixtures.js

@@ -1,38 +1,260 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.setFixtureConfig = setFixtureConfig;
+exports.resolveEnvVariable = resolveEnvVariable;
 exports.loadFixture = loadFixture;
 exports.getFixtureValue = getFixtureValue;
+exports.resolveAliasInValue = resolveAliasInValue;
 //src/backend/utils/fixtures.ts
 const fs_1 = require("fs");
 const path_1 = require("path");
+const dotenv_1 = __importDefault(require("dotenv"));
+/**
+ * Global fixture configuration.
+ * Can be overridden via setFixtureConfig() from playwright.config.ts
+ */
+let fixtureConfig = {
+    projectRoot: undefined,
+    fixturesDir: "fixtures",
+};
+/**
+ * Cached environment variables loaded from .env file
+ */
+let envVariables = {};
+/**
+ * Sets the fixture configuration from playwright.config.ts
+ * @param config - The fixture configuration object
+ */
+function setFixtureConfig(config) {
+    if (config.projectRoot) {
+        fixtureConfig.projectRoot = config.projectRoot;
+    }
+    if (config.fixturesDir) {
+        fixtureConfig.fixturesDir = config.fixturesDir;
+    }
+    if (config.selectorsFile) {
+        fixtureConfig.selectorsFile = config.selectorsFile;
+    }
+    if (config.textsFile) {
+        fixtureConfig.textsFile = config.textsFile;
+    }
+    if (config.valuesFile) {
+        fixtureConfig.valuesFile = config.valuesFile;
+    }
+    if (config.optionsFile) {
+        fixtureConfig.optionsFile = config.optionsFile;
+    }
+    if (config.endpointsFile) {
+        fixtureConfig.endpointsFile = config.endpointsFile;
+    }
+    if (config.filesFile) {
+        fixtureConfig.filesFile = config.filesFile;
+    }
+    if (config.pathsFile) {
+        fixtureConfig.pathsFile = config.pathsFile;
+    }
+    if (config.responsesFile) {
+        fixtureConfig.responsesFile = config.responsesFile;
+    }
+    if (config.queriesFile) {
+        fixtureConfig.queriesFile = config.queriesFile;
+    }
+    if (config.columnsFile) {
+        fixtureConfig.columnsFile = config.columnsFile;
+    }
+    if (config.typesFile) {
+        fixtureConfig.typesFile = config.typesFile;
+    }
+    if (config.titlesFile) {
+        fixtureConfig.titlesFile = config.titlesFile;
+    }
+    if (config.urlsFile) {
+        fixtureConfig.urlsFile = config.urlsFile;
+    }
+    if (config.attributesFile) {
+        fixtureConfig.attributesFile = config.attributesFile;
+    }
+    if (config.promptsFile) {
+        fixtureConfig.promptsFile = config.promptsFile;
+    }
+    if (config.envFile) {
+        fixtureConfig.envFile = config.envFile;
+        // Load environment variables from custom .env file
+        const baseDir = fixtureConfig.projectRoot || process.cwd();
+        const envPath = (0, path_1.resolve)(baseDir, config.envFile);
+        try {
+            const envConfig = dotenv_1.default.config({ path: envPath });
+            if (envConfig.parsed) {
+                // Filter out undefined values
+                envVariables = Object.entries({ ...process.env, ...envConfig.parsed })
+                    .reduce((acc, [key, value]) => {
+                    if (value !== undefined) {
+                        acc[key] = value;
+                    }
+                    return acc;
+                }, {});
+                console.log(`✅ Loaded environment variables from "${envPath}"`);
+            }
+        }
+        catch (_error) {
+            console.warn(`⚠️ Failed to load .env file from "${envPath}". Using process.env only.`);
+            // Filter out undefined values
+            envVariables = Object.entries(process.env)
+                .reduce((acc, [key, value]) => {
+                if (value !== undefined) {
+                    acc[key] = value;
+                }
+                return acc;
+            }, {});
+        }
+    }
+    else {
+        // Load default .env file from project root
+        const baseDir = fixtureConfig.projectRoot || process.cwd();
+        const defaultEnvPath = (0, path_1.resolve)(baseDir, ".env");
+        try {
+            const envConfig = dotenv_1.default.config({ path: defaultEnvPath });
+            if (envConfig.parsed) {
+                // Filter out undefined values
+                envVariables = Object.entries({ ...process.env, ...envConfig.parsed })
+                    .reduce((acc, [key, value]) => {
+                    if (value !== undefined) {
+                        acc[key] = value;
+                    }
+                    return acc;
+                }, {});
+            }
+            else {
+                // Filter out undefined values
+                envVariables = Object.entries(process.env)
+                    .reduce((acc, [key, value]) => {
+                    if (value !== undefined) {
+                        acc[key] = value;
+                    }
+                    return acc;
+                }, {});
+            }
+        }
+        catch (_error) {
+            // Filter out undefined values
+            envVariables = Object.entries(process.env)
+                .reduce((acc, [key, value]) => {
+                if (value !== undefined) {
+                    acc[key] = value;
+                }
+                return acc;
+            }, {});
+        }
+    }
+}
+/**
+ * Resolves environment variable placeholders in a string.
+ * Supports {{VARIABLE_NAME}} syntax for environment variables.
+ * Also supports @alias syntax for runtime variables stored in page state.
+ * @param value - The value that may contain placeholders
+ * @returns The resolved value with placeholders replaced
+ */
+function resolveEnvVariable(value) {
+    if (typeof value !== 'string') {
+        return value;
+    }
+    // Match {{VARIABLE_NAME}} pattern
+    const envVarPattern = /\{\{([^}]+)\}\}/g;
+    return value.replace(envVarPattern, (match, varName) => {
+        const trimmedVarName = varName.trim();
+        const envValue = envVariables[trimmedVarName];
+        if (envValue === undefined) {
+            console.warn(`⚠️ Environment variable "${trimmedVarName}" not found. Using literal value.`);
+            return match; // Return original placeholder if not found
+        }
+        return envValue;
+    });
+}
+/**
+ * Resolves the actual file name for a given fixture type.
+ * Uses custom file name if configured, otherwise defaults to the standard name.
+ * @param fileName - The default/standard fixture file name
+ * @returns The configured file name or the default if not configured
+ */
+function resolveFileName(fileName) {
+    const configKey = fileName.replace(".json", "") + "File";
+    const customFile = fixtureConfig[configKey];
+    return customFile || fileName;
+}
 /**
  * Loads a JSON fixture file from the test project's fixtures directory.
- * Looks in the current working directory (test project root).
+ * Looks in the current working directory (test project root) or custom projectRoot if configured.
  * @param fileName - Name of the fixture file (e.g., "selectors.json").
  * @returns Parsed JSON object.
  */
 function loadFixture(fileName) {
     try {
-        const fixturePath = (0, path_1.resolve)(process.cwd(), "fixtures", fileName);
+        const actualFileName = resolveFileName(fileName);
+        // Use projectRoot if configured (for monorepo support), otherwise use cwd
+        const baseDir = fixtureConfig.projectRoot || process.cwd();
+        const fixturePath = (0, path_1.resolve)(baseDir, fixtureConfig.fixturesDir, actualFileName);
         const content = (0, fs_1.readFileSync)(fixturePath, "utf8");
         return JSON.parse(content);
     }
     catch (_error) {
         // Return empty object for optional fixtures
-        console.warn(`⚠️ Fixture "${fileName}" not found in project root. Proceeding with empty object.`);
+        const baseDir = fixtureConfig.projectRoot || process.cwd();
+        console.warn(`⚠️ Fixture "${fileName}" not found in "${baseDir}/${fixtureConfig.fixturesDir}". Proceeding with empty object.`);
         return {};
     }
 }
 /**
  * Retrieves a specific value from a loaded fixture.
  * Returns the raw key if fixture or key is not found (fallback to raw selector).
+ * Also resolves environment variable placeholders {{VARIABLE_NAME}} in the returned value.
+ * For @alias resolution, use resolveAliasInValue() after getting the value.
  * @param fixture - The loaded fixture object.
  * @param keyPath - Dot-separated path to the desired value (e.g., "login.usernameField").
- * @returns The value at the specified key path, or the keyPath itself if not found.
+ * @returns The value at the specified key path with env vars resolved, or the keyPath itself if not found.
  */
 function getFixtureValue(fixture, keyPath) {
-    // If fixture is empty, return the keyPath as-is (fallback to raw selector)
+    // If fixture is empty, check if keyPath is an env variable placeholder
     if (Object.keys(fixture).length === 0) {
+        // Check if it's an env variable placeholder {{VAR}}
+        if (keyPath.includes('{{') && keyPath.includes('}}')) {
+            return resolveEnvVariable(keyPath);
+        }
         return keyPath;
     }
     const keys = keyPath.split(".");
@@ -42,10 +264,104 @@ function getFixtureValue(fixture, keyPath) {
             value = value[key];
         }
         else {
+            // If key not found in fixture, check if keyPath is an env variable
+            if (keyPath.includes('{{') && keyPath.includes('}}')) {
+                return resolveEnvVariable(keyPath);
+            }
             // If key not found in fixture, return the original keyPath (fallback)
             console.warn(`⚠️ Key "${keyPath}" not found in fixture. Using raw value.`);
             return keyPath;
         }
     }
+    // Resolve environment variable placeholders in the value (supports strings, objects, and arrays)
+    return resolveEnvVarsInValue(value);
+}
+/**
+ * Resolves environment variables in a value recursively (supports strings, objects, and arrays).
+ * @param value - The value to resolve
+ * @returns The value with {{ENV_VAR}} placeholders resolved
+ */
+function resolveEnvVarsInValue(value) {
+    // Handle strings
+    if (typeof value === 'string') {
+        return resolveEnvVariable(value);
+    }
+    // Handle arrays
+    if (Array.isArray(value)) {
+        return value.map(item => resolveEnvVarsInValue(item));
+    }
+    // Handle objects
+    if (value !== null && typeof value === 'object') {
+        const resolved = {};
+        for (const [key, val] of Object.entries(value)) {
+            resolved[key] = resolveEnvVarsInValue(val);
+        }
+        return resolved;
+    }
+    // Return primitives as-is
+    return value;
+}
+/**
+ * Resolves @alias references in a string value using runtime variables from page state.
+ * This should be called after getFixtureValue() when you need @alias support.
+ * @param value - The value that may contain @alias references
+ * @param page - The Playwright page object
+ * @returns The value with @alias placeholders resolved
+ */
+async function resolveAliasInValue(value, page) {
+    // Handle strings
+    if (typeof value === 'string') {
+        // Match @alias pattern (word characters after @)
+        const aliasPattern = /@([a-zA-Z_][a-zA-Z0-9_]*)/g;
+        const matches = [...value.matchAll(aliasPattern)];
+        let result = value;
+        // Process in reverse to preserve indices
+        for (const match of matches.reverse()) {
+            const aliasKey = match[1];
+            let replacement = null;
+            // Try to get from page state
+            try {
+                const stateModule = await Promise.resolve().then(() => __importStar(require('./state')));
+                const storedValue = stateModule.getVariable(page, aliasKey);
+                if (storedValue !== undefined) {
+                    replacement = String(storedValue);
+                }
+            }
+            catch (_error) {
+                // Continue with env var check
+            }
+            // Check environment variables if not found in page state
+            if (replacement === null) {
+                const envValue = envVariables[aliasKey];
+                if (envValue !== undefined) {
+                    replacement = envValue;
+                }
+            }
+            // Replace if found
+            if (replacement !== null) {
+                result = result.substring(0, match.index) +
+                    replacement +
+                    result.substring(match.index + match[0].length);
+            }
+        }
+        return result;
+    }
+    // Handle arrays
+    if (Array.isArray(value)) {
+        const resolvedArray = [];
+        for (const item of value) {
+            resolvedArray.push(await resolveAliasInValue(item, page));
+        }
+        return resolvedArray;
+    }
+    // Handle objects
+    if (value !== null && typeof value === 'object') {
+        const resolved = {};
+        for (const [key, val] of Object.entries(value)) {
+            resolved[key] = await resolveAliasInValue(val, page);
+        }
+        return resolved;
+    }
+    // Return primitives as-is
     return value;
 }

package/dist/backend/utils/resolver.d.ts

@@ -1,6 +1,19 @@
 /**
  * Resolves a parameter by checking if it's a key in a fixture file.
  * If the fixture doesn't exist or the key isn't found, it returns the raw string.
+ * Also resolves environment variable placeholders {{VARIABLE_NAME}}.
+ * For @alias resolution, use resolveAliasInParam() instead.
+ * @param key - The key to resolve (can be a fixture key or {{ENV_VAR}})
+ * @param fixtureFile - The fixture file to load (e.g., "selectors.json")
+ * @returns The resolved value
  */
 export declare function resolveParam(key: string, fixtureFile: string): string;
+/**
+ * Resolves @alias references in a parameter value using runtime variables from page state.
+ * Call this after resolveParam() if you need @alias support.
+ * @param value - The value that may contain @alias references
+ * @param page - The Playwright page object
+ * @returns The value with @alias placeholders resolved
+ */
+export declare function resolveAliasInParam(value: any, page: any): Promise<any>;
 //# sourceMappingURL=resolver.d.ts.map

package/dist/backend/utils/resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../../src/backend/utils/resolver.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CASrE"}
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../../src/backend/utils/resolver.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAcrE;AAED;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAG7E"}

package/dist/backend/utils/resolver.js

@@ -1,19 +1,74 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveParam = resolveParam;
+exports.resolveAliasInParam = resolveAliasInParam;
 const fixtures_1 = require("./fixtures");
 /**
  * Resolves a parameter by checking if it's a key in a fixture file.
  * If the fixture doesn't exist or the key isn't found, it returns the raw string.
+ * Also resolves environment variable placeholders {{VARIABLE_NAME}}.
+ * For @alias resolution, use resolveAliasInParam() instead.
+ * @param key - The key to resolve (can be a fixture key or {{ENV_VAR}})
+ * @param fixtureFile - The fixture file to load (e.g., "selectors.json")
+ * @returns The resolved value
  */
 function resolveParam(key, fixtureFile) {
     try {
         const fixture = (0, fixtures_1.loadFixture)(fixtureFile);
         // getFixtureValue handles the logic of returning the raw key if the value isn't found
+        // and resolves {{ENV_VAR}} placeholders
         return (0, fixtures_1.getFixtureValue)(fixture, key);
     }
     catch (_error) {
         // If fixture file is missing, fallback to the raw string
+        // But still resolve environment variables
+        if (key.includes('{{') && key.includes('}}')) {
+            return (0, fixtures_1.resolveEnvVariable)(key);
+        }
         return key;
     }
 }
+/**
+ * Resolves @alias references in a parameter value using runtime variables from page state.
+ * Call this after resolveParam() if you need @alias support.
+ * @param value - The value that may contain @alias references
+ * @param page - The Playwright page object
+ * @returns The value with @alias placeholders resolved
+ */
+async function resolveAliasInParam(value, page) {
+    const fixturesModule = await Promise.resolve().then(() => __importStar(require('./fixtures')));
+    return fixturesModule.resolveAliasInValue(value, page);
+}

package/dist/core/runner.d.ts

@@ -4,6 +4,7 @@ import "../backend/elements/index";
 import "../backend/api/index";
 import "../backend/auth/index";
 import "../backend/utils/state";
+import "../backend/utils/faker";
 import "../backend/db/index";
 export interface RunnerOptions {
     tags?: string;

package/dist/core/runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/core/runner.ts"],"names":[],"mappings":"AAOA,OAAO,0BAA0B,CAAC;AAClC,OAAO,6BAA6B,CAAC;AACrC,OAAO,2BAA2B,CAAC;AACnC,OAAO,sBAAsB,CAAC;AAC9B,OAAO,uBAAuB,CAAC;AAC/B,OAAO,wBAAwB,CAAC;AAChC,OAAO,qBAAqB,CAAC;AAG7B,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;CAC3C;AA8FD,wBAAgB,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,QA8LpE"}
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/core/runner.ts"],"names":[],"mappings":"AAOA,OAAO,0BAA0B,CAAC;AAClC,OAAO,6BAA6B,CAAC;AACrC,OAAO,2BAA2B,CAAC;AACnC,OAAO,sBAAsB,CAAC;AAC9B,OAAO,uBAAuB,CAAC;AAC/B,OAAO,wBAAwB,CAAC;AAChC,OAAO,wBAAwB,CAAC;AAChC,OAAO,qBAAqB,CAAC;AAG7B,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;CAC3C;AA8FD,wBAAgB,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,QA8LpE"}

package/dist/core/runner.js

@@ -46,6 +46,7 @@ require("../backend/elements/index");
 require("../backend/api/index");
 require("../backend/auth/index");
 require("../backend/utils/state");
+require("../backend/utils/faker");
 require("../backend/db/index");
 /**
  * Parses a block of Gherkin lines into structured steps.

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export { runTests } from "./core/runner";
 export { Step } from "./core/registry";
 export { getReporters } from "./reporting/index";
 export { runComponentTests } from "./component/index";
+export { setFixtureConfig, resolveEnvVariable } from "./backend/utils/fixtures";
 export type { RunnerOptions } from "./core/runner";
 export type { ReportOptions } from "./reporting/index";
 export type { StepAction } from "./core/registry";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAGtD,YAAY,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,YAAY,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,YAAY,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,YAAY,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAGhF,YAAY,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,YAAY,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,YAAY,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,YAAY,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runComponentTests = exports.getReporters = exports.Step = exports.runTests = void 0;
+exports.resolveEnvVariable = exports.setFixtureConfig = exports.runComponentTests = exports.getReporters = exports.Step = exports.runTests = void 0;
 var runner_1 = require("./core/runner");
 Object.defineProperty(exports, "runTests", { enumerable: true, get: function () { return runner_1.runTests; } });
 var registry_1 = require("./core/registry");
@@ -9,3 +9,6 @@ var index_1 = require("./reporting/index");
 Object.defineProperty(exports, "getReporters", { enumerable: true, get: function () { return index_1.getReporters; } });
 var index_2 = require("./component/index");
 Object.defineProperty(exports, "runComponentTests", { enumerable: true, get: function () { return index_2.runComponentTests; } });
+var fixtures_1 = require("./backend/utils/fixtures");
+Object.defineProperty(exports, "setFixtureConfig", { enumerable: true, get: function () { return fixtures_1.setFixtureConfig; } });
+Object.defineProperty(exports, "resolveEnvVariable", { enumerable: true, get: function () { return fixtures_1.resolveEnvVariable; } });

package/dist/metadata.json

@@ -472,17 +472,65 @@
     "type": "When"
   },
   {
-    "pattern": "I pw expect the response status to be {int}",
+    "pattern": "I pw expect the response status to be {string}",
+    "type": "Then"
+  },
+  {
+    "pattern": "I pw expect the response status to be successful",
     "type": "Then"
   },
   {
     "pattern": "I pw expect the response body to contain {string}",
     "type": "Then"
   },
+  {
+    "pattern": "I pw expect the response body to not contain {string}",
+    "type": "Then"
+  },
+  {
+    "pattern": "I pw expect the response body to equal {string}",
+    "type": "Then"
+  },
   {
     "pattern": "I pw expect the response property {string} to be {string}",
     "type": "Then"
   },
+  {
+    "pattern": "I pw store response property {string} value as {string}",
+    "type": "When"
+  },
+  {
+    "pattern": "I pw expect response property {string} to exist",
+    "type": "Then"
+  },
+  {
+    "pattern": "I pw expect response property {string} to not exist",
+    "type": "Then"
+  },
+  {
+    "pattern": "I pw expect response property {string} to be null",
+    "type": "Then"
+  },
+  {
+    "pattern": "I pw expect response property {string} to not be null",
+    "type": "Then"
+  },
+  {
+    "pattern": "I pw expect response property {string} to contain {string}",
+    "type": "Then"
+  },
+  {
+    "pattern": "I pw expect response property {string} array length to be {int}",
+    "type": "Then"
+  },
+  {
+    "pattern": "I pw expect response property {string} array to not be empty",
+    "type": "Then"
+  },
+  {
+    "pattern": "I pw fill {string} with stored value {string}",
+    "type": "When"
+  },
   {
     "pattern": "I pw mock the API endpoint {string} with body {string}",
     "type": "When"

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "playwright-cucumber-ts-steps",
   "description": "A collection of reusable Playwright step definitions for Cucumber in TypeScript, designed to streamline end-to-end testing across web, API, and mobile applications.",
-  "version": "1.3.2",
+  "version": "1.3.4",
   "private": false,
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -100,6 +100,8 @@
     "@cucumber/cucumber-expressions": "^17.1.0",
     "@cucumber/gherkin": "^27.0.0",
     "@cucumber/messages": "^22.0.0",
+    "@faker-js/faker": "^10.3.0",
+    "dotenv": "^17.3.1",
     "glob": "^10.3.10"
   }
-}
+}