@bernierllc/content-management-tests 0.1.1

package/dist/index.js

@@ -0,0 +1,1104 @@
+"use client";
+"use strict";
+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 __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __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);
+
+// jest.config.js
+var require_jest_config = __commonJS({
+  "jest.config.js"(exports2, module2) {
+    "use strict";
+    module2.exports = {
+      testEnvironment: "jsdom",
+      setupFilesAfterEnv: ["<rootDir>/src/setup/jest.setup.ts"],
+      testMatch: [
+        "<rootDir>/src/**/*.test.ts",
+        "<rootDir>/src/**/*.test.tsx"
+      ],
+      collectCoverageFrom: [
+        "src/**/*.{ts,tsx}",
+        "!src/**/*.test.{ts,tsx}",
+        "!src/**/*.stories.{ts,tsx}",
+        "!src/setup/**",
+        "!src/fixtures/**",
+        "!src/mocks/**"
+      ],
+      coverageThreshold: {
+        global: {
+          branches: 80,
+          functions: 80,
+          lines: 80,
+          statements: 80
+        }
+      },
+      moduleNameMapper: {
+        "^@/(.*)$": "<rootDir>/src/$1",
+        "^@test/(.*)$": "<rootDir>/src/test-utils/$1",
+        "^@fixtures/(.*)$": "<rootDir>/src/fixtures/$1",
+        "^@mocks/(.*)$": "<rootDir>/src/mocks/$1"
+      },
+      transform: {
+        "^.+\\.(ts|tsx)$": "ts-jest"
+      }
+    };
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  TestAssertions: () => TestAssertions,
+  TestDataGenerator: () => TestDataGenerator,
+  TestHelpers: () => TestHelpers,
+  TestRunner: () => TestRunner,
+  TestUtils: () => TestUtils,
+  apiResponseFixtures: () => apiResponseFixtures,
+  configFixtures: () => configFixtures,
+  contentFixtures: () => contentFixtures,
+  contentTypeFixtures: () => contentTypeFixtures,
+  createTestUtils: () => createTestUtils,
+  dateFixtures: () => dateFixtures,
+  defaultTestConfig: () => defaultTestConfig,
+  expect: () => import_test3.expect,
+  fireEvent: () => import_react2.fireEvent,
+  jestConfig: () => import_jest.default,
+  playwrightConfig: () => playwright_config_default,
+  render: () => import_react2.render,
+  screen: () => import_react2.screen,
+  test: () => import_test3.test,
+  testDataGenerators: () => testDataGenerators,
+  userEvent: () => import_user_event.userEvent,
+  userFixtures: () => userFixtures,
+  waitFor: () => import_react2.waitFor,
+  workflowFixtures: () => workflowFixtures
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/test-utils/test-utils.ts
+var import_test = require("@playwright/test");
+var TestUtils = class {
+  constructor(page, context) {
+    this.page = page;
+    this.context = context;
+  }
+  // Navigation helpers
+  async navigateTo(path) {
+    await this.page.goto(path);
+    await this.page.waitForLoadState("networkidle");
+  }
+  async waitForElement(selector, timeout = 5e3) {
+    await this.page.waitForSelector(selector, { timeout });
+  }
+  async waitForText(text, timeout = 5e3) {
+    await this.page.waitForSelector(`text=${text}`, { timeout });
+  }
+  // Form helpers
+  async fillForm(formData) {
+    for (const [field, value] of Object.entries(formData)) {
+      await this.page.fill(`[name="${field}"]`, value);
+    }
+  }
+  async clickButton(text) {
+    await this.page.click(`button:has-text("${text}")`);
+  }
+  async clickLink(text) {
+    await this.page.click(`a:has-text("${text}")`);
+  }
+  // Content management helpers
+  async createContent(type, data) {
+    await this.navigateTo("/admin/content/new");
+    await this.page.selectOption('[name="contentType"]', type);
+    await this.fillForm(data);
+    await this.clickButton("Save as Draft");
+    await this.waitForText("Content saved successfully");
+  }
+  async editContent(contentId, updates) {
+    await this.navigateTo(`/admin/content/${contentId}/edit`);
+    await this.fillForm(updates);
+    await this.clickButton("Save Changes");
+    await this.waitForText("Content updated successfully");
+  }
+  async publishContent(contentId) {
+    await this.navigateTo(`/admin/content/${contentId}/edit`);
+    await this.clickButton("Publish");
+    await this.waitForText("Content published successfully");
+  }
+  async scheduleContent(contentId, date) {
+    await this.navigateTo(`/admin/content/${contentId}/edit`);
+    await this.page.fill('[name="publishDate"]', date);
+    await this.clickButton("Schedule");
+    await this.waitForText("Content scheduled successfully");
+  }
+  async deleteContent(contentId, soft = true) {
+    await this.navigateTo(`/admin/content/${contentId}/edit`);
+    await this.clickButton("Delete");
+    if (!soft) {
+      await this.page.click('[data-testid="confirm-delete"]');
+    }
+    await this.waitForText("Content deleted successfully");
+  }
+  // Workflow helpers
+  async createWorkflow(workflowData) {
+    await this.navigateTo("/admin/workflows/new");
+    await this.fillForm(workflowData);
+    await this.clickButton("Create Workflow");
+    await this.waitForText("Workflow created successfully");
+  }
+  async updateWorkflow(workflowId, updates) {
+    await this.navigateTo(`/admin/workflows/${workflowId}/edit`);
+    await this.fillForm(updates);
+    await this.clickButton("Update Workflow");
+    await this.waitForText("Workflow updated successfully");
+  }
+  async deleteWorkflow(workflowId) {
+    await this.navigateTo(`/admin/workflows/${workflowId}/edit`);
+    await this.clickButton("Delete Workflow");
+    await this.page.click('[data-testid="confirm-delete"]');
+    await this.waitForText("Workflow deleted successfully");
+  }
+  // Content type helpers
+  async createContentType(contentTypeData) {
+    await this.navigateTo("/admin/content-types/new");
+    await this.fillForm(contentTypeData);
+    await this.clickButton("Create Content Type");
+    await this.waitForText("Content type created successfully");
+  }
+  async updateContentType(contentTypeId, updates) {
+    await this.navigateTo(`/admin/content-types/${contentTypeId}/edit`);
+    await this.fillForm(updates);
+    await this.clickButton("Update Content Type");
+    await this.waitForText("Content type updated successfully");
+  }
+  async deleteContentType(contentTypeId) {
+    await this.navigateTo(`/admin/content-types/${contentTypeId}/edit`);
+    await this.clickButton("Delete Content Type");
+    await this.page.click('[data-testid="confirm-delete"]');
+    await this.waitForText("Content type deleted successfully");
+  }
+  // User helpers
+  async createUser(userData) {
+    await this.navigateTo("/admin/users/new");
+    await this.fillForm(userData);
+    await this.clickButton("Create User");
+    await this.waitForText("User created successfully");
+  }
+  async updateUser(userId, updates) {
+    await this.navigateTo(`/admin/users/${userId}/edit`);
+    await this.fillForm(updates);
+    await this.clickButton("Update User");
+    await this.waitForText("User updated successfully");
+  }
+  async deleteUser(userId) {
+    await this.navigateTo(`/admin/users/${userId}/edit`);
+    await this.clickButton("Delete User");
+    await this.page.click('[data-testid="confirm-delete"]');
+    await this.waitForText("User deleted successfully");
+  }
+  // Authentication helpers
+  async login(email, password) {
+    await this.navigateTo("/login");
+    await this.fillForm({ email, password });
+    await this.clickButton("Login");
+    await this.waitForText("Welcome");
+  }
+  async logout() {
+    await this.clickButton("Logout");
+    await this.waitForText("Logged out successfully");
+  }
+  // API helpers
+  async apiRequest(method, endpoint, data) {
+    const response = await this.page.request.fetch(`/api${endpoint}`, {
+      method,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      data: data ? JSON.stringify(data) : void 0
+    });
+    return response;
+  }
+  async getContent(contentId) {
+    const response = await this.apiRequest("GET", `/content/${contentId}`);
+    return response.json();
+  }
+  async createContentViaAPI(type, data) {
+    const response = await this.apiRequest("POST", "/content", { type, data });
+    return response.json();
+  }
+  async updateContentViaAPI(contentId, data) {
+    const response = await this.apiRequest("PUT", `/content/${contentId}`, { data });
+    return response.json();
+  }
+  async deleteContentViaAPI(contentId, soft = true) {
+    const response = await this.apiRequest("DELETE", `/content/${contentId}?soft=${soft}`);
+    return response;
+  }
+  // Assertion helpers
+  async expectElementVisible(selector) {
+    await (0, import_test.expect)(this.page.locator(selector)).toBeVisible();
+  }
+  async expectElementHidden(selector) {
+    await (0, import_test.expect)(this.page.locator(selector)).toBeHidden();
+  }
+  async expectTextVisible(text) {
+    await (0, import_test.expect)(this.page.locator(`text=${text}`)).toBeVisible();
+  }
+  async expectTextHidden(text) {
+    await (0, import_test.expect)(this.page.locator(`text=${text}`)).toBeHidden();
+  }
+  async expectElementCount(selector, count) {
+    await (0, import_test.expect)(this.page.locator(selector)).toHaveCount(count);
+  }
+  async expectElementText(selector, text) {
+    await (0, import_test.expect)(this.page.locator(selector)).toHaveText(text);
+  }
+  async expectElementValue(selector, value) {
+    await (0, import_test.expect)(this.page.locator(selector)).toHaveValue(value);
+  }
+  // Screenshot helpers
+  async takeScreenshot(name) {
+    await this.page.screenshot({ path: `test-results/screenshots/${name}.png` });
+  }
+  async takeElementScreenshot(selector, name) {
+    await this.page.locator(selector).screenshot({ path: `test-results/screenshots/${name}.png` });
+  }
+  // Performance helpers
+  async measurePerformance(name, fn) {
+    const start = Date.now();
+    await fn();
+    const end = Date.now();
+    console.log(`Performance: ${name} took ${end - start}ms`);
+    return end - start;
+  }
+  // Accessibility helpers
+  async checkAccessibility() {
+    const elements = await this.page.locator("[role]").all();
+    (0, import_test.expect)(elements.length).toBeGreaterThan(0);
+  }
+  // Mobile helpers
+  async switchToMobile() {
+    await this.page.setViewportSize({ width: 375, height: 667 });
+  }
+  async switchToTablet() {
+    await this.page.setViewportSize({ width: 768, height: 1024 });
+  }
+  async switchToDesktop() {
+    await this.page.setViewportSize({ width: 1920, height: 1080 });
+  }
+  // Cleanup helpers
+  async cleanup() {
+    await this.page.evaluate(() => {
+      localStorage.clear();
+      sessionStorage.clear();
+    });
+  }
+};
+function createTestUtils(page, context) {
+  return new TestUtils(page, context);
+}
+
+// src/fixtures/index.ts
+var import_faker = require("@faker-js/faker");
+var import_uuid = require("uuid");
+var import_date_fns = require("date-fns");
+var contentFixtures = {
+  text: {
+    id: (0, import_uuid.v4)(),
+    type: "text",
+    title: import_faker.faker.lorem.sentence(),
+    slug: import_faker.faker.lorem.slug(),
+    body: import_faker.faker.lorem.paragraphs(3),
+    excerpt: import_faker.faker.lorem.sentence(),
+    tags: import_faker.faker.lorem.words(3).split(" "),
+    categories: ["general"],
+    author: {
+      id: (0, import_uuid.v4)(),
+      name: import_faker.faker.person.fullName(),
+      email: import_faker.faker.internet.email()
+    },
+    status: "draft",
+    createdAt: /* @__PURE__ */ new Date(),
+    updatedAt: /* @__PURE__ */ new Date(),
+    publishedAt: null
+  },
+  image: {
+    id: (0, import_uuid.v4)(),
+    type: "image",
+    title: import_faker.faker.lorem.sentence(),
+    slug: import_faker.faker.lorem.slug(),
+    description: import_faker.faker.lorem.sentence(),
+    altText: import_faker.faker.lorem.sentence(),
+    imageUrl: import_faker.faker.image.url(),
+    tags: import_faker.faker.lorem.words(3).split(" "),
+    categories: ["photography"],
+    author: {
+      id: (0, import_uuid.v4)(),
+      name: import_faker.faker.person.fullName(),
+      email: import_faker.faker.internet.email()
+    },
+    status: "draft",
+    createdAt: /* @__PURE__ */ new Date(),
+    updatedAt: /* @__PURE__ */ new Date(),
+    publishedAt: null
+  },
+  audio: {
+    id: (0, import_uuid.v4)(),
+    type: "audio",
+    title: import_faker.faker.lorem.sentence(),
+    slug: import_faker.faker.lorem.slug(),
+    description: import_faker.faker.lorem.sentence(),
+    audioUrl: import_faker.faker.internet.url(),
+    duration: import_faker.faker.number.int({ min: 60, max: 3600 }),
+    metadata: {
+      artist: import_faker.faker.person.fullName(),
+      album: import_faker.faker.lorem.words(2),
+      year: import_faker.faker.date.past().getFullYear()
+    },
+    tags: import_faker.faker.lorem.words(3).split(" "),
+    categories: ["podcast"],
+    author: {
+      id: (0, import_uuid.v4)(),
+      name: import_faker.faker.person.fullName(),
+      email: import_faker.faker.internet.email()
+    },
+    status: "draft",
+    createdAt: /* @__PURE__ */ new Date(),
+    updatedAt: /* @__PURE__ */ new Date(),
+    publishedAt: null
+  },
+  video: {
+    id: (0, import_uuid.v4)(),
+    type: "video",
+    title: import_faker.faker.lorem.sentence(),
+    slug: import_faker.faker.lorem.slug(),
+    description: import_faker.faker.lorem.sentence(),
+    videoUrl: import_faker.faker.internet.url(),
+    duration: import_faker.faker.number.int({ min: 60, max: 3600 }),
+    dimensions: {
+      width: 1920,
+      height: 1080
+    },
+    metadata: {
+      director: import_faker.faker.person.fullName(),
+      genre: import_faker.faker.lorem.word(),
+      year: import_faker.faker.date.past().getFullYear()
+    },
+    tags: import_faker.faker.lorem.words(3).split(" "),
+    categories: ["tutorial"],
+    author: {
+      id: (0, import_uuid.v4)(),
+      name: import_faker.faker.person.fullName(),
+      email: import_faker.faker.internet.email()
+    },
+    status: "draft",
+    createdAt: /* @__PURE__ */ new Date(),
+    updatedAt: /* @__PURE__ */ new Date(),
+    publishedAt: null
+  }
+};
+var workflowFixtures = {
+  simple: {
+    id: "simple",
+    name: "Simple Workflow",
+    description: "A simple two-stage workflow",
+    stages: [
+      {
+        id: "draft",
+        name: "Draft",
+        order: 1,
+        isPublishStage: false,
+        allowsScheduling: false,
+        permissions: ["content.edit"]
+      },
+      {
+        id: "published",
+        name: "Published",
+        order: 2,
+        isPublishStage: true,
+        allowsScheduling: true,
+        permissions: ["content.publish"]
+      }
+    ],
+    transitions: [
+      {
+        id: "draft-to-published",
+        from: "draft",
+        to: "published",
+        permissions: ["content.publish"]
+      }
+    ]
+  },
+  editorial: {
+    id: "editorial",
+    name: "Editorial Workflow",
+    description: "A comprehensive editorial workflow",
+    stages: [
+      {
+        id: "write",
+        name: "Write",
+        order: 1,
+        isPublishStage: false,
+        allowsScheduling: false,
+        permissions: ["content.edit"]
+      },
+      {
+        id: "edit",
+        name: "Edit",
+        order: 2,
+        isPublishStage: false,
+        allowsScheduling: false,
+        permissions: ["content.edit"]
+      },
+      {
+        id: "review",
+        name: "Review",
+        order: 3,
+        isPublishStage: false,
+        allowsScheduling: false,
+        permissions: ["content.review"]
+      },
+      {
+        id: "publish",
+        name: "Publish",
+        order: 4,
+        isPublishStage: true,
+        allowsScheduling: true,
+        permissions: ["content.publish"]
+      }
+    ],
+    transitions: [
+      {
+        id: "write-to-edit",
+        from: "write",
+        to: "edit",
+        permissions: ["content.edit"]
+      },
+      {
+        id: "edit-to-review",
+        from: "edit",
+        to: "review",
+        permissions: ["content.review"]
+      },
+      {
+        id: "review-to-publish",
+        from: "review",
+        to: "publish",
+        permissions: ["content.publish"]
+      }
+    ]
+  }
+};
+var userFixtures = {
+  admin: {
+    id: (0, import_uuid.v4)(),
+    name: "Admin User",
+    email: "admin@example.com",
+    role: "admin",
+    permissions: ["*"],
+    createdAt: /* @__PURE__ */ new Date(),
+    updatedAt: /* @__PURE__ */ new Date()
+  },
+  editor: {
+    id: (0, import_uuid.v4)(),
+    name: "Editor User",
+    email: "editor@example.com",
+    role: "editor",
+    permissions: ["content.edit", "content.publish", "content.schedule"],
+    createdAt: /* @__PURE__ */ new Date(),
+    updatedAt: /* @__PURE__ */ new Date()
+  },
+  author: {
+    id: (0, import_uuid.v4)(),
+    name: "Author User",
+    email: "author@example.com",
+    role: "author",
+    permissions: ["content.edit"],
+    createdAt: /* @__PURE__ */ new Date(),
+    updatedAt: /* @__PURE__ */ new Date()
+  },
+  user: {
+    id: (0, import_uuid.v4)(),
+    name: "Regular User",
+    email: "user@example.com",
+    role: "user",
+    permissions: ["content.view"],
+    createdAt: /* @__PURE__ */ new Date(),
+    updatedAt: /* @__PURE__ */ new Date()
+  }
+};
+var contentTypeFixtures = {
+  text: {
+    id: "text",
+    name: "Text Content",
+    description: "Rich text content with formatting",
+    schema: {
+      title: { type: "string", required: true },
+      slug: { type: "string", required: true },
+      body: { type: "string", required: true },
+      excerpt: { type: "string", required: false },
+      tags: { type: "array", required: false },
+      categories: { type: "array", required: false }
+    },
+    editorConfig: {
+      component: "TextEditor",
+      fields: [
+        { name: "title", type: "text", label: "Title", required: true },
+        { name: "slug", type: "text", label: "Slug", required: true },
+        { name: "body", type: "textarea", label: "Body", required: true },
+        { name: "excerpt", type: "textarea", label: "Excerpt", required: false },
+        { name: "tags", type: "tags", label: "Tags", required: false },
+        { name: "categories", type: "select", label: "Categories", required: false }
+      ]
+    }
+  },
+  image: {
+    id: "image",
+    name: "Image Content",
+    description: "Image content with metadata",
+    schema: {
+      title: { type: "string", required: true },
+      slug: { type: "string", required: true },
+      description: { type: "string", required: false },
+      altText: { type: "string", required: true },
+      imageUrl: { type: "string", required: true },
+      tags: { type: "array", required: false },
+      categories: { type: "array", required: false }
+    },
+    editorConfig: {
+      component: "ImageEditor",
+      fields: [
+        { name: "title", type: "text", label: "Title", required: true },
+        { name: "slug", type: "text", label: "Slug", required: true },
+        { name: "description", type: "textarea", label: "Description", required: false },
+        { name: "altText", type: "text", label: "Alt Text", required: true },
+        { name: "imageUrl", type: "url", label: "Image URL", required: true },
+        { name: "tags", type: "tags", label: "Tags", required: false },
+        { name: "categories", type: "select", label: "Categories", required: false }
+      ]
+    }
+  }
+};
+var configFixtures = {
+  development: {
+    server: {
+      port: 3e3,
+      host: "localhost",
+      cors: {
+        origin: "*",
+        credentials: true
+      }
+    },
+    database: {
+      type: "sqlite",
+      name: "content_management_dev"
+    },
+    logging: {
+      level: "debug",
+      format: "text",
+      console: {
+        enabled: true,
+        colorize: true
+      }
+    }
+  },
+  production: {
+    server: {
+      port: 80,
+      host: "0.0.0.0",
+      cors: {
+        origin: ["https://myapp.com"],
+        credentials: true
+      }
+    },
+    database: {
+      type: "postgresql",
+      url: "postgresql://user:password@localhost:5432/content_management"
+    },
+    logging: {
+      level: "info",
+      format: "json",
+      file: {
+        enabled: true,
+        path: "./logs",
+        maxSize: "10MB",
+        maxFiles: 5
+      }
+    }
+  }
+};
+var testDataGenerators = {
+  generateContent: (type, overrides = {}) => {
+    const base = contentFixtures[type];
+    return {
+      ...base,
+      id: (0, import_uuid.v4)(),
+      ...overrides
+    };
+  },
+  generateWorkflow: (overrides = {}) => {
+    return {
+      ...workflowFixtures.simple,
+      id: (0, import_uuid.v4)(),
+      ...overrides
+    };
+  },
+  generateUser: (role = "user", overrides = {}) => {
+    const base = userFixtures[role];
+    return {
+      ...base,
+      id: (0, import_uuid.v4)(),
+      ...overrides
+    };
+  },
+  generateContentType: (overrides = {}) => {
+    return {
+      ...contentTypeFixtures.text,
+      id: (0, import_uuid.v4)(),
+      ...overrides
+    };
+  },
+  generateConfig: (environment = "development", overrides = {}) => {
+    const base = configFixtures[environment];
+    return {
+      ...base,
+      ...overrides
+    };
+  }
+};
+var dateFixtures = {
+  now: /* @__PURE__ */ new Date(),
+  tomorrow: (0, import_date_fns.addDays)(/* @__PURE__ */ new Date(), 1),
+  yesterday: (0, import_date_fns.subDays)(/* @__PURE__ */ new Date(), 1),
+  nextWeek: (0, import_date_fns.addDays)(/* @__PURE__ */ new Date(), 7),
+  lastWeek: (0, import_date_fns.subDays)(/* @__PURE__ */ new Date(), 7),
+  nextMonth: (0, import_date_fns.addDays)(/* @__PURE__ */ new Date(), 30),
+  lastMonth: (0, import_date_fns.subDays)(/* @__PURE__ */ new Date(), 30)
+};
+var apiResponseFixtures = {
+  success: {
+    success: true,
+    message: "Operation completed successfully",
+    data: null
+  },
+  error: {
+    success: false,
+    message: "An error occurred",
+    error: {
+      code: "INTERNAL_ERROR",
+      details: "Something went wrong"
+    }
+  },
+  validationError: {
+    success: false,
+    message: "Validation failed",
+    error: {
+      code: "VALIDATION_ERROR",
+      details: {
+        field: "title",
+        message: "Title is required"
+      }
+    }
+  }
+};
+
+// src/setup/jest.setup.ts
+var import_jest_dom = require("@testing-library/jest-dom");
+var import_react = require("@testing-library/react");
+var import_util = require("util");
+(0, import_react.configure)({ testIdAttribute: "data-testid" });
+global.TextEncoder = import_util.TextEncoder;
+global.TextDecoder = import_util.TextDecoder;
+global.IntersectionObserver = class IntersectionObserver {
+  constructor() {
+  }
+  disconnect() {
+  }
+  observe() {
+  }
+  unobserve() {
+  }
+};
+global.ResizeObserver = class ResizeObserver {
+  constructor() {
+  }
+  disconnect() {
+  }
+  observe() {
+  }
+  unobserve() {
+  }
+};
+Object.defineProperty(window, "matchMedia", {
+  writable: true,
+  value: jest.fn().mockImplementation((query) => ({
+    matches: false,
+    media: query,
+    onchange: null,
+    addListener: jest.fn(),
+    // deprecated
+    removeListener: jest.fn(),
+    // deprecated
+    addEventListener: jest.fn(),
+    removeEventListener: jest.fn(),
+    dispatchEvent: jest.fn()
+  }))
+});
+var localStorageMock = {
+  getItem: jest.fn(),
+  setItem: jest.fn(),
+  removeItem: jest.fn(),
+  clear: jest.fn()
+};
+global.localStorage = localStorageMock;
+var sessionStorageMock = {
+  getItem: jest.fn(),
+  setItem: jest.fn(),
+  removeItem: jest.fn(),
+  clear: jest.fn()
+};
+global.sessionStorage = sessionStorageMock;
+global.fetch = jest.fn();
+var originalError = console.error;
+var originalWarn = console.warn;
+beforeAll(() => {
+  console.error = (...args) => {
+    if (typeof args[0] === "string" && args[0].includes("Warning: ReactDOM.render is no longer supported")) {
+      return;
+    }
+    originalError.call(console, ...args);
+  };
+  console.warn = (...args) => {
+    if (typeof args[0] === "string" && args[0].includes("Warning: ReactDOM.render is no longer supported")) {
+      return;
+    }
+    originalWarn.call(console, ...args);
+  };
+});
+afterAll(() => {
+  console.error = originalError;
+  console.warn = originalWarn;
+});
+afterEach(() => {
+  jest.clearAllMocks();
+  localStorageMock.clear();
+  sessionStorageMock.clear();
+});
+
+// src/index.ts
+var import_react2 = require("@testing-library/react");
+var import_user_event = require("@testing-library/user-event");
+var import_test3 = require("@playwright/test");
+
+// playwright.config.ts
+var import_test2 = require("@playwright/test");
+var playwright_config_default = (0, import_test2.defineConfig)({
+  testDir: "./src/playwright",
+  fullyParallel: true,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 2 : 0,
+  workers: process.env.CI ? 1 : void 0,
+  reporter: [
+    ["html"],
+    ["json", { outputFile: "test-results/results.json" }],
+    ["junit", { outputFile: "test-results/results.xml" }]
+  ],
+  use: {
+    baseURL: "http://localhost:3000",
+    trace: "on-first-retry",
+    screenshot: "only-on-failure",
+    video: "retain-on-failure"
+  },
+  projects: [
+    {
+      name: "chromium",
+      use: { ...import_test2.devices["Desktop Chrome"] }
+    },
+    {
+      name: "firefox",
+      use: { ...import_test2.devices["Desktop Firefox"] }
+    },
+    {
+      name: "webkit",
+      use: { ...import_test2.devices["Desktop Safari"] }
+    },
+    {
+      name: "Mobile Chrome",
+      use: { ...import_test2.devices["Pixel 5"] }
+    },
+    {
+      name: "Mobile Safari",
+      use: { ...import_test2.devices["iPhone 12"] }
+    }
+  ],
+  webServer: {
+    command: "npm run start:test",
+    url: "http://localhost:3000",
+    reuseExistingServer: !process.env.CI,
+    timeout: 120 * 1e3
+  }
+});
+
+// src/index.ts
+var import_jest = __toESM(require_jest_config());
+var TestRunner = class {
+  constructor(config) {
+    this.suites = [];
+    this.config = config;
+  }
+  addSuite(suite) {
+    this.suites.push(suite);
+  }
+  async runSuite(suiteName) {
+    const suite = this.suites.find((s) => s.name === suiteName);
+    if (!suite) {
+      throw new Error(`Suite ${suiteName} not found`);
+    }
+    const results = [];
+    const startTime = Date.now();
+    try {
+      if (suite.setup) {
+        await suite.setup();
+      }
+      for (const testCase of suite.tests) {
+        if (testCase.skip) {
+          results.push({
+            name: testCase.name,
+            status: "skipped",
+            duration: 0
+          });
+          continue;
+        }
+        const testStartTime = Date.now();
+        try {
+          await testCase.test();
+          results.push({
+            name: testCase.name,
+            status: "passed",
+            duration: Date.now() - testStartTime
+          });
+        } catch (error) {
+          results.push({
+            name: testCase.name,
+            status: "failed",
+            duration: Date.now() - testStartTime,
+            error
+          });
+        }
+      }
+    } finally {
+      if (suite.teardown) {
+        await suite.teardown();
+      }
+    }
+    const summary = {
+      total: results.length,
+      passed: results.filter((r) => r.status === "passed").length,
+      failed: results.filter((r) => r.status === "failed").length,
+      skipped: results.filter((r) => r.status === "skipped").length,
+      duration: Date.now() - startTime
+    };
+    return {
+      suite: suiteName,
+      results,
+      summary
+    };
+  }
+  async runAllSuites() {
+    const reports = [];
+    for (const suite of this.suites) {
+      const report = await this.runSuite(suite.name);
+      reports.push(report);
+    }
+    return reports;
+  }
+};
+var TestDataGenerator = class {
+  static generateContent(type, overrides = {}) {
+    const base = {
+      id: `test-${Date.now()}`,
+      type,
+      title: `Test ${type} Content`,
+      slug: `test-${type}-content`,
+      body: `Test content for ${type}`,
+      author: {
+        id: "test-user",
+        name: "Test User",
+        email: "test@example.com"
+      },
+      status: "draft",
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    return { ...base, ...overrides };
+  }
+  static generateWorkflow(overrides = {}) {
+    const base = {
+      id: `test-workflow-${Date.now()}`,
+      name: "Test Workflow",
+      description: "Test workflow for testing",
+      stages: [
+        {
+          id: "draft",
+          name: "Draft",
+          order: 1,
+          isPublishStage: false,
+          allowsScheduling: false,
+          permissions: ["content.edit"]
+        },
+        {
+          id: "published",
+          name: "Published",
+          order: 2,
+          isPublishStage: true,
+          allowsScheduling: true,
+          permissions: ["content.publish"]
+        }
+      ],
+      transitions: [
+        {
+          id: "draft-to-published",
+          from: "draft",
+          to: "published",
+          permissions: ["content.publish"]
+        }
+      ]
+    };
+    return { ...base, ...overrides };
+  }
+  static generateUser(role = "user", overrides = {}) {
+    const base = {
+      id: `test-user-${Date.now()}`,
+      name: "Test User",
+      email: "test@example.com",
+      role,
+      permissions: role === "admin" ? ["*"] : ["content.view"],
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    return { ...base, ...overrides };
+  }
+};
+var TestAssertions = class {
+  static async expectElementVisible(page, selector) {
+    const element = await page.locator(selector);
+    await expect(element).toBeVisible();
+  }
+  static async expectElementHidden(page, selector) {
+    const element = await page.locator(selector);
+    await expect(element).toBeHidden();
+  }
+  static async expectTextVisible(page, text) {
+    const element = await page.locator(`text=${text}`);
+    await expect(element).toBeVisible();
+  }
+  static async expectTextHidden(page, text) {
+    const element = await page.locator(`text=${text}`);
+    await expect(element).toBeHidden();
+  }
+  static async expectElementCount(page, selector, count) {
+    const elements = await page.locator(selector);
+    await expect(elements).toHaveCount(count);
+  }
+  static async expectElementText(page, selector, text) {
+    const element = await page.locator(selector);
+    await expect(element).toHaveText(text);
+  }
+  static async expectElementValue(page, selector, value) {
+    const element = await page.locator(selector);
+    await expect(element).toHaveValue(value);
+  }
+};
+var TestHelpers = class {
+  static async waitForElement(page, selector, timeout = 5e3) {
+    await page.waitForSelector(selector, { timeout });
+  }
+  static async waitForText(page, text, timeout = 5e3) {
+    await page.waitForSelector(`text=${text}`, { timeout });
+  }
+  static async fillForm(page, formData) {
+    for (const [field, value] of Object.entries(formData)) {
+      await page.fill(`[name="${field}"]`, value);
+    }
+  }
+  static async clickButton(page, text) {
+    await page.click(`button:has-text("${text}")`);
+  }
+  static async clickLink(page, text) {
+    await page.click(`a:has-text("${text}")`);
+  }
+  static async takeScreenshot(page, name) {
+    await page.screenshot({ path: `test-results/screenshots/${name}.png` });
+  }
+  static async measurePerformance(name, fn) {
+    const start = Date.now();
+    await fn();
+    const end = Date.now();
+    console.log(`Performance: ${name} took ${end - start}ms`);
+    return end - start;
+  }
+};
+var defaultTestConfig = {
+  baseURL: "http://localhost:3000",
+  timeout: 3e4,
+  retries: 2,
+  workers: 1,
+  reporter: ["html", "json"],
+  browser: ["chromium", "firefox", "webkit"],
+  mobile: true,
+  tablet: true,
+  desktop: true
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TestAssertions,
+  TestDataGenerator,
+  TestHelpers,
+  TestRunner,
+  TestUtils,
+  apiResponseFixtures,
+  configFixtures,
+  contentFixtures,
+  contentTypeFixtures,
+  createTestUtils,
+  dateFixtures,
+  defaultTestConfig,
+  expect,
+  fireEvent,
+  jestConfig,
+  playwrightConfig,
+  render,
+  screen,
+  test,
+  testDataGenerators,
+  userEvent,
+  userFixtures,
+  waitFor,
+  workflowFixtures
+});
+//# sourceMappingURL=index.js.map