playwright-json-runner/dist/scripts/cli.js

Extends Playwright to run tests using JSON-based test definitions.

#!/usr/bin/env node
'use strict';

var fs = require('fs');
var zod = require('zod');
var zodToJsonSchema = require('zod-to-json-schema');

function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }

function _interopNamespace(e) {
  if (e && e.__esModule) return e;
  var n = Object.create(null);
  if (e) {
    Object.keys(e).forEach(function (k) {
      if (k !== 'default') {
        var d = Object.getOwnPropertyDescriptor(e, k);
        Object.defineProperty(n, k, d.get ? d : {
          enumerable: true,
          get: function () { return e[k]; }
        });
      }
    });
  }
  n.default = e;
  return Object.freeze(n);
}

var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
var zodToJsonSchema__default = /*#__PURE__*/_interopDefault(zodToJsonSchema);

var withLabelSchema = zod.z.object({
  label: zod.z.string().optional()
});
var withDescriptionSchema = zod.z.object({
  description: zod.z.string().optional()
});
var testObjectSchema = withLabelSchema.merge(withDescriptionSchema);
zod.z.object({
  checked: zod.z.boolean().optional(),
  disabled: zod.z.boolean().optional(),
  exact: zod.z.boolean().optional(),
  expanded: zod.z.boolean().optional(),
  includeHidden: zod.z.boolean().optional(),
  level: zod.z.number().optional(),
  // For name, accept string or RegExp. 
  // If you strictly need to parse only real RegExp objects at runtime, keep it like this.
  // If you want to accept a "string that might be a pattern," consider a string-based approach.
  name: zod.z.union([zod.z.string(), zod.z.instanceof(RegExp)]).optional(),
  pressed: zod.z.boolean().optional(),
  selected: zod.z.boolean().optional()
}).optional();
var PlaywrightRoleSchema = zod.z.enum([
  "alert",
  "alertdialog",
  "application",
  "article",
  "banner",
  "blockquote",
  "button",
  "caption",
  "cell",
  "checkbox",
  "code",
  "columnheader",
  "combobox",
  "complementary",
  "contentinfo",
  "definition",
  "deletion",
  "dialog",
  "directory",
  "document",
  "emphasis",
  "feed",
  "figure",
  "form",
  "generic",
  "grid",
  "gridcell",
  "group",
  "heading",
  "img",
  "insertion",
  "link",
  "list",
  "listbox",
  "listitem",
  "log",
  "main",
  "marquee",
  "math",
  "meter",
  "menu",
  "menubar",
  "menuitem",
  "menuitemcheckbox",
  "menuitemradio",
  "navigation",
  "none",
  "note",
  "option",
  "paragraph",
  "presentation",
  "progressbar",
  "radio",
  "radiogroup",
  "region",
  "row",
  "rowgroup",
  "rowheader",
  "scrollbar",
  "search",
  "searchbox",
  "separator",
  "slider",
  "spinbutton",
  "status",
  "strong",
  "subscript",
  "superscript",
  "switch",
  "tab",
  "table",
  "tablist",
  "tabpanel",
  "term",
  "textbox",
  "time",
  "timer",
  "toolbar",
  "tooltip",
  "tree",
  "treegrid",
  "treeitem"
]);

// src/schemas/locators/locator-parameters.ts
var nthField = { nth: zod.z.number().optional() };
var selectorLocatorSchema = zod.z.object({
  by: zod.z.literal("selector"),
  value: zod.z.string().describe("CSS selector"),
  ...nthField
});
var xpathLocatorSchema = zod.z.object({
  by: zod.z.literal("xpath"),
  value: zod.z.string().describe("XPath expression"),
  ...nthField
});
var roleLocatorSchema = zod.z.object({
  by: zod.z.literal("role"),
  role: PlaywrightRoleSchema,
  name: zod.z.union([zod.z.string(), zod.z.instanceof(RegExp)]).optional(),
  exact: zod.z.boolean().optional(),
  checked: zod.z.boolean().optional(),
  disabled: zod.z.boolean().optional(),
  expanded: zod.z.boolean().optional(),
  includeHidden: zod.z.boolean().optional(),
  level: zod.z.number().optional(),
  pressed: zod.z.boolean().optional(),
  selected: zod.z.boolean().optional(),
  ...nthField
});
var textLocatorSchema = zod.z.object({
  by: zod.z.literal("text"),
  value: zod.z.string(),
  exact: zod.z.boolean().optional(),
  ...nthField
});
var labelLocatorSchema = zod.z.object({
  by: zod.z.literal("label"),
  value: zod.z.string(),
  exact: zod.z.boolean().optional(),
  ...nthField
});
var placeholderLocatorSchema = zod.z.object({
  by: zod.z.literal("placeholder"),
  value: zod.z.string(),
  exact: zod.z.boolean().optional(),
  ...nthField
});
var altTextLocatorSchema = zod.z.object({
  by: zod.z.literal("altText"),
  value: zod.z.string(),
  exact: zod.z.boolean().optional(),
  ...nthField
});
var titleLocatorSchema = zod.z.object({
  by: zod.z.literal("title"),
  value: zod.z.string(),
  exact: zod.z.boolean().optional(),
  ...nthField
});
var testIdLocatorSchema = zod.z.object({
  by: zod.z.literal("testId"),
  value: zod.z.string(),
  ...nthField
});
var locatorParamsSchema;
var nestedLocatorSchema = zod.z.lazy(
  () => zod.z.object({
    by: zod.z.literal("nested"),
    parent: locatorParamsSchema,
    child: locatorParamsSchema,
    ...nthField
  })
);
var customLocatorSchema = zod.z.object({
  by: zod.z.string(),
  value: zod.z.string().optional(),
  ...nthField
});
locatorParamsSchema = zod.z.union([
  zod.z.discriminatedUnion("by", [
    selectorLocatorSchema,
    xpathLocatorSchema,
    roleLocatorSchema,
    textLocatorSchema,
    labelLocatorSchema,
    placeholderLocatorSchema,
    altTextLocatorSchema,
    titleLocatorSchema,
    testIdLocatorSchema
  ]),
  nestedLocatorSchema,
  customLocatorSchema
]);

// src/schemas/test-action.ts
var timeoutOpts = zod.z.object({ timeout: zod.z.number().optional() }).optional();
var interactOpts = zod.z.object({
  timeout: zod.z.number().optional(),
  force: zod.z.boolean().optional(),
  trial: zod.z.boolean().optional()
}).optional();
var waitUntilEnum = zod.z.enum(["commit", "domcontentloaded", "load", "networkidle"]);
var loadStateEnum = zod.z.enum(["domcontentloaded", "load", "networkidle"]);
var waitForStateEnum = zod.z.enum(["attached", "detached", "visible", "hidden"]);
var base = testObjectSchema;
var withLocator = base.extend({ locator: locatorParamsSchema });
var navigateActionSchema = base.extend({
  action: zod.z.literal("navigate"),
  url: zod.z.string(),
  options: zod.z.object({ timeout: zod.z.number().optional(), waitUntil: waitUntilEnum.optional() }).optional()
});
var sleepActionSchema = base.extend({
  action: zod.z.literal("sleep"),
  duration: zod.z.number().describe("milliseconds to wait")
});
var waitForURLActionSchema = base.extend({
  action: zod.z.literal("waitForURL"),
  url: zod.z.string(),
  options: zod.z.object({ timeout: zod.z.number().optional(), waitUntil: waitUntilEnum.optional() }).optional()
});
var goBackActionSchema = base.extend({
  action: zod.z.literal("goBack"),
  options: zod.z.object({ timeout: zod.z.number().optional(), waitUntil: waitUntilEnum.optional() }).optional()
});
var goForwardActionSchema = base.extend({
  action: zod.z.literal("goForward"),
  options: zod.z.object({ timeout: zod.z.number().optional(), waitUntil: waitUntilEnum.optional() }).optional()
});
var waitForLoadStateActionSchema = base.extend({
  action: zod.z.literal("waitForLoadState"),
  state: loadStateEnum.optional(),
  options: timeoutOpts
});
var assertURLActionSchema = base.extend({
  action: zod.z.literal("assertURL"),
  value: zod.z.string(),
  options: timeoutOpts
});
var assertTitleActionSchema = base.extend({
  action: zod.z.literal("assertTitle"),
  value: zod.z.string(),
  options: timeoutOpts
});
var scrollActionSchema = base.extend({
  action: zod.z.literal("scroll"),
  deltaX: zod.z.number().describe("Horizontal scroll pixels"),
  deltaY: zod.z.number().describe("Vertical scroll pixels")
});
var waitForTextActionSchema = base.extend({
  action: zod.z.literal("waitForText"),
  value: zod.z.string(),
  options: zod.z.object({
    timeout: zod.z.number().optional(),
    state: waitForStateEnum.optional()
  }).optional()
});
var clickCoordinatesActionSchema = base.extend({
  action: zod.z.literal("clickCoordinates"),
  x: zod.z.number(),
  y: zod.z.number(),
  options: zod.z.object({
    button: zod.z.enum(["left", "middle", "right"]).optional(),
    clickCount: zod.z.number().optional(),
    delay: zod.z.number().optional()
  }).optional()
});
var screenshotActionSchema = base.extend({
  action: zod.z.literal("screenshot"),
  locator: locatorParamsSchema.optional(),
  path: zod.z.string().optional(),
  options: zod.z.object({ fullPage: zod.z.boolean().optional(), timeout: zod.z.number().optional() }).optional()
});
var assertSnapshotActionSchema = base.extend({
  action: zod.z.literal("assertSnapshot"),
  locator: locatorParamsSchema.optional(),
  name: zod.z.string().optional().describe("Baseline snapshot filename"),
  options: zod.z.object({
    timeout: zod.z.number().optional(),
    maxDiffPixels: zod.z.number().optional(),
    maxDiffPixelRatio: zod.z.number().optional(),
    threshold: zod.z.number().optional()
  }).optional()
});
var clickActionSchema = withLocator.extend({
  action: zod.z.literal("click"),
  options: zod.z.object({
    button: zod.z.enum(["left", "middle", "right"]).optional(),
    clickCount: zod.z.number().optional(),
    delay: zod.z.number().optional(),
    force: zod.z.boolean().optional(),
    timeout: zod.z.number().optional(),
    trial: zod.z.boolean().optional()
  }).optional()
});
var dblclickActionSchema = withLocator.extend({
  action: zod.z.literal("dblclick"),
  options: interactOpts
});
var fillActionSchema = withLocator.extend({
  action: zod.z.literal("fill"),
  value: zod.z.string(),
  options: zod.z.object({
    force: zod.z.boolean().optional(),
    timeout: zod.z.number().optional(),
    noWaitAfter: zod.z.boolean().optional()
  }).optional()
});
var typeActionSchema = withLocator.extend({
  action: zod.z.literal("type"),
  value: zod.z.string(),
  options: zod.z.object({ delay: zod.z.number().optional(), timeout: zod.z.number().optional() }).optional()
});
var pressActionSchema = withLocator.extend({
  action: zod.z.literal("press"),
  key: zod.z.string().describe("Key or chord, e.g. 'Enter', 'Tab', 'Control+a'"),
  options: zod.z.object({ delay: zod.z.number().optional(), timeout: zod.z.number().optional() }).optional()
});
var checkActionSchema = withLocator.extend({
  action: zod.z.literal("check"),
  options: interactOpts
});
var uncheckActionSchema = withLocator.extend({
  action: zod.z.literal("uncheck"),
  options: interactOpts
});
var selectOptionActionSchema = withLocator.extend({
  action: zod.z.literal("selectOption"),
  value: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]),
  options: zod.z.object({ force: zod.z.boolean().optional(), timeout: zod.z.number().optional() }).optional()
});
var hoverActionSchema = withLocator.extend({
  action: zod.z.literal("hover"),
  options: interactOpts
});
var focusActionSchema = withLocator.extend({
  action: zod.z.literal("focus"),
  options: timeoutOpts
});
var blurActionSchema = withLocator.extend({
  action: zod.z.literal("blur"),
  options: timeoutOpts
});
var clearActionSchema = withLocator.extend({
  action: zod.z.literal("clear"),
  options: interactOpts
});
var scrollIntoViewActionSchema = withLocator.extend({
  action: zod.z.literal("scrollIntoView"),
  options: timeoutOpts
});
var waitForActionSchema = withLocator.extend({
  action: zod.z.literal("waitFor"),
  state: waitForStateEnum.optional(),
  options: timeoutOpts
});
var waitForHiddenActionSchema = withLocator.extend({
  action: zod.z.literal("waitForHidden"),
  options: timeoutOpts
});
var waitForSelectorActionSchema = withLocator.extend({
  action: zod.z.literal("waitForSelector"),
  options: timeoutOpts
});
var setFieldValueActionSchema = withLocator.extend({
  action: zod.z.literal("setFieldValue"),
  value: zod.z.string(),
  options: timeoutOpts
});
var assertFieldValueEqualsActionSchema = withLocator.extend({
  action: zod.z.literal("assertFieldValueEquals"),
  value: zod.z.string(),
  options: timeoutOpts
});
var assertFieldValueContainsActionSchema = withLocator.extend({
  action: zod.z.literal("assertFieldValueContains"),
  value: zod.z.string(),
  options: timeoutOpts
});
var assertVisibleSchema = withLocator.extend({
  action: zod.z.literal("assertVisible"),
  options: timeoutOpts
});
var assertHiddenSchema = withLocator.extend({
  action: zod.z.literal("assertHidden"),
  options: timeoutOpts
});
var assertEnabledSchema = withLocator.extend({
  action: zod.z.literal("assertEnabled"),
  options: timeoutOpts
});
var assertDisabledSchema = withLocator.extend({
  action: zod.z.literal("assertDisabled"),
  options: timeoutOpts
});
var assertCheckedSchema = withLocator.extend({
  action: zod.z.literal("assertChecked"),
  checked: zod.z.boolean().optional().describe("Default true; set false to assert unchecked"),
  options: timeoutOpts
});
var assertTextSchema = withLocator.extend({
  action: zod.z.literal("assertText"),
  value: zod.z.string(),
  options: zod.z.object({ timeout: zod.z.number().optional(), ignoreCase: zod.z.boolean().optional() }).optional()
});
var assertContainsTextSchema = withLocator.extend({
  action: zod.z.literal("assertContainsText"),
  value: zod.z.string(),
  options: zod.z.object({ timeout: zod.z.number().optional(), ignoreCase: zod.z.boolean().optional() }).optional()
});
var assertValueSchema = withLocator.extend({
  action: zod.z.literal("assertValue"),
  value: zod.z.string(),
  options: timeoutOpts
});
var assertCountSchema = withLocator.extend({
  action: zod.z.literal("assertCount"),
  count: zod.z.number(),
  options: timeoutOpts
});
var assertAttributeSchema = withLocator.extend({
  action: zod.z.literal("assertAttribute"),
  attribute: zod.z.string(),
  value: zod.z.string(),
  options: timeoutOpts
});
var customActionSchema = base.extend({
  action: zod.z.string(),
  locator: locatorParamsSchema.optional(),
  value: zod.z.string().optional()
}).passthrough();
var knownActionsSchema = zod.z.discriminatedUnion("action", [
  navigateActionSchema,
  sleepActionSchema,
  goBackActionSchema,
  goForwardActionSchema,
  scrollActionSchema,
  waitForURLActionSchema,
  waitForLoadStateActionSchema,
  waitForTextActionSchema,
  clickCoordinatesActionSchema,
  assertURLActionSchema,
  assertTitleActionSchema,
  screenshotActionSchema,
  assertSnapshotActionSchema,
  clickActionSchema,
  dblclickActionSchema,
  fillActionSchema,
  typeActionSchema,
  pressActionSchema,
  checkActionSchema,
  uncheckActionSchema,
  selectOptionActionSchema,
  hoverActionSchema,
  focusActionSchema,
  blurActionSchema,
  clearActionSchema,
  scrollIntoViewActionSchema,
  waitForActionSchema,
  waitForHiddenActionSchema,
  waitForSelectorActionSchema,
  assertVisibleSchema,
  assertHiddenSchema,
  assertEnabledSchema,
  assertDisabledSchema,
  assertCheckedSchema,
  assertTextSchema,
  assertContainsTextSchema,
  assertValueSchema,
  assertCountSchema,
  assertAttributeSchema,
  setFieldValueActionSchema,
  assertFieldValueEqualsActionSchema,
  assertFieldValueContainsActionSchema
]);
var testActionSchema = zod.z.union([knownActionsSchema, customActionSchema]);
var testStepSchema = testObjectSchema.extend({
  description: zod.z.string(),
  actions: zod.z.array(testActionSchema)
});

// src/schemas/test-scenario.ts
var testScenarioSchema = testObjectSchema.extend({
  name: zod.z.string(),
  steps: zod.z.array(testStepSchema)
});

// src/schemas/test-run.ts
var testRunSchema = testObjectSchema.extend({
  browser: zod.z.enum(["chrome", "firefox", "webkit"]),
  host: zod.z.string(),
  scenarios: zod.z.array(testScenarioSchema)
});
function dumpSchema() {
  return zodToJsonSchema__default.default(testRunSchema, {
    name: "TestRun"
  });
}
(async function main() {
  const [, , command, outputFile] = process.argv;
  if (command === "dump-json-schema") {
    const fileName = outputFile || "playwright-json-runner-schema.json";
    try {
      const schemaJson = await dumpSchema();
      fs__namespace.writeFileSync(fileName, typeof schemaJson === "string" ? schemaJson : JSON.stringify(schemaJson, null, 2));
      console.log(`Schema dumped to ${fileName}`);
    } catch (error) {
      console.error("Error dumping JSON Schema:", error);
      process.exit(1);
    }
  } else {
    console.log(
      `Usage:
  playwright-json-runner dump-json-schema <outputFile>

Example:
  playwright-json-runner dump-json-schema schema.json`
    );
    process.exit(0);
  }
})();
//# sourceMappingURL=cli.js.map
//# sourceMappingURL=cli.js.map