@tachybase/test 0.23.8

package/lib/e2e/e2eUtils.js

@@ -0,0 +1,633 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var e2eUtils_exports = {};
+__export(e2eUtils_exports, {
+  NocoPage: () => NocoPage,
+  createBlockInPage: () => createBlockInPage,
+  defineConfig: () => import_defineConfig.defineConfig,
+  expectInitializerMenu: () => expectInitializerMenu,
+  expectSettingsMenu: () => expectSettingsMenu,
+  omitSomeFields: () => omitSomeFields,
+  test: () => test
+});
+module.exports = __toCommonJS(e2eUtils_exports);
+var import_faker = require("@faker-js/faker");
+var import_shared = require("@formily/shared");
+var import_test = require("@playwright/test");
+var import_lodash = __toESM(require("lodash"));
+var import_defineConfig = require("./defineConfig");
+__reExport(e2eUtils_exports, require("@playwright/test"), module.exports);
+const PORT = process.env.APP_PORT || 2e4;
+const APP_BASE_URL = process.env.APP_BASE_URL || `http://localhost:${PORT}`;
+const _NocoPage = class _NocoPage {
+  constructor(options, page) {
+    this.options = options;
+    this.page = page;
+    this._waitForInit = this.init();
+  }
+  url;
+  uid;
+  collectionsName;
+  _waitForInit;
+  async init() {
+    var _a, _b, _c, _d, _e, _f, _g;
+    if ((_b = (_a = this.options) == null ? void 0 : _a.collections) == null ? void 0 : _b.length) {
+      const collections = omitSomeFields(this.options.collections);
+      this.collectionsName = collections.map((item) => item.name);
+      await createCollections(collections);
+    }
+    this.uid = await createPage({
+      type: (_c = this.options) == null ? void 0 : _c.type,
+      name: (_d = this.options) == null ? void 0 : _d.name,
+      pageSchema: (_e = this.options) == null ? void 0 : _e.pageSchema,
+      url: (_f = this.options) == null ? void 0 : _f.url
+    });
+    this.url = `${((_g = this.options) == null ? void 0 : _g.basePath) || "/admin/"}${this.uid}`;
+  }
+  async goto() {
+    var _a;
+    await this._waitForInit;
+    await ((_a = this.page) == null ? void 0 : _a.goto(this.url));
+  }
+  async getUrl() {
+    await this._waitForInit;
+    return this.url;
+  }
+  async getUid() {
+    await this._waitForInit;
+    return this.uid;
+  }
+  async waitForInit() {
+    await this._waitForInit;
+    return this;
+  }
+  async destroy() {
+    var _a;
+    if (this.uid) {
+      await deletePage(this.uid);
+      this.uid = void 0;
+    }
+    if ((_a = this.collectionsName) == null ? void 0 : _a.length) {
+      await deleteCollections(this.collectionsName);
+      this.collectionsName = void 0;
+    }
+  }
+};
+__name(_NocoPage, "NocoPage");
+let NocoPage = _NocoPage;
+const _test = import_test.test.extend({
+  mockPage: /* @__PURE__ */ __name(async ({ page }, use) => {
+    const nocoPages = [];
+    const mockPage = /* @__PURE__ */ __name((config) => {
+      const nocoPage = new NocoPage(config, page);
+      nocoPages.push(nocoPage);
+      return nocoPage;
+    }, "mockPage");
+    await use(mockPage);
+    for (const nocoPage of nocoPages) {
+      await nocoPage.destroy();
+      await setDefaultRole("root");
+    }
+  }, "mockPage"),
+  mockManualDestroyPage: /* @__PURE__ */ __name(async ({ browser }, use) => {
+    const mockManualDestroyPage = /* @__PURE__ */ __name((config) => {
+      const nocoPage = new NocoPage(config);
+      return nocoPage;
+    }, "mockManualDestroyPage");
+    await use(mockManualDestroyPage);
+  }, "mockManualDestroyPage"),
+  createCollections: /* @__PURE__ */ __name(async ({ page }, use) => {
+    let collectionsName = [];
+    const _createCollections = /* @__PURE__ */ __name(async (collectionSettings) => {
+      collectionSettings = omitSomeFields(
+        Array.isArray(collectionSettings) ? collectionSettings : [collectionSettings]
+      );
+      collectionsName = [...collectionsName, ...collectionSettings.map((item) => item.name)];
+      await createCollections(collectionSettings);
+    }, "_createCollections");
+    await use(_createCollections);
+    if (collectionsName.length) {
+      await deleteCollections(import_lodash.default.uniq(collectionsName));
+    }
+  }, "createCollections"),
+  mockCollections: /* @__PURE__ */ __name(async ({ page }, use) => {
+    let collectionsName = [];
+    const destroy = /* @__PURE__ */ __name(async () => {
+      if (collectionsName.length) {
+        await deleteCollections(import_lodash.default.uniq(collectionsName));
+      }
+    }, "destroy");
+    const mockCollections = /* @__PURE__ */ __name(async (collectionSettings) => {
+      collectionSettings = omitSomeFields(collectionSettings);
+      collectionsName = [...collectionsName, ...collectionSettings.map((item) => item.name)];
+      return createCollections(collectionSettings);
+    }, "mockCollections");
+    await use(mockCollections);
+    await destroy();
+  }, "mockCollections"),
+  mockCollection: /* @__PURE__ */ __name(async ({ page }, use) => {
+    let collectionsName = [];
+    const destroy = /* @__PURE__ */ __name(async () => {
+      if (collectionsName.length) {
+        await deleteCollections(import_lodash.default.uniq(collectionsName));
+      }
+    }, "destroy");
+    const mockCollection = /* @__PURE__ */ __name(async (collectionSetting, options) => {
+      const collectionSettings = omitSomeFields([collectionSetting]);
+      collectionsName = [...collectionsName, ...collectionSettings.map((item) => item.name)];
+      return createCollections(collectionSettings);
+    }, "mockCollection");
+    await use(mockCollection);
+    await destroy();
+  }, "mockCollection"),
+  mockRecords: /* @__PURE__ */ __name(async ({ page }, use) => {
+    const mockRecords = /* @__PURE__ */ __name(async (collectionName, count = 3, data) => {
+      if (import_lodash.default.isArray(count)) {
+        data = count;
+        count = data.length;
+      }
+      return createRandomData(collectionName, count, data);
+    }, "mockRecords");
+    await use(mockRecords);
+    const deletePromises = [
+      deleteRecords("users", { id: { $ne: 1 } }),
+      deleteRecords("roles", { name: { $ne: ["root", "admin", "member"] } })
+    ];
+    await Promise.all(deletePromises);
+  }, "mockRecords"),
+  mockRecord: /* @__PURE__ */ __name(async ({ page }, use) => {
+    const mockRecord = /* @__PURE__ */ __name(async (collectionName, data) => {
+      const result = await createRandomData(collectionName, 1, data);
+      return result[0];
+    }, "mockRecord");
+    await use(mockRecord);
+    const deletePromises = [
+      deleteRecords("users", { id: { $ne: 1 } }),
+      deleteRecords("roles", { name: { $ne: ["root", "admin", "member"] } })
+    ];
+    await Promise.all(deletePromises);
+  }, "mockRecord"),
+  deletePage: /* @__PURE__ */ __name(async ({ page }, use) => {
+    const deletePage2 = /* @__PURE__ */ __name(async (pageName) => {
+      await page.getByText(pageName, { exact: true }).hover();
+      await page.getByRole("button", { name: "designer-schema-settings-" }).hover();
+      await page.getByRole("menuitem", { name: "Delete", exact: true }).click();
+      await page.getByRole("button", { name: "OK", exact: true }).click();
+    }, "deletePage");
+    await use(deletePage2);
+    const deletePromises = [
+      deleteRecords("users", { id: { $ne: 1 } }),
+      deleteRecords("roles", { name: { $ne: ["root", "admin", "member"] } })
+    ];
+    await Promise.all(deletePromises);
+  }, "deletePage"),
+  mockRole: /* @__PURE__ */ __name(async ({ page }, use) => {
+    const mockRole = /* @__PURE__ */ __name(async (roleSetting) => {
+      return createRole(roleSetting);
+    }, "mockRole");
+    await use(mockRole);
+  }, "mockRole"),
+  updateRole: /* @__PURE__ */ __name(async ({ page }, use) => {
+    const updateRole2 = /* @__PURE__ */ __name(async (roleSetting) => {
+      return updateRole2(roleSetting);
+    }, "updateRole");
+    await use(updateRole2);
+  }, "updateRole"),
+  mockExternalDataSource: /* @__PURE__ */ __name(async ({ browser }, use) => {
+    const mockExternalDataSource = /* @__PURE__ */ __name(async (DataSourceSetting) => {
+      return createExternalDataSource(DataSourceSetting);
+    }, "mockExternalDataSource");
+    await use(mockExternalDataSource);
+  }, "mockExternalDataSource"),
+  destoryExternalDataSource: /* @__PURE__ */ __name(async ({ browser }, use) => {
+    const destoryDataSource = /* @__PURE__ */ __name(async (key) => {
+      return destoryExternalDataSource(key);
+    }, "destoryDataSource");
+    await use(destoryDataSource);
+  }, "destoryExternalDataSource"),
+  clearBlockTemplates: /* @__PURE__ */ __name(async ({ page }, use) => {
+    const clearBlockTemplates = /* @__PURE__ */ __name(async () => {
+      const api = await import_test.request.newContext({
+        storageState: process.env.PLAYWRIGHT_AUTH_FILE
+      });
+      const state = await api.storageState();
+      const headers = getHeaders(state);
+      const filter = {
+        key: { $exists: true }
+      };
+      const result = await api.post(`/api/uiSchemaTemplates:destroy?filter=${JSON.stringify(filter)}`, {
+        headers
+      });
+      if (!result.ok()) {
+        throw new Error(await result.text());
+      }
+    }, "clearBlockTemplates");
+    try {
+      await use(clearBlockTemplates);
+    } catch (error) {
+      await clearBlockTemplates();
+    }
+  }, "clearBlockTemplates")
+});
+const test = Object.assign(_test, {
+  /** 只运行在 postgres 数据库中 */
+  pgOnly: process.env.DB_DIALECT == "postgres" ? _test : _test.skip
+});
+const getStorageItem = /* @__PURE__ */ __name((key, storageState) => {
+  var _a, _b;
+  return (_b = (_a = storageState.origins.find((item) => item.origin === APP_BASE_URL)) == null ? void 0 : _a.localStorage.find((item) => item.name === key)) == null ? void 0 : _b.value;
+}, "getStorageItem");
+const updateUidOfPageSchema = /* @__PURE__ */ __name((uiSchema) => {
+  if (!uiSchema) {
+    return;
+  }
+  if (uiSchema["x-uid"]) {
+    uiSchema["x-uid"] = (0, import_shared.uid)();
+  }
+  if (uiSchema.properties) {
+    Object.keys(uiSchema.properties).forEach((key) => {
+      updateUidOfPageSchema(uiSchema.properties[key]);
+    });
+  }
+  return uiSchema;
+}, "updateUidOfPageSchema");
+const createPage = /* @__PURE__ */ __name(async (options) => {
+  const { type = "page", url, name, pageSchema } = options || {};
+  const api = await import_test.request.newContext({
+    storageState: process.env.PLAYWRIGHT_AUTH_FILE
+  });
+  const typeToSchema = {
+    group: {
+      "x-component": "Menu.SubMenu",
+      "x-component-props": {}
+    },
+    page: {
+      "x-component": "Menu.Item",
+      "x-component-props": {}
+    },
+    link: {
+      "x-component": "Menu.URL",
+      "x-component-props": {
+        href: url
+      }
+    }
+  };
+  const state = await api.storageState();
+  const headers = getHeaders(state);
+  const pageUid = (0, import_shared.uid)();
+  const gridName = (0, import_shared.uid)();
+  const result = await api.post(`/api/uiSchemas:insertAdjacent/default-admin-menu?position=beforeEnd`, {
+    headers,
+    data: {
+      schema: {
+        _isJSONSchemaObject: true,
+        version: "2.0",
+        type: "void",
+        title: name || pageUid,
+        ...typeToSchema[type],
+        "x-decorator": "ACLMenuItemProvider",
+        "x-server-hooks": [
+          { type: "onSelfCreate", method: "bindMenuToRole" },
+          { type: "onSelfSave", method: "extractTextToLocale" }
+        ],
+        properties: {
+          page: updateUidOfPageSchema(pageSchema) || {
+            _isJSONSchemaObject: true,
+            version: "2.0",
+            type: "void",
+            "x-component": "Page",
+            "x-async": true,
+            properties: {
+              [gridName]: {
+                _isJSONSchemaObject: true,
+                version: "2.0",
+                type: "void",
+                "x-component": "Grid",
+                "x-initializer": "page:addBlock",
+                "x-uid": (0, import_shared.uid)(),
+                name: gridName
+              }
+            },
+            "x-uid": (0, import_shared.uid)(),
+            name: "page"
+          }
+        },
+        name: (0, import_shared.uid)(),
+        "x-uid": pageUid
+      },
+      wrap: null
+    }
+  });
+  if (!result.ok()) {
+    throw new Error(await result.text());
+  }
+  return pageUid;
+}, "createPage");
+const deletePage = /* @__PURE__ */ __name(async (pageUid) => {
+  const api = await import_test.request.newContext({
+    storageState: process.env.PLAYWRIGHT_AUTH_FILE
+  });
+  const state = await api.storageState();
+  const headers = getHeaders(state);
+  const result = await api.post(`/api/uiSchemas:remove/${pageUid}`, {
+    headers
+  });
+  if (!result.ok()) {
+    throw new Error(await result.text());
+  }
+}, "deletePage");
+const deleteCollections = /* @__PURE__ */ __name(async (collectionNames) => {
+  const api = await import_test.request.newContext({
+    storageState: process.env.PLAYWRIGHT_AUTH_FILE
+  });
+  const state = await api.storageState();
+  const headers = getHeaders(state);
+  const params = collectionNames.map((name) => `filterByTk[]=${name}`).join("&");
+  const result = await api.post(`/api/collections:destroy?${params}`, {
+    headers,
+    params: {
+      cascade: true
+    }
+  });
+  if (!result.ok()) {
+    throw new Error(await result.text());
+  }
+}, "deleteCollections");
+const deleteRecords = /* @__PURE__ */ __name(async (collectionName, filter) => {
+  const api = await import_test.request.newContext({
+    storageState: process.env.PLAYWRIGHT_AUTH_FILE
+  });
+  const state = await api.storageState();
+  const headers = getHeaders(state);
+  const result = await api.post(`/api/${collectionName}:destroy?filter=${JSON.stringify(filter)}`, {
+    headers
+  });
+  if (!result.ok()) {
+    throw new Error(await result.text());
+  }
+}, "deleteRecords");
+const omitSomeFields = /* @__PURE__ */ __name((collectionSettings) => {
+  return collectionSettings.map((collection) => {
+    var _a;
+    return {
+      ...import_lodash.default.omit(collection, ["key"]),
+      fields: (_a = collection.fields) == null ? void 0 : _a.map((field) => import_lodash.default.omit(field, ["key", "collectionName"]))
+    };
+  });
+}, "omitSomeFields");
+const createCollections = /* @__PURE__ */ __name(async (collectionSettings) => {
+  const api = await import_test.request.newContext({
+    storageState: process.env.PLAYWRIGHT_AUTH_FILE
+  });
+  const state = await api.storageState();
+  const headers = getHeaders(state);
+  collectionSettings = Array.isArray(collectionSettings) ? collectionSettings : [collectionSettings];
+  const result = await api.post(`/api/collections:mock`, {
+    headers,
+    data: collectionSettings
+  });
+  if (!result.ok()) {
+    throw new Error(await result.text());
+  }
+  return (await result.json()).data;
+}, "createCollections");
+const createRole = /* @__PURE__ */ __name(async (roleSetting) => {
+  const api = await import_test.request.newContext({
+    storageState: process.env.PLAYWRIGHT_AUTH_FILE
+  });
+  const state = await api.storageState();
+  const headers = getHeaders(state);
+  const name = roleSetting.name || (0, import_shared.uid)();
+  const result = await api.post(`/api/users/1/roles:create`, {
+    headers,
+    data: { ...roleSetting, name, title: name }
+  });
+  if (!result.ok()) {
+    throw new Error(await result.text());
+  }
+  const roleData = (await result.json()).data;
+  await setDefaultRole(name);
+  return roleData;
+}, "createRole");
+const updateRole = /* @__PURE__ */ __name(async (roleSetting) => {
+  const api = await import_test.request.newContext({
+    storageState: process.env.PLAYWRIGHT_AUTH_FILE
+  });
+  const state = await api.storageState();
+  const headers = getHeaders(state);
+  const name = roleSetting.name;
+  const dataSourceKey = roleSetting.dataSourceKey;
+  const url = !dataSourceKey ? `/api/roles:update?filterByTk=${name}` : `/api/dataSources/${dataSourceKey}/roles:update?filterByTk=${name}`;
+  const result = await api.post(url, {
+    headers,
+    data: { ...roleSetting }
+  });
+  if (!result.ok()) {
+    throw new Error(await result.text());
+  }
+  const roleData = (await result.json()).data;
+  return roleData;
+}, "updateRole");
+const setDefaultRole = /* @__PURE__ */ __name(async (name) => {
+  const api = await import_test.request.newContext({
+    storageState: process.env.PLAYWRIGHT_AUTH_FILE
+  });
+  const state = await api.storageState();
+  const headers = getHeaders(state);
+  await api.post(`/api/users:setDefaultRole`, {
+    headers,
+    data: { roleName: name }
+  });
+}, "setDefaultRole");
+const createExternalDataSource = /* @__PURE__ */ __name(async (dataSourceSetting) => {
+  const api = await import_test.request.newContext({
+    storageState: process.env.PLAYWRIGHT_AUTH_FILE
+  });
+  const state = await api.storageState();
+  const headers = getHeaders(state);
+  const result = await api.post(`/api/dataSources:create`, {
+    headers,
+    data: { ...dataSourceSetting }
+  });
+  if (!result.ok()) {
+    throw new Error(await result.text());
+  }
+  const dataSourceData = (await result.json()).data;
+  return dataSourceData;
+}, "createExternalDataSource");
+const destoryExternalDataSource = /* @__PURE__ */ __name(async (key) => {
+  const api = await import_test.request.newContext({
+    storageState: process.env.PLAYWRIGHT_AUTH_FILE
+  });
+  const state = await api.storageState();
+  const headers = getHeaders(state);
+  const result = await api.post(`/api/dataSources:destroy?filterByTk=${key}`, {
+    headers
+  });
+  if (!result.ok()) {
+    throw new Error(await result.text());
+  }
+  const dataSourceData = (await result.json()).data;
+  return dataSourceData;
+}, "destoryExternalDataSource");
+const generateFakerData = /* @__PURE__ */ __name((collectionSetting) => {
+  var _a;
+  const excludeField = ["id", "createdAt", "updatedAt", "createdBy", "updatedBy"];
+  const basicInterfaceToData = {
+    input: /* @__PURE__ */ __name(() => import_faker.faker.lorem.words(), "input"),
+    textarea: /* @__PURE__ */ __name(() => import_faker.faker.lorem.paragraph(), "textarea"),
+    richText: /* @__PURE__ */ __name(() => import_faker.faker.lorem.paragraph(), "richText"),
+    phone: /* @__PURE__ */ __name(() => import_faker.faker.phone.number(), "phone"),
+    email: /* @__PURE__ */ __name(() => import_faker.faker.internet.email(), "email"),
+    url: /* @__PURE__ */ __name(() => import_faker.faker.internet.url(), "url"),
+    integer: /* @__PURE__ */ __name(() => import_faker.faker.number.int(), "integer"),
+    number: /* @__PURE__ */ __name(() => import_faker.faker.number.int(), "number"),
+    percent: /* @__PURE__ */ __name(() => import_faker.faker.number.float(), "percent"),
+    password: /* @__PURE__ */ __name(() => import_faker.faker.internet.password(), "password"),
+    color: /* @__PURE__ */ __name(() => import_faker.faker.internet.color(), "color"),
+    icon: /* @__PURE__ */ __name(() => "checkcircleoutlined", "icon"),
+    datetime: /* @__PURE__ */ __name(() => import_faker.faker.date.anytime({ refDate: "2023-09-21T00:00:00.000Z" }), "datetime"),
+    time: /* @__PURE__ */ __name(() => "00:00:00", "time")
+  };
+  const result = {};
+  (_a = collectionSetting.fields) == null ? void 0 : _a.forEach((field) => {
+    if (field.name && excludeField.includes(field.name)) {
+      return;
+    }
+    if (basicInterfaceToData[field.interface] && field.name) {
+      result[field.name] = basicInterfaceToData[field.interface]();
+    }
+  });
+  return result;
+}, "generateFakerData");
+const createRandomData = /* @__PURE__ */ __name(async (collectionName, count = 10, data) => {
+  const api = await import_test.request.newContext({
+    storageState: process.env.PLAYWRIGHT_AUTH_FILE
+  });
+  const state = await api.storageState();
+  const headers = getHeaders(state);
+  const result = await api.post(`/api/${collectionName}:mock?count=${count}`, {
+    headers,
+    data
+  });
+  if (!result.ok()) {
+    throw new Error(await result.text());
+  }
+  return (await result.json()).data;
+}, "createRandomData");
+function getHeaders(storageState) {
+  var _a;
+  const headers = {};
+  const token = getStorageItem("TACHYBASE_TOKEN", storageState);
+  const auth = getStorageItem("TACHYBASE_AUTH", storageState);
+  const subAppName = (_a = new URL(APP_BASE_URL).pathname.match(/^\/apps\/([^/]*)\/*/)) == null ? void 0 : _a[1];
+  const hostName = new URL(APP_BASE_URL).host;
+  const locale = getStorageItem("TACHYBASE_LOCALE", storageState);
+  const timezone = "+08:00";
+  const withAclMeta = "true";
+  const role = getStorageItem("TACHYBASE_ROLE", storageState);
+  if (token) {
+    headers.Authorization = `Bearer ${token}`;
+  }
+  if (auth) {
+    headers["X-Authenticator"] = auth;
+  }
+  if (subAppName) {
+    headers["X-App"] = subAppName;
+  }
+  if (hostName) {
+    headers["X-Hostname"] = hostName;
+  }
+  if (locale) {
+    headers["X-Locale"] = locale;
+  }
+  if (timezone) {
+    headers["X-Timezone"] = timezone;
+  }
+  if (withAclMeta) {
+    headers["X-With-Acl-Meta"] = withAclMeta;
+  }
+  if (role) {
+    headers["X-Role"] = role;
+  }
+  return headers;
+}
+__name(getHeaders, "getHeaders");
+async function expectSettingsMenu({
+  showMenu,
+  supportedOptions,
+  page,
+  unsupportedOptions
+}) {
+  await showMenu();
+  for (const option of supportedOptions) {
+    await (0, import_test.expect)(page.getByRole("menuitem", { name: option })).toBeVisible();
+  }
+  if (unsupportedOptions) {
+    for (const option of unsupportedOptions) {
+      await (0, import_test.expect)(page.getByRole("menuitem", { name: option })).not.toBeVisible();
+    }
+  }
+}
+__name(expectSettingsMenu, "expectSettingsMenu");
+async function expectInitializerMenu({ showMenu, supportedOptions, page }) {
+  await showMenu();
+  for (const option of supportedOptions) {
+    await (0, import_test.expect)(page.getByRole("menuitem", { name: option }).first()).toBeVisible();
+  }
+}
+__name(expectInitializerMenu, "expectInitializerMenu");
+const createBlockInPage = /* @__PURE__ */ __name(async (page, name) => {
+  await page.getByLabel("schema-initializer-Grid-page:addBlock").hover();
+  if (name === "Form") {
+    await page.getByText("Form", { exact: true }).first().hover();
+  } else if (name === "Filter form") {
+    await page.getByText("Form", { exact: true }).nth(1).hover();
+  } else {
+    await page.getByText(name, { exact: true }).hover();
+  }
+  if (name === "Markdown") {
+    await page.getByRole("menuitem", { name: "Markdown" }).click();
+  } else {
+    await page.getByRole("menuitem", { name: "Users" }).click();
+  }
+  await page.mouse.move(300, 0);
+}, "createBlockInPage");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NocoPage,
+  createBlockInPage,
+  defineConfig,
+  expectInitializerMenu,
+  expectSettingsMenu,
+  omitSomeFields,
+  test,
+  ...require("@playwright/test")
+});

package/lib/e2e/index.d.ts

@@ -0,0 +1,3 @@
+export * from './e2eUtils';
+export * from './templatesOfCollection';
+export * from './templatesOfPage';

package/lib/e2e/index.js

@@ -0,0 +1,25 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var e2e_exports = {};
+module.exports = __toCommonJS(e2e_exports);
+__reExport(e2e_exports, require("./e2eUtils"), module.exports);
+__reExport(e2e_exports, require("./templatesOfCollection"), module.exports);
+__reExport(e2e_exports, require("./templatesOfPage"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./e2eUtils"),
+  ...require("./templatesOfCollection"),
+  ...require("./templatesOfPage")
+});