@lowdefy/e2e-utils 0.0.0-experimental-20260202125814

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1.  Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction,
+    and distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by
+    the copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all
+    other entities that control, are controlled by, or are under common
+    control with that entity. For the purposes of this definition,
+    "control" means (i) the power, direct or indirect, to cause the
+    direction or management of such entity, whether by contract or
+    otherwise, or (ii) ownership of fifty percent (50%) or more of the
+    outstanding shares, or (iii) beneficial ownership of such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity
+    exercising permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation
+    source, and configuration files.
+
+    "Object" form shall mean any form resulting from mechanical
+    transformation or translation of a Source form, including but
+    not limited to compiled object code, generated documentation,
+    and conversions to other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or
+    Object form, made available under the License, as indicated by a
+    copyright notice that is included in or attached to the work
+    (an example is provided in the Appendix below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object
+    form, that is based on (or derived from) the Work and for which the
+    editorial revisions, annotations, elaborations, or other modifications
+    represent, as a whole, an original work of authorship. For the purposes
+    of this License, Derivative Works shall not include works that remain
+    separable from, or merely link (or bind by name) to the interfaces of,
+    the Work and Derivative Works thereof.
+
+    "Contribution" shall mean any work of authorship, including
+    the original version of the Work and any modifications or additions
+    to that Work or Derivative Works thereof, that is intentionally
+    submitted to Licensor for inclusion in the Work by the copyright owner
+    or by an individual or Legal Entity authorized to submit on behalf of
+    the copyright owner. For the purposes of this definition, "submitted"
+    means any form of electronic, verbal, or written communication sent
+    to the Licensor or its representatives, including but not limited to
+    communication on electronic mailing lists, source code control systems,
+    and issue tracking systems that are managed by, or on behalf of, the
+    Licensor for the purpose of discussing and improving the Work, but
+    excluding communication that is conspicuously marked or otherwise
+    designated in writing by the copyright owner as "Not a Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity
+    on behalf of whom a Contribution has been received by Licensor and
+    subsequently incorporated within the Work.
+
+2.  Grant of Copyright License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    copyright license to reproduce, prepare Derivative Works of,
+    publicly display, publicly perform, sublicense, and distribute the
+    Work and such Derivative Works in Source or Object form.
+
+3.  Grant of Patent License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    (except as stated in this section) patent license to make, have made,
+    use, offer to sell, sell, import, and otherwise transfer the Work,
+    where such license applies only to those patent claims licensable
+    by such Contributor that are necessarily infringed by their
+    Contribution(s) alone or by combination of their Contribution(s)
+    with the Work to which such Contribution(s) was submitted. If You
+    institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work
+    or a Contribution incorporated within the Work constitutes direct
+    or contributory patent infringement, then any patent licenses
+    granted to You under this License for that Work shall terminate
+    as of the date such litigation is filed.
+
+4.  Redistribution. You may reproduce and distribute copies of the
+    Work or Derivative Works thereof in any medium, with or without
+    modifications, and in Source or Object form, provided that You
+    meet the following conditions:
+
+    (a) You must give any other recipients of the Work or
+    Derivative Works a copy of this License; and
+
+    (b) You must cause any modified files to carry prominent notices
+    stating that You changed the files; and
+
+    (c) You must retain, in the Source form of any Derivative Works
+    that You distribute, all copyright, patent, trademark, and
+    attribution notices from the Source form of the Work,
+    excluding those notices that do not pertain to any part of
+    the Derivative Works; and
+
+    (d) If the Work includes a "NOTICE" text file as part of its
+    distribution, then any Derivative Works that You distribute must
+    include a readable copy of the attribution notices contained
+    within such NOTICE file, excluding those notices that do not
+    pertain to any part of the Derivative Works, in at least one
+    of the following places: within a NOTICE text file distributed
+    as part of the Derivative Works; within the Source form or
+    documentation, if provided along with the Derivative Works; or,
+    within a display generated by the Derivative Works, if and
+    wherever such third-party notices normally appear. The contents
+    of the NOTICE file are for informational purposes only and
+    do not modify the License. You may add Your own attribution
+    notices within Derivative Works that You distribute, alongside
+    or as an addendum to the NOTICE text from the Work, provided
+    that such additional attribution notices cannot be construed
+    as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and
+    may provide additional or different license terms and conditions
+    for use, reproduction, or distribution of Your modifications, or
+    for any such Derivative Works as a whole, provided Your use,
+    reproduction, and distribution of the Work otherwise complies with
+    the conditions stated in this License.
+
+5.  Submission of Contributions. Unless You explicitly state otherwise,
+    any Contribution intentionally submitted for inclusion in the Work
+    by You to the Licensor shall be under the terms and conditions of
+    this License, without any additional terms or conditions.
+    Notwithstanding the above, nothing herein shall supersede or modify
+    the terms of any separate license agreement you may have executed
+    with Licensor regarding such Contributions.
+
+6.  Trademarks. This License does not grant permission to use the trade
+    names, trademarks, service marks, or product names of the Licensor,
+    except as required for reasonable and customary use in describing the
+    origin of the Work and reproducing the content of the NOTICE file.
+
+7.  Disclaimer of Warranty. Unless required by applicable law or
+    agreed to in writing, Licensor provides the Work (and each
+    Contributor provides its Contributions) on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+    implied, including, without limitation, any warranties or conditions
+    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+    PARTICULAR PURPOSE. You are solely responsible for determining the
+    appropriateness of using or redistributing the Work and assume any
+    risks associated with Your exercise of permissions under this License.
+
+8.  Limitation of Liability. In no event and under no legal theory,
+    whether in tort (including negligence), contract, or otherwise,
+    unless required by applicable law (such as deliberate and grossly
+    negligent acts) or agreed to in writing, shall any Contributor be
+    liable to You for damages, including any direct, indirect, special,
+    incidental, or consequential damages of any character arising as a
+    result of this License or out of the use or inability to use the
+    Work (including but not limited to damages for loss of goodwill,
+    work stoppage, computer failure or malfunction, or any and all
+    other commercial damages or losses), even if such Contributor
+    has been advised of the possibility of such damages.
+
+9.  Accepting Warranty or Additional Liability. While redistributing
+    the Work or Derivative Works thereof, You may choose to offer,
+    and charge a fee for, acceptance of support, warranty, indemnity,
+    or other liability obligations and/or rights consistent with this
+    License. However, in accepting such obligations, You may act only
+    on Your own behalf and on Your sole responsibility, not on behalf
+    of any other Contributor, and only if You agree to indemnify,
+    defend, and hold each Contributor harmless for any liability
+    incurred by, or claims asserted against, such Contributor by reason
+    of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,164 @@
+# @lowdefy/e2e-utils
+
+Playwright testing utilities for Lowdefy applications.
+
+## Installation
+
+```bash
+pnpm add -D @lowdefy/e2e-utils @playwright/test
+npx playwright install chromium
+```
+
+## Quick Start
+
+Initialize e2e testing in your Lowdefy app:
+
+```bash
+npx lowdefy-e2e init
+```
+
+This creates:
+- `e2e/playwright.config.js` - Pre-configured Playwright config
+- `e2e/example.spec.js` - Starter test to copy from
+
+Then run tests:
+
+```bash
+pnpm e2e        # Run tests
+pnpm e2e:ui     # Run with Playwright UI
+```
+
+## Core Helpers
+
+Framework-level testing utilities:
+
+```javascript
+import { ldf } from '@lowdefy/e2e-utils';
+
+// Navigation
+await ldf.goto(page, '/dashboard');
+await ldf.waitForReady(page);
+await ldf.expectNavigation(page, /\/tickets\/\d+/);
+await ldf.waitForPage(page, '/settings');
+
+// Requests
+await ldf.waitForRequest(page, 'create_ticket');
+const response = await ldf.getRequestResponse(page, 'get_users');
+
+// State
+const state = await ldf.getState(page);
+const blockState = await ldf.getBlockState(page, 'my_input');
+await ldf.expectState(page, 'form.title', 'Bug report');
+
+// Block locator
+const block = ldf.block(page, 'my_block');
+await expect(block).toBeVisible();
+```
+
+## Block Helpers
+
+Block-specific interactions (requires `@lowdefy/blocks-antd`):
+
+```javascript
+import { button, selector, textInput } from '@lowdefy/e2e-utils';
+
+// Button
+await button.click(page, 'submit_btn');
+await button.assertions.isVisible(page, 'submit_btn');
+await button.assertions.isDisabled(page, 'submit_btn');
+await button.assertions.isLoading(page, 'submit_btn');
+await button.assertions.hasText(page, 'submit_btn', 'Submit');
+await button.assertions.hasType(page, 'submit_btn', 'primary');
+
+// Selector
+await selector.select(page, 'priority', 'High');
+await selector.clear(page, 'priority');
+await selector.search(page, 'priority', 'Med');
+await selector.assertions.isVisible(page, 'priority');
+await selector.assertions.hasValue(page, 'priority', 'High');
+await selector.assertions.isDisabled(page, 'priority');
+await selector.assertions.hasPlaceholder(page, 'priority', 'Select...');
+
+// TextInput
+await textInput.fill(page, 'title', 'Bug report');
+await textInput.clear(page, 'title');
+await textInput.pressEnter(page, 'title');
+await textInput.assertions.isVisible(page, 'title');
+await textInput.assertions.hasValue(page, 'title', 'Bug report');
+await textInput.assertions.isDisabled(page, 'title');
+await textInput.assertions.hasPlaceholder(page, 'title', 'Enter title...');
+```
+
+## Complete Example
+
+```javascript
+import { test, expect } from '@playwright/test';
+import { ldf, button, textInput, selector } from '@lowdefy/e2e-utils';
+
+test('create ticket workflow', async ({ page }) => {
+  // Navigate
+  await ldf.goto(page, '/tickets/new');
+
+  // Fill form (block helpers)
+  await textInput.fill(page, 'title', 'Bug report');
+  await textInput.fill(page, 'description', 'Login not working');
+  await selector.select(page, 'priority', 'High');
+
+  // Submit and verify (framework helpers)
+  await button.click(page, 'submit_btn');
+  await ldf.waitForRequest(page, 'create_ticket');
+  await ldf.expectNavigation(page, /\/tickets\/\d+/);
+  await ldf.expectState(page, 'ticket.status', 'open');
+});
+```
+
+## Playwright Config
+
+Use `createConfig` for a pre-configured Playwright setup:
+
+```javascript
+// e2e/playwright.config.js
+import { createConfig } from '@lowdefy/e2e-utils/config';
+
+export default createConfig({
+  appDir: './',      // Where lowdefy.yaml is
+  port: 3000,        // Dev server port
+  testDir: 'e2e',    // Test directory
+  testMatch: '**/*.spec.js',
+});
+```
+
+## How It Works
+
+These utilities access the Lowdefy client state via `window.lowdefy`, which is exposed in dev mode. This allows:
+
+- Waiting for the Lowdefy client to initialize
+- Checking request completion status
+- Accessing page state
+- Stable block selection via `#bl-{blockId}` IDs
+
+**Note:** Tests must run against the Lowdefy dev server (`npx lowdefy dev`).
+
+## LLM Test Generation
+
+These helpers are designed to be LLM-friendly. An LLM can read your `lowdefy.yaml` config and generate stable tests:
+
+```yaml
+# lowdefy.yaml
+blocks:
+  - id: title_input
+    type: TextInput
+  - id: priority
+    type: Selector
+  - id: submit_btn
+    type: Button
+```
+
+LLM generates:
+```javascript
+await textInput.fill(page, 'title_input', 'Bug report');
+await selector.select(page, 'priority', 'High');
+await button.click(page, 'submit_btn');
+```
+
+Block IDs from config → stable, readable tests.

package/dist/config.js

@@ -0,0 +1,55 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import path from 'path';
+import { fileURLToPath } from 'url';
+import { defineConfig, devices } from '@playwright/test';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+function createConfig({ appDir = './', buildDir = '.lowdefy/server/build', port = 3000, testDir = 'e2e', testMatch = '**/*.spec.js' } = {}) {
+    const cliCommand = 'npx lowdefy';
+    // Resolve absolute path for build directory
+    const absoluteBuildDir = path.resolve(appDir, buildDir);
+    // Set environment for fixtures to find build artifacts
+    process.env.LOWDEFY_BUILD_DIR = absoluteBuildDir;
+    return defineConfig({
+        testDir,
+        testMatch,
+        fullyParallel: true,
+        reporter: 'list',
+        globalSetup: path.join(__dirname, 'globalSetup.js'),
+        use: {
+            baseURL: `http://localhost:${port}`,
+            trace: 'on-first-retry'
+        },
+        projects: [
+            {
+                name: 'chromium',
+                use: {
+                    ...devices['Desktop Chrome']
+                }
+            }
+        ],
+        webServer: {
+            // Start production server (build happens in globalSetup)
+            // NEXT_PUBLIC_LOWDEFY_E2E=true exposes window.lowdefy for state testing
+            command: `NEXT_PUBLIC_LOWDEFY_E2E=true ${cliCommand} start --port ${port}`,
+            url: `http://localhost:${port}`,
+            reuseExistingServer: true,
+            timeout: 60000,
+            cwd: appDir
+        }
+    });
+}
+export { createConfig };
+export default createConfig;

package/dist/core/index.js

@@ -0,0 +1,18 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ export { getBlock } from './locators.js';
+export { goto, waitForReady, expectNavigation, waitForPage } from './navigation.js';
+export { waitForRequest, getRequestResponse } from './requests.js';
+export { getState, getBlockState, expectState } from './state.js';

package/dist/core/locators.js

@@ -0,0 +1,18 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ function getBlock(page, blockId) {
+    return page.locator(`#bl-${blockId}`);
+}
+export { getBlock };

package/dist/core/navigation.js

@@ -0,0 +1,37 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { expect } from '@playwright/test';
+async function waitForReady(page) {
+    // Wait for Lowdefy client to initialize (context exists)
+    // Context key is "page:{pageId}" not just pageId
+    await page.waitForFunction(()=>{
+        const lowdefy = window.lowdefy;
+        return lowdefy && lowdefy.pageId && lowdefy.contexts[`page:${lowdefy.pageId}`];
+    }, {
+        timeout: 30000
+    });
+}
+async function goto(page, path) {
+    await page.goto(path);
+    await waitForReady(page);
+}
+async function expectNavigation(page, urlPattern) {
+    await expect(page).toHaveURL(urlPattern);
+}
+async function waitForPage(page, path) {
+    await page.waitForURL(path);
+    await waitForReady(page);
+}
+export { goto, waitForReady, expectNavigation, waitForPage };

package/dist/core/requests.js

@@ -0,0 +1,35 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ async function waitForRequest(page, requestId) {
+    // Wait for request to complete (loading === false)
+    await page.waitForFunction((reqId)=>{
+        const lowdefy = window.lowdefy;
+        if (!lowdefy) return false;
+        const pageId = lowdefy.pageId;
+        const requests = lowdefy.contexts?.[`page:${pageId}`]?.requests?.[reqId];
+        return requests && requests.length > 0 && requests[0].loading === false;
+    }, requestId, {
+        timeout: 30000
+    });
+}
+async function getRequestResponse(page, requestId) {
+    return page.evaluate((reqId)=>{
+        const lowdefy = window.lowdefy;
+        const pageId = lowdefy?.pageId;
+        const requests = lowdefy?.contexts?.[`page:${pageId}`]?.requests?.[reqId];
+        return requests?.[0]?.response;
+    }, requestId);
+}
+export { waitForRequest, getRequestResponse };

package/dist/core/state.js

@@ -0,0 +1,35 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { expect } from '@playwright/test';
+async function getState(page) {
+    return page.evaluate(()=>{
+        const lowdefy = window.lowdefy;
+        const pageId = lowdefy?.pageId;
+        return lowdefy?.contexts?.[`page:${pageId}`]?.state;
+    });
+}
+async function getBlockState(page, blockId) {
+    const state = await getState(page);
+    return state?.[blockId];
+}
+async function expectState(page, key, value, { timeout = 5000 } = {}) {
+    await expect.poll(async ()=>{
+        const state = await getState(page);
+        return key.split('.').reduce((obj, k)=>obj?.[k], state);
+    }, {
+        timeout
+    }).toEqual(value);
+}
+export { getState, getBlockState, expectState };

package/dist/fixtures/index.js

@@ -0,0 +1,54 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { test as base, expect } from '@playwright/test';
+import createHelperRegistry from '../proxy/createHelperRegistry.js';
+import createPageManager from '../proxy/createPageManager.js';
+import { loadManifest } from '../testPrep/generateManifest.js';
+// Create test with ldf fixture
+export const test = base.extend({
+    // Worker-scoped fixtures (shared across tests in a worker)
+    helperRegistry: [
+        async ({}, use)=>{
+            const registry = createHelperRegistry();
+            await use(registry);
+        },
+        {
+            scope: 'worker'
+        }
+    ],
+    manifest: [
+        async ({}, use)=>{
+            // Load manifest from build directory (generated by globalSetup)
+            const buildDir = process.env.LOWDEFY_BUILD_DIR || '.lowdefy';
+            const manifest = loadManifest({
+                buildDir
+            });
+            await use(manifest);
+        },
+        {
+            scope: 'worker'
+        }
+    ],
+    // Test-scoped fixture - provides the ldf helper
+    ldf: async ({ page, manifest, helperRegistry }, use)=>{
+        const pageManager = createPageManager({
+            page,
+            manifest,
+            helperRegistry
+        });
+        await use(pageManager);
+    }
+});
+export { expect };

package/dist/globalSetup.js

@@ -0,0 +1,35 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { execSync } from 'child_process';
+import path from 'path';
+import { generateManifest } from './testPrep/generateManifest.js';
+async function globalSetup(config) {
+    // Get app directory from webServer config or use current directory
+    const appDir = config.webServer?.cwd || process.cwd();
+    const buildDir = process.env.LOWDEFY_BUILD_DIR || path.join(appDir, '.lowdefy/server/build');
+    console.log('[e2e-utils] Building Lowdefy app...');
+    execSync('npx lowdefy build', {
+        cwd: appDir,
+        stdio: 'inherit'
+    });
+    console.log('[e2e-utils] Build complete.');
+    console.log('[e2e-utils] Generating manifest...');
+    // Generate manifest from build artifacts
+    generateManifest({
+        buildDir
+    });
+    console.log(`[e2e-utils] Manifest generated at ${buildDir}/e2e-manifest.json`);
+}
+export default globalSetup;

package/dist/index.js

@@ -0,0 +1,31 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ // Core helpers
+import { getBlock } from './core/locators.js';
+import { goto, waitForReady, expectNavigation, waitForPage } from './core/navigation.js';
+import { waitForRequest, getRequestResponse } from './core/requests.js';
+import { getState, getBlockState, expectState } from './core/state.js';
+export { getBlock };
+export { goto, waitForReady, expectNavigation, waitForPage };
+export { waitForRequest, getRequestResponse };
+export { getState, getBlockState, expectState };
+// Test prep utilities
+import { generateManifest, loadManifest } from './testPrep/generateManifest.js';
+export { generateManifest, loadManifest };
+// Proxy utilities
+import createHelperRegistry from './proxy/createHelperRegistry.js';
+import createBlockProxy from './proxy/createBlockProxy.js';
+import createPageManager from './proxy/createPageManager.js';
+export { createHelperRegistry, createBlockProxy, createPageManager };

package/dist/init/index.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+async function init() {
+    const cwd = process.cwd();
+    const e2eDir = path.join(cwd, 'e2e');
+    console.log('Setting up Lowdefy e2e testing...\n');
+    // Create e2e directory
+    if (!fs.existsSync(e2eDir)) {
+        fs.mkdirSync(e2eDir, {
+            recursive: true
+        });
+        console.log('Created e2e/');
+    }
+    // Copy templates
+    const templates = [
+        {
+            src: 'playwright.config.js.template',
+            dest: 'playwright.config.js'
+        },
+        {
+            src: 'example.spec.js.template',
+            dest: 'example.spec.js'
+        }
+    ];
+    for (const { src, dest } of templates){
+        const srcPath = path.join(__dirname, 'templates', src);
+        const destPath = path.join(e2eDir, dest);
+        if (!fs.existsSync(destPath)) {
+            fs.copyFileSync(srcPath, destPath);
+            console.log(`Created e2e/${dest}`);
+        } else {
+            console.log(`Skipped e2e/${dest} (already exists)`);
+        }
+    }
+    // Update package.json
+    const pkgPath = path.join(cwd, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        let updated = false;
+        pkg.scripts = pkg.scripts || {};
+        if (!pkg.scripts.e2e) {
+            pkg.scripts.e2e = 'playwright test';
+            updated = true;
+        }
+        if (!pkg.scripts['e2e:ui']) {
+            pkg.scripts['e2e:ui'] = 'playwright test --ui';
+            updated = true;
+        }
+        if (updated) {
+            fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+            console.log('Updated package.json with e2e scripts');
+        }
+    }
+    console.log('\n✓ E2E testing setup complete!\n');
+    console.log('Next steps:');
+    console.log('  1. Install dependencies: pnpm add -D @lowdefy/e2e-utils @playwright/test');
+    console.log('  2. Install browsers: npx playwright install chromium');
+    console.log('  3. Run tests: pnpm e2e');
+    console.log('  4. Or use UI mode: pnpm e2e:ui');
+}
+init().catch((err)=>{
+    console.error('Error:', err.message);
+    process.exit(1);
+});

package/dist/init/templates/example.spec.js.template

@@ -0,0 +1,28 @@
+import { test, expect } from '@playwright/test';
+import { ldf, button, textInput, selector } from '@lowdefy/e2e-utils';
+
+test('homepage loads', async ({ page }) => {
+  await ldf.goto(page, '/');
+
+  // Replace with your own assertions
+  await expect(page).toHaveTitle(/./);
+});
+
+// Example: Testing a form submission
+// Uncomment and modify for your app:
+//
+// test('submit contact form', async ({ page }) => {
+//   await ldf.goto(page, '/contact');
+//
+//   // Fill form fields
+//   await textInput.fill(page, 'name_input', 'John Doe');
+//   await textInput.fill(page, 'email_input', 'john@example.com');
+//   await selector.select(page, 'category', 'Support');
+//
+//   // Submit
+//   await button.click(page, 'submit_btn');
+//
+//   // Wait for request and verify
+//   await ldf.waitForRequest(page, 'send_message');
+//   await ldf.expectNavigation(page, '/thank-you');
+// });

package/dist/init/templates/playwright.config.js.template

@@ -0,0 +1,6 @@
+import { createConfig } from '@lowdefy/e2e-utils/config';
+
+export default createConfig({
+  appDir: './',
+  port: 3000,
+});

package/dist/proxy/createBlockProxy.js

@@ -0,0 +1,44 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ function createBlockProxy({ page, blockMap, helperRegistry }) {
+    return new Proxy({}, {
+        get (_, blockId) {
+            if (typeof blockId !== 'string') return undefined;
+            const blockInfo = blockMap[blockId];
+            if (!blockInfo) {
+                const available = Object.keys(blockMap).join(', ');
+                throw new Error(`Block "${blockId}" not found on page. Available blocks: ${available || '(none)'}`);
+            }
+            // Return a proxy that routes method calls to the helper
+            return new Proxy({}, {
+                get (_, methodName) {
+                    if (typeof methodName !== 'string') return undefined;
+                    return async (...args)=>{
+                        const helper = await helperRegistry.get(blockInfo.helper);
+                        if (!helper) {
+                            throw new Error(`Block type "${blockInfo.type}" does not have e2e helpers.\n` + `Add e2e.js to: ${blockInfo.helper.replace('/e2e/', '/src/blocks/')}/e2e.js`);
+                        }
+                        if (typeof helper[methodName] !== 'function') {
+                            const available = Object.keys(helper).filter((k)=>typeof helper[k] === 'function').join(', ');
+                            throw new Error(`Block type "${blockInfo.type}" has no method "${methodName}".\n` + `Available methods: ${available || '(none)'}`);
+                        }
+                        return helper[methodName](page, blockId, ...args);
+                    };
+                }
+            });
+        }
+    });
+}
+export default createBlockProxy;

package/dist/proxy/createHelperRegistry.js

@@ -0,0 +1,37 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ function createHelperRegistry() {
+    const cache = new Map();
+    return {
+        async get (helperPath) {
+            if (!cache.has(helperPath)) {
+                try {
+                    const module = await import(helperPath);
+                    cache.set(helperPath, module.default ?? module);
+                } catch (e) {
+                    cache.set(helperPath, null);
+                }
+            }
+            return cache.get(helperPath);
+        },
+        has (helperPath) {
+            return cache.has(helperPath);
+        },
+        clear () {
+            cache.clear();
+        }
+    };
+}
+export default createHelperRegistry;

package/dist/proxy/createPageManager.js

@@ -0,0 +1,53 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { getBlock } from '../core/locators.js';
+import { waitForReady } from '../core/navigation.js';
+import { getState, getBlockState, expectState } from '../core/state.js';
+import createBlockProxy from './createBlockProxy.js';
+function createPageManager({ page, manifest, helperRegistry }) {
+    let currentBlockMap = null;
+    let currentPageId = null;
+    return {
+        async goto (path) {
+            await page.goto(path);
+            await waitForReady(page);
+            currentPageId = await page.evaluate(()=>window.lowdefy?.pageId);
+            currentBlockMap = manifest.pages[currentPageId];
+            if (!currentBlockMap) {
+                const available = Object.keys(manifest.pages).join(', ');
+                throw new Error(`Page "${currentPageId}" not found in manifest. Available pages: ${available || '(none)'}`);
+            }
+        },
+        get blocks () {
+            if (!currentBlockMap) {
+                throw new Error('Call goto() before accessing blocks');
+            }
+            return createBlockProxy({
+                page,
+                blockMap: currentBlockMap,
+                helperRegistry
+            });
+        },
+        get pageId () {
+            return currentPageId;
+        },
+        // Core helpers
+        block: (blockId)=>getBlock(page, blockId),
+        getState: ()=>getState(page),
+        getBlockState: (blockId)=>getBlockState(page, blockId),
+        expectState: (key, value, opts)=>expectState(page, key, value, opts)
+    };
+}
+export default createPageManager;

package/dist/testPrep/extractBlockMap.js

@@ -0,0 +1,51 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ function getBlocksArray(container) {
+    if (!container) return [];
+    if (Array.isArray(container)) return container;
+    if (container['~arr']) return container['~arr'];
+    return [];
+}
+function extractBlockMap({ pageConfig, typesBlocks }) {
+    const blockMap = {};
+    function traverse(obj) {
+        if (!obj || typeof obj !== 'object') return;
+        // If this object has blockId and type, record it
+        if (obj.blockId && obj.type) {
+            const packageName = typesBlocks[obj.type]?.package;
+            if (packageName) {
+                blockMap[obj.blockId] = {
+                    type: obj.type,
+                    helper: `${packageName}/e2e/${obj.type}`
+                };
+            }
+        }
+        // Traverse areas - area.blocks is { "~arr": [...blocks...] }
+        if (obj.areas) {
+            Object.values(obj.areas).forEach((area)=>{
+                const blocks = getBlocksArray(area.blocks);
+                blocks.forEach((block)=>traverse(block));
+            });
+        }
+        // Traverse direct blocks array (may also be { "~arr": [...] })
+        if (obj.blocks) {
+            const blocks = getBlocksArray(obj.blocks);
+            blocks.forEach((block)=>traverse(block));
+        }
+    }
+    traverse(pageConfig);
+    return blockMap;
+}
+export default extractBlockMap;

package/dist/testPrep/generateManifest.js

@@ -0,0 +1,52 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import fs from 'fs';
+import path from 'path';
+import extractBlockMap from './extractBlockMap.js';
+function generateManifest({ buildDir = '.lowdefy' }) {
+    const typesPath = path.join(buildDir, 'types.json');
+    if (!fs.existsSync(typesPath)) {
+        throw new Error(`Build artifacts not found at ${buildDir}. Run 'lowdefy build' first.`);
+    }
+    const types = JSON.parse(fs.readFileSync(typesPath, 'utf-8'));
+    const pagesDir = path.join(buildDir, 'pages');
+    const manifest = {
+        pages: {}
+    };
+    if (fs.existsSync(pagesDir)) {
+        for (const pageId of fs.readdirSync(pagesDir)){
+            const pageConfigPath = path.join(pagesDir, pageId, `${pageId}.json`);
+            if (fs.existsSync(pageConfigPath)) {
+                const pageConfig = JSON.parse(fs.readFileSync(pageConfigPath, 'utf-8'));
+                manifest.pages[pageId] = extractBlockMap({
+                    pageConfig,
+                    typesBlocks: types.blocks ?? {}
+                });
+            }
+        }
+    }
+    const manifestPath = path.join(buildDir, 'e2e-manifest.json');
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+    return manifest;
+}
+function loadManifest({ buildDir = '.lowdefy' } = {}) {
+    const manifestPath = path.join(buildDir, 'e2e-manifest.json');
+    if (!fs.existsSync(manifestPath)) {
+        throw new Error(`E2E manifest not found at ${manifestPath}. Run test prep or generateManifest() first.`);
+    }
+    return JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+}
+export { generateManifest, loadManifest };
+export default generateManifest;

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@lowdefy/e2e-utils",
+  "version": "0.0.0-experimental-20260202125814",
+  "license": "Apache-2.0",
+  "description": "Lowdefy E2E Testing Utilities for Playwright",
+  "homepage": "https://lowdefy.com",
+  "keywords": [
+    "lowdefy",
+    "e2e",
+    "playwright",
+    "testing"
+  ],
+  "bugs": {
+    "url": "https://github.com/lowdefy/lowdefy/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lowdefy/lowdefy.git"
+  },
+  "type": "module",
+  "bin": {
+    "lowdefy-e2e": "./dist/init/index.js"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./config": "./dist/config.js",
+    "./fixtures": "./dist/fixtures/index.js"
+  },
+  "files": [
+    "dist/*"
+  ],
+  "dependencies": {
+    "@playwright/test": "1.50.1"
+  },
+  "peerDependencies": {
+    "@lowdefy/blocks-antd": "0.0.0-experimental-20260202125814"
+  },
+  "peerDependenciesMeta": {
+    "@lowdefy/blocks-antd": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@swc/cli": "0.1.63",
+    "@swc/core": "1.3.99",
+    "copyfiles": "2.4.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "swc src --out-dir dist --config-file ../../../.swcrc --delete-dir-on-start && pnpm copyfiles",
+    "clean": "rm -rf dist",
+    "copyfiles": "copyfiles -u 1 \"./src/init/templates/*\" dist"
+  }
+}