create-pw-core 0.0.2

package/dist/index.js

@@ -0,0 +1,306 @@
+#!/usr/bin/env node
+"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 });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const readline = __importStar(require("readline"));
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+const question = (query) => {
+    return new Promise((resolve) => rl.question(query, resolve));
+};
+async function runCommand(command, args, cwd) {
+    return new Promise((resolve, reject) => {
+        console.log(`\x1b[36mRunning: ${command} ${args.join(' ')}\x1b[0m`);
+        const child = (0, child_process_1.spawn)(command, args, { cwd, stdio: ['ignore', 'inherit', 'inherit'], shell: true });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`Command failed with exit code ${code}`));
+            }
+        });
+    });
+}
+const ignoreList = [
+    'node_modules',
+    'reports',
+    'playwright-report',
+    'test-results',
+    'package-lock.json',
+    '.env.example',
+    '.git'
+];
+function copyRecursiveSync(src, dest) {
+    const exists = fs.existsSync(src);
+    if (!exists)
+        return;
+    const stats = fs.statSync(src);
+    const isDirectory = stats.isDirectory();
+    const name = path.basename(src);
+    if (ignoreList.includes(name)) {
+        return;
+    }
+    if (isDirectory) {
+        if (!fs.existsSync(dest)) {
+            fs.mkdirSync(dest, { recursive: true });
+        }
+        fs.readdirSync(src).forEach((childItemName) => {
+            copyRecursiveSync(path.join(src, childItemName), path.join(dest, childItemName));
+        });
+    }
+    else {
+        if (name === 'package.json') {
+            return;
+        }
+        let finalDest = dest;
+        if (name === 'gitignore' || name === '.gitignore') {
+            finalDest = path.join(path.dirname(dest), '.gitignore');
+        }
+        else if (name === 'env' || name === '.env') {
+            finalDest = path.join(path.dirname(dest), '.env');
+        }
+        fs.mkdirSync(path.dirname(finalDest), { recursive: true });
+        fs.copyFileSync(src, finalDest);
+    }
+}
+async function main() {
+    console.log('\n\x1b[35m============================================\x1b[0m');
+    console.log('\x1b[35m      Initializing pw-core Test Suite      \x1b[0m');
+    console.log('\x1b[35m============================================\n\x1b[0m');
+    const projectPathInput = await question('Project path (default: current directory): ');
+    const targetDir = projectPathInput.trim()
+        ? path.resolve(process.cwd(), projectPathInput.trim())
+        : process.cwd();
+    if (!fs.existsSync(targetDir)) {
+        fs.mkdirSync(targetDir, { recursive: true });
+    }
+    // Detect paths and find templates
+    const devRepoPath = path.resolve(__dirname, '../..');
+    const devRepoPkgPath = path.join(devRepoPath, 'package.json');
+    let isDevRepo = false;
+    if (fs.existsSync(devRepoPkgPath)) {
+        try {
+            const devRepoPkg = JSON.parse(fs.readFileSync(devRepoPkgPath, 'utf8'));
+            if (devRepoPkg.name === 'pw-core') {
+                isDevRepo = true;
+            }
+        }
+        catch (e) { }
+    }
+    // Look for local pw-core/examples on the user's machine
+    let localExamplesDir = null;
+    if (!isDevRepo) {
+        let current = targetDir;
+        while (true) {
+            const candidate = path.join(current, 'pw-core', 'examples');
+            if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
+                localExamplesDir = candidate;
+                break;
+            }
+            const siblingCandidate = path.join(current, '..', 'pw-core', 'examples');
+            if (fs.existsSync(siblingCandidate) && fs.statSync(siblingCandidate).isDirectory()) {
+                localExamplesDir = siblingCandidate;
+                break;
+            }
+            const parent = path.dirname(current);
+            if (parent === current) {
+                break;
+            }
+            current = parent;
+        }
+        if (!localExamplesDir) {
+            const hardcodedPaths = [
+                'z:/QECore/pw-core/examples',
+                'Z:/QECore/pw-core/examples'
+            ];
+            for (const p of hardcodedPaths) {
+                if (fs.existsSync(p) && fs.statSync(p).isDirectory()) {
+                    localExamplesDir = p;
+                    break;
+                }
+            }
+        }
+    }
+    let templatesDir = path.join(__dirname, 'templates');
+    let templatePkgPath = path.join(templatesDir, 'package.json');
+    if (isDevRepo || localExamplesDir) {
+        const srcDir = isDevRepo ? path.join(devRepoPath, 'examples') : localExamplesDir;
+        templatePkgPath = path.join(srcDir, 'package.json');
+    }
+    let templatePkg = {};
+    if (fs.existsSync(templatePkgPath)) {
+        try {
+            templatePkg = JSON.parse(fs.readFileSync(templatePkgPath, 'utf8'));
+        }
+        catch (e) {
+            console.warn(`Warning: Could not parse template package.json: ${e}`);
+        }
+    }
+    // Ensure package.json exists in the target directory
+    const packageJsonPath = path.join(targetDir, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+        console.log('\nNo package.json found. Initializing a new package...');
+        const newPkg = {
+            ...templatePkg,
+            name: path.basename(targetDir)
+        };
+        fs.writeFileSync(packageJsonPath, JSON.stringify(newPkg, null, 2), 'utf8');
+    }
+    // Copy templates from create-pw-core package to target directory
+    console.log('\nCopying template files...');
+    if (isDevRepo || localExamplesDir) {
+        const srcDir = isDevRepo ? path.join(devRepoPath, 'examples') : localExamplesDir;
+        console.log(`\x1b[33mLocal pw-core repository found. Copying templates directly from: ${srcDir}\x1b[0m`);
+        copyRecursiveSync(srcDir, targetDir);
+    }
+    else {
+        if (!fs.existsSync(templatesDir)) {
+            console.error(`\x1b[31mError: Templates directory not found at ${templatesDir}\x1b[0m`);
+            rl.close();
+            process.exit(1);
+        }
+        copyRecursiveSync(templatesDir, targetDir);
+    }
+    console.log('\x1b[32mSuccessfully copied template files.\x1b[0m');
+    // Update target package.json with dependencies and scripts
+    console.log('\nUpdating package.json...');
+    const targetPkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    // Merge description, author, license if target has empty or default ones
+    if (!targetPkg.description || targetPkg.description === 'pw-core test suite') {
+        targetPkg.description = templatePkg.description || "pw-core test suite";
+    }
+    if (!targetPkg.author && templatePkg.author) {
+        targetPkg.author = templatePkg.author;
+    }
+    if (!targetPkg.license || targetPkg.license === 'ISC') {
+        targetPkg.license = templatePkg.license || "ISC";
+    }
+    // Merge scripts from template
+    targetPkg.scripts = targetPkg.scripts || {};
+    if (templatePkg.scripts) {
+        for (const [key, val] of Object.entries(templatePkg.scripts)) {
+            targetPkg.scripts[key] = val;
+        }
+    }
+    else {
+        targetPkg.scripts['test'] = 'playwright test';
+    }
+    // Merge devDependencies
+    targetPkg.devDependencies = targetPkg.devDependencies || {};
+    if (templatePkg.devDependencies) {
+        for (const [key, val] of Object.entries(templatePkg.devDependencies)) {
+            if (key !== 'pw-core') {
+                targetPkg.devDependencies[key] = val;
+            }
+        }
+    }
+    // Check if we are testing locally or installing published package
+    let pwCoreInstallSource = templatePkg.devDependencies?.['pw-core'] || '^1.0.0';
+    const envInstallLocal = process.env.PW_CORE_INSTALL_LOCAL;
+    if (envInstallLocal) {
+        // If running in development/local test, use the absolute path to pw-core directory
+        pwCoreInstallSource = `file:${envInstallLocal}`;
+    }
+    else {
+        // Check if running in the development repository
+        if (isDevRepo) {
+            pwCoreInstallSource = `file:${devRepoPath}`;
+        }
+        else {
+            if (pwCoreInstallSource.startsWith('file:')) {
+                let resolvedRootPkgPath = '';
+                if (localExamplesDir) {
+                    resolvedRootPkgPath = path.join(localExamplesDir, '..', 'package.json');
+                }
+                if (fs.existsSync(resolvedRootPkgPath)) {
+                    try {
+                        const rootPkg = JSON.parse(fs.readFileSync(resolvedRootPkgPath, 'utf8'));
+                        pwCoreInstallSource = `^${rootPkg.version}`;
+                    }
+                    catch (e) {
+                        pwCoreInstallSource = '^1.1.1';
+                    }
+                }
+                else {
+                    pwCoreInstallSource = '^1.1.1';
+                }
+            }
+        }
+    }
+    targetPkg.devDependencies['pw-core'] = pwCoreInstallSource;
+    fs.writeFileSync(packageJsonPath, JSON.stringify(targetPkg, null, 2), 'utf8');
+    console.log('\x1b[32mpackage.json updated.\x1b[0m');
+    // Install NPM Packages (automatically accepted, no questions)
+    let pkgManager = 'npm';
+    let installArgs = ['install'];
+    if (fs.existsSync(path.join(targetDir, 'pnpm-lock.yaml'))) {
+        pkgManager = 'pnpm';
+    }
+    else if (fs.existsSync(path.join(targetDir, 'yarn.lock'))) {
+        pkgManager = 'yarn';
+    }
+    try {
+        await runCommand(pkgManager, installArgs, targetDir);
+        console.log('\x1b[32mPackages installed successfully.\x1b[0m');
+    }
+    catch (err) {
+        console.error('\x1b[31mFailed to install packages. Please run npm install manually.\x1b[0m');
+    }
+    // Install Playwright Browsers (automatically accepted, no questions)
+    try {
+        await runCommand('npx', ['playwright', 'install'], targetDir);
+        console.log('\x1b[32mPlaywright browsers installed successfully.\x1b[0m');
+    }
+    catch (err) {
+        console.error('\x1b[31mFailed to install browsers. Please run npx playwright install manually.\x1b[0m');
+    }
+    console.log('\n\x1b[32;1m============================================\x1b[0m');
+    console.log('\x1b[32;1m      Initialization Completed!             \x1b[0m');
+    console.log('\x1b[32;1m============================================\x1b[0m');
+    console.log('\nTo run your tests, execute:');
+    console.log('\x1b[36m  npm run test\x1b[0m\n');
+    rl.close();
+}
+main().catch((err) => {
+    console.error('\nAn error occurred during initialization:', err);
+    rl.close();
+    process.exit(1);
+});

package/dist/templates/.github/actions/setup/action.yml

@@ -0,0 +1,19 @@
+name: 'Setup Environment'
+description: 'Sets up Node.js, installs dependencies, and installs Playwright browsers'
+
+runs:
+  using: 'composite'
+  steps:
+    - name: Setup Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: lts/*
+        cache: 'npm'
+
+    - name: Install dependencies
+      shell: bash
+      run: npm ci
+
+    - name: Install Playwright Browsers
+      shell: bash
+      run: npx playwright install --with-deps

package/dist/templates/.github/workflows/playwright.yml

@@ -0,0 +1,22 @@
+name: Playwright Tests
+on:
+  push:
+    branches: [ main, master ]
+  pull_request:
+    branches: [ main, master ]
+jobs:
+  test:
+    timeout-minutes: 10
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Setup environment
+      uses: ./.github/actions/setup
+    - name: Run Playwright tests
+      run: npm run test
+    - uses: actions/upload-artifact@v4
+      if: always()
+      with:
+        name: playwright-report
+        path: reports/playwright-report/
+        retention-days: 30

package/dist/templates/.vscode/settings.json

@@ -0,0 +1,9 @@
+{
+    "files.exclude": {
+        "node_modules": true,
+        "playwright-report": true,
+        "test-results": true,
+        "package-lock.json": true,
+        "yarn.lock": true
+    }
+}

package/dist/templates/README.md

@@ -0,0 +1,47 @@
+# Welcome to your pw-core Test Suite! 🚀
+
+This test suite has been successfully initialized using `create-pw-core`. It is pre-configured with Playwright, TypeScript, and `pw-core` framework patterns.
+
+## 📖 Documentation
+
+For complete guides, API references, and framework concepts, please visit the official documentation:
+👉 **[qecore.github.io/pw-core](https://qecore.github.io/pw-core)**
+
+---
+
+## 🛠️ VS Code Developer Experience
+
+For a clean and focused workspace, we recommend configuring VS Code to hide generated files and folders (such as build artifacts, dependencies, and test reports).
+
+You can review or customize these settings in:
+📄 **[.vscode/settings.json](file:///.vscode/settings.json)**
+
+### Recommended Settings:
+```json
+{
+  "files.exclude": {
+    "node_modules": true,
+    "playwright-report": true,
+    "test-results": true,
+    "package-lock.json": true,
+    "yarn.lock": true
+  }
+}
+```
+
+---
+
+## 🚀 Running Your Tests
+
+- **Run all E2E tests**:
+  ```bash
+  npm run test
+  ```
+- **Run tests in headed browser**:
+  ```bash
+  npm run test:headed
+  ```
+- **Show test execution report**:
+  ```bash
+  npm run test:report
+  ```

package/dist/templates/gitignore

@@ -0,0 +1,7 @@
+node_modules/
+reports/
+playwright-report/
+test-results/
+*.log
+.env
+.DS_Store

package/dist/templates/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "pw-core-demo",
+  "version": "1.0.0",
+  "description": "Demo and example test suite showcasing the usage of pw-core in Playwright.",
+  "scripts": {
+    "test": "playwright test",
+    "test:headed": "playwright test --headed",
+    "test:headless": "playwright test",
+    "test:report": "playwright show-report"
+  },
+  "author": {
+    "name": "Shanmuka Chandra Teja Anem",
+    "url": "https://github.com/shanmukaanem"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@playwright/test": "^1.61.0",
+    "@types/node": "^20.11.0",
+    "dotenv": "^16.4.5",
+    "pw-core": "^0.0.2",
+    "typescript": "^6.0.3"
+  }
+}

package/dist/templates/playwright.config.ts

@@ -0,0 +1,24 @@
+import { defineConfig } from '@playwright/test';
+import { env } from '@utils/env';
+
+export default defineConfig({
+  testDir: './src/tests',
+  timeout: 10000,
+  expect: {
+    timeout: 5000,
+  },
+  reporter: [['html'], ['list']],
+  use: {
+    baseURL: env.url,
+    headless: true,
+    screenshot: 'only-on-failure',
+    video: 'retain-on-failure',
+    trace: 'retain-on-failure'
+  },
+  projects: [
+    {
+      name: 'chrome',
+      use: { browserName: 'chromium' },
+    }
+  ]
+});

package/dist/templates/src/pages/projects.page.ts

@@ -0,0 +1,29 @@
+import type { Page } from "@playwright/test";
+import { Table } from "pw-core/component/table";
+import { registry } from "@pages/registry";
+
+type TableType = { title: string }
+
+// To Override the page config to add custom methods for the page
+export class ProjectsPage extends registry.pages.projectsPage {
+  projectsTable = new Table<TableType>(this.table);
+
+  constructor(page: Page) {
+    super(page);
+  }
+
+  async createProject(title: string, description: string) {
+    await this.click('newProject');
+    await this.fill('formTitle', title);
+    await this.fill('formDescription', description);
+    await this.click('formSave');
+  }
+
+  async verifyProjectInTable(title: string) {
+    const rows = await this.projectsTable.get();
+    const titles = rows.getAll('title');
+    if (!titles.includes(title)) {
+      throw new Error(`Project "${title}" not found in projects table.`);
+    }
+  }
+}

package/dist/templates/src/pages/registry.ts

@@ -0,0 +1,48 @@
+import { createPageRegistry } from 'pw-core/page';
+
+// Initialize registry (mostly automatic, defining base configs as siblings)
+export const registry = createPageRegistry({
+  loginPage: {
+    url: '/login',
+    testIds: {
+      defaultUserLogin: 'login-default-user',
+    },
+  },
+  dashboardPage: {
+    url: '/app',
+    selectors: {
+      heading: 'h1:has-text("Dashboard")',
+    },
+  },
+  projectsPage: {
+    url: '/app/projects',
+    testIds: {
+      newProject: 'new-project-button',
+      formTitle: 'form-title',
+      formDescription: 'form-description',
+      formSave: 'form-save',
+      table: 'projects-table',
+    },
+  },
+  tasksPage: {
+    url: '/app/tasks',
+    testIds: {
+      newTask: 'new-task-button',
+      formTitle: 'form-title',
+      formDescription: 'form-description',
+      formSave: 'form-save',
+      table: 'tasks-table',
+    },
+  },
+  sidebar: {
+    testIds: {
+      itemProjects: 'sidebar-projects',
+      itemTasks: 'sidebar-tasks',
+    },
+  },
+  topNav: {
+    testIds: {
+      logoutBtn: 'logout-button',
+    },
+  },
+});

package/dist/templates/src/tests/core.test.ts

@@ -0,0 +1,41 @@
+import { expect } from '@playwright/test';
+import { scenario } from '@utils/fixtures';
+
+scenario('Verify advanced locators, actions and assertions in pw-core', async ({
+  loginPage,
+  dashboardPage,
+  projectsPage,
+  sidebar
+}) => {
+  // 1. Navigation and Title Verification
+  await loginPage.goto();
+  await loginPage.verifyTitle('PW-Core Workspace — Build, Test & Document');
+
+  // 2. Click action using options (hasText)
+  // This resolves the locator and filters it by the provided text before clicking
+  await loginPage.click('defaultUserLogin', { hasText: /Default/ });
+  await dashboardPage.verifyURL();
+
+  // 3. All verify methods (using default visibility checks)
+  await dashboardPage.verify('heading'); // Inbuilt visibility check
+  await loginPage.verifyHidden('defaultUserLogin'); // verifyHidden asserts that the element is hidden
+
+  // Navigate to Projects Page
+  await sidebar.click('itemProjects');
+  await projectsPage.verifyURL();
+  await projectsPage.verifyEnabled('newProject'); // verifyEnabled asserts element is enabled
+
+  // 4. Action click/fill using options (nth)
+  await projectsPage.click('newProject', { nth: 0 });
+  await projectsPage.fill('formTitle', 'Form Title Nth Test', { nth: 0 });
+  await projectsPage.fill('formDescription', 'Form Description Nth Test', { nth: 0 });
+
+  // Verify disabled state using verifyEnabled
+  await projectsPage.verifyEnabled('formSave');
+  await projectsPage.click('formSave');
+
+  // 5. Locator chaining on typed Page objects
+  // Resolves the parent 'table' locator and chains standard Playwright locator methods on it
+  const projectTableRows = projectsPage.locator('table').locator('tbody tr').first();
+  await expect(projectTableRows).toBeVisible();
+});

package/dist/templates/src/tests/e2e.test.ts

@@ -0,0 +1,62 @@
+import { expect } from '@playwright/test';
+import { Table } from 'pw-core/component/table';
+import { scenario } from '@utils/fixtures';
+
+scenario('End-to-End User Flow on QECore App with Page Object Flows', async ({
+  loginPage,
+  dashboardPage,
+  projectsPage,
+  tasksPage,
+  sidebar,
+  topNav
+}) => {
+  // 1. Login (automatic page usage)
+  await loginPage.goto();
+
+  // Verify title and page element states
+  await loginPage.verifyTitle(/PW-Core/);
+  await loginPage.verify('defaultUserLogin').toBeEnabled();
+
+  await loginPage.click('defaultUserLogin');
+  await dashboardPage.verifyURL();
+
+  // Verify dashboard page is loaded with soft assertions (toBeVisible is default and doesn't need to be chained)
+  await dashboardPage.verify.soft('heading');
+  await dashboardPage.verify.soft('heading').toHaveText('Dashboard');
+
+  // 2. Create a Project (using custom overridden ProjectsPage flows)
+  await sidebar.click('itemProjects');
+  await projectsPage.verifyURL();
+
+  // Verify elements are not present initially using verifyHidden
+  await projectsPage.verifyHidden('formTitle');
+
+  await projectsPage.createProject('Demo Project', 'A project created via pw-core automation.');
+  await projectsPage.verifyProjectInTable('Demo Project');
+
+  // 3. Create a Task (automatic page usage, creating Table component inline)
+  await sidebar.click('itemTasks');
+  await tasksPage.verifyURL();
+  await tasksPage.click('newTask');
+
+  // Verify element attributes using the typed expect wrapper
+  await tasksPage.expect('formTitle').toBeVisible();
+
+  await tasksPage.fill('formTitle', 'Demo Task');
+  await tasksPage.fill('formDescription', 'A task created via pw-core automation.');
+  await tasksPage.click('formSave');
+
+  // Wait for the new task to appear in the table using built-in verify
+  await tasksPage.verify('table', { hasText: 'Demo Task' });
+
+  const taskTable = new Table<{ title: string }>(tasksPage.table);
+  const taskHeaders = await taskTable.getHeaders();
+  expect(taskHeaders).toContain('title');
+  const taskRows = await taskTable.get();
+  expect(taskRows.getAll('title')).toContain('Demo Task');
+
+  // 4. Logout (automatic page usage)
+  await topNav.click('logoutBtn');
+  await loginPage.verifyURL();
+  await loginPage.verify('defaultUserLogin'); // Inbuilt visibility check
+});

package/dist/templates/src/tests/multiuser.test.ts

@@ -0,0 +1,65 @@
+import { scenario as baseScenario } from '@utils/fixtures';
+import { Page, Browser, BrowserContext } from '@playwright/test';
+
+type Session = {
+  context: BrowserContext;
+  page: Page;
+} & {
+  [K in keyof typeof baseScenario.pages]: InstanceType<(typeof baseScenario.pages)[K]>;
+};
+
+// Helper to create an isolated user session with all page objects instantiated
+async function createUser(browser: Browser): Promise<Session> {
+  const context = await browser.newContext();
+  const page = await context.newPage();
+
+  const pages: any = {};
+  for (const [key, PageClass] of Object.entries(baseScenario.pages)) {
+    pages[key] = new (PageClass as any)(page);
+  }
+
+  return {
+    context,
+    page,
+    ...pages
+  } as Session;
+}
+
+// Extend the imported scenario locally with custom user session fixtures
+const scenario = baseScenario.extend<{
+  user1: Session;
+  user2: Session;
+}>({
+  user1: async ({ browser }, use) => {
+    const session = await createUser(browser);
+    await use(session);
+    await session.context.close();
+  },
+  
+  user2: async ({ browser }, use) => {
+    const session = await createUser(browser);
+    await use(session);
+    await session.context.close();
+  },
+});
+
+/**
+ * NOTE: This is a simulation of multiple isolated contexts/sessions in a single test,
+ * not real multi-user authentication. You can follow this pattern for seamless multi-user flows.
+ */
+scenario('Verify multi-user concurrent context control', async ({ user1, user2 }) => {
+  // Both navigate to login page
+  await user1.loginPage.goto();
+  await user2.loginPage.goto();
+
+  // User 1 (Admin) logs in
+  await user1.loginPage.click('defaultUserLogin');
+  await user1.dashboardPage.verifyURL();
+  await user1.dashboardPage.verify('heading').toHaveText('Dashboard');
+
+  // User 2 logs in independently
+  await user2.loginPage.click('defaultUserLogin');
+  await user2.dashboardPage.verifyURL();
+  await user2.dashboardPage.verify('heading').toHaveText('Dashboard');
+});
+

package/dist/templates/src/tests/state.test.ts

@@ -0,0 +1,22 @@
+import { scenario } from '@utils/fixtures';
+
+scenario.describe.serial('Worker Page State Reuse Suite', () => {
+  // Scenario 1: Setup state inside the workerPage
+  scenario('Test 1: Navigate and transition page state on workerPage', async ({ workerLoginPage: lp, workerDashboardPage: dp }) => {
+    await lp.goto();
+    await lp.verifyURL();
+    await lp.verify('defaultUserLogin');
+
+    // Perform action that transitions page state (Login)
+    await lp.click('defaultUserLogin');
+    await dp.verifyURL({ timeout: 2000 });
+  });
+
+  // Scenario 2: Verify same state persists in a subsequent test in the same worker,
+  // without requesting the page-scoped `page` or `loginPage` fixtures at all.
+  scenario('Test 2: Verify same page instance and state persist on workerPage', async ({ workerDashboardPage: dp }) => {
+    // Verify using workerDashboardPage fixture (which is bound to workerPage)
+    await dp.verifyURL();
+    await dp.verify('heading');
+  });
+});

package/dist/templates/src/tests/store.test.ts

@@ -0,0 +1,43 @@
+import { expect } from '@playwright/test';
+import { scenario } from '@utils/fixtures';
+import { 
+  getLocalStorage, 
+  setLocalStorage, 
+  getSessionStorage, 
+  setSessionStorage, 
+  seedSessionStorage 
+} from 'pw-core/helpers';
+
+scenario('Verify local and session storage helpers', async ({ page }) => {
+  await page.goto('/login');
+  
+  // 1. LocalStorage Helpers
+  await setLocalStorage(page, 'localKey', 'localValue');
+  const localVal = await getLocalStorage(page, 'localKey');
+  expect(localVal).toBe('localValue');
+
+  // 2. SessionStorage Helpers
+  await setSessionStorage(page, 'sessionKey', 'sessionValue');
+  const sessionVal = await getSessionStorage(page, 'sessionKey');
+  expect(sessionVal).toBe('sessionValue');
+});
+
+scenario('Verify sessionStorage seeding helper', async ({ page }) => {
+  // Add a cookie to simulate authenticated state and trigger sessionStorage seeding
+  await page.context().addCookies([{
+    name: 'auth-token',
+    value: 'dummy-token-value',
+    domain: 'qecore.github.io',
+    path: '/'
+  }]);
+
+  // Seed sessionStorage before load/navigation
+  await seedSessionStorage(page, { seededKey: 'seededValue' });
+  
+  await page.goto('/login');
+
+  const seededVal = await getSessionStorage(page, 'seededKey');
+  expect(seededVal).toBe('seededValue');
+  
+  console.log('Successfully seeded and retrieved sessionStorage value:', seededVal);
+});

package/dist/templates/src/utils/env.ts

@@ -0,0 +1,16 @@
+import dotenv from 'dotenv';
+import path from 'path';
+
+// Load env configuration
+dotenv.config({ path: path.resolve('.env') });
+
+export const ENV = {
+  url: process.env.URL || 'https://qecore.github.io',
+  testUser: process.env.TEST_USER || 'default',
+  testPassword: process.env.TEST_PASSWORD || 'secret',
+} as const;
+
+
+// It's always best to prefer typesafe variables for .env
+export const env = ENV
+

package/dist/templates/src/utils/fixtures.ts

@@ -0,0 +1,7 @@
+import { ProjectsPage } from "@pages/projects.page";
+import { registry } from "@pages/registry";
+
+// Extend registry with overridden ProjectsPage class
+export const scenario = registry.extend({
+  projectsPage: ProjectsPage,
+});

package/dist/templates/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node20",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "noEmit": true,
+    "baseUrl": ".",
+    "paths": {
+      "@pages/*": ["src/pages/*"],
+      "@tests/*": ["src/tests/*"],
+      "@utils/*": ["src/utils/*"]
+    }
+  },
+  "include": [
+    "**/*.ts"
+  ]
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "create-pw-core",
+  "version": "0.0.2",
+  "description": "Initialize a pw-core test suite in a project",
+  "bin": {
+    "create-pw-core": "dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "rimraf dist && tsc && node scripts/copy-templates.js"
+  },
+  "keywords": [
+    "playwright",
+    "pw-core",
+    "create-pw-core",
+    "initializer"
+  ],
+  "author": {
+    "name": "Shanmuka Chandra Teja Anem",
+    "url": "https://github.com/shanmukaanem"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.3.3"
+  }
+}