@sdods/core 0.2.2 → 0.3.1

package/dist/steps/glob.js

@@ -1,5 +1,7 @@
+import { readdirSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { SdodsError } from '../errors.js';
 /**
  * Absolute glob of the core step library. Built from this file's real path so Playwright's
  * TS transform sees a workspace path (not node_modules) and playwright-bdd loads it.
@@ -7,6 +9,13 @@ import { fileURLToPath } from 'node:url';
 export function coreStepsDir() {
     return dirname(fileURLToPath(import.meta.url)).replace(/\\/g, '/');
 }
+/** The library names present in this build — `a11y` for `a11y.steps.ts`. */
+export function coreStepNames() {
+    return readdirSync(coreStepsDir())
+        .map((f) => /^(.+)\.steps\.(?:js|ts)$/.exec(f)?.[1])
+        .filter((n) => Boolean(n))
+        .sort();
+}
 /**
  * Both extensions, because this resolves against whichever copy of the package is running: the
  * workspace checkout ships `*.steps.ts`, the published package ships the compiled `*.steps.js`.
@@ -14,8 +23,38 @@ export function coreStepsDir() {
  * outside the pattern. playwright-bdd passes explicit patterns to tinyglobby untouched — it only
  * appends extensions to bare directory patterns — and neither it nor tinyglobby excludes
  * node_modules, so the published layout globs fine.
- */
+ * */
 export function coreStepsGlob() {
     return `${coreStepsDir()}/*.steps.{js,ts}`;
 }
+/**
+ * The patterns bddgen should load, honouring `steps.core.exclude`.
+ *
+ * Separate from `coreStepsGlob()` because that one is exported API and returns a single string;
+ * widening its return type would break every caller for the sake of an option most projects
+ * never set. With nothing excluded this returns exactly that same glob, so the common path is
+ * byte-identical to what shipped before.
+ *
+ * An unknown name THROWS rather than being ignored. A silent no-op on a typo would leave the
+ * project believing it had excluded a library while the collision it was avoiding still fails
+ * generation — and the error it would then read points at the step, not at the typo.
+ */
+export function coreStepsPatterns(exclude = []) {
+    if (exclude.length === 0)
+        return [coreStepsGlob()];
+    const available = coreStepNames();
+    const unknown = exclude.filter((n) => !available.includes(n));
+    if (unknown.length) {
+        throw new SdodsError('CONFIG_INVALID', `steps.core.exclude names ${unknown.length === 1 ? 'a library' : 'libraries'} that ` +
+            `${unknown.length === 1 ? 'does' : 'do'} not exist: ${unknown.join(', ')}.`, {
+            hint: `Available: ${available.join(', ')}. Names are the file basenames, so "a11y" for a11y.steps.ts.`,
+        });
+    }
+    // Explicit per-library patterns rather than a negated glob: playwright-bdd hands these to
+    // tinyglobby verbatim, and a `!`-prefixed entry in that list is treated as a path, not an
+    // exclusion.
+    return available
+        .filter((n) => !exclude.includes(n))
+        .map((n) => `${coreStepsDir()}/${n}.steps.{js,ts}`);
+}
 //# sourceMappingURL=glob.js.map

package/dist/steps/iframe.steps.d.ts

@@ -0,0 +1,2 @@
+import './params.js';
+//# sourceMappingURL=iframe.steps.d.ts.map

package/dist/steps/iframe.steps.js

@@ -0,0 +1,93 @@
+import { expect } from '@playwright/test';
+import './params.js';
+import { Given, Then, When } from '../fixtures/test.js';
+import { render } from '../api/template.js';
+import { SdodsError } from '../errors.js';
+/**
+ * Iframe steps.
+ *
+ * DESIGN — a frame is entered, not passed around. Every other UI step in this
+ * library resolves against `page`, and threading an optional frame through all
+ * of them would touch every signature for a surface most scenarios never see.
+ * So a scenario *enters* a frame, the subsequent steps here operate inside it,
+ * and it *leaves*. The scope is per-scenario state, held on the page object
+ * rather than in module scope, so parallel workers cannot see each other's.
+ *
+ * WHY THIS EXISTS — a cross-origin payment frame is the single most common
+ * thing a suite cannot reach, and "we do not test checkout" is not a decision
+ * anybody made; it is what happens when the vocabulary has no word for it.
+ */
+const scopesOf = (apiContext, env) => [apiContext.vars.toObject(), env.vars];
+/** Per-page frame scope. A WeakMap, so a closed page's entry is collectable. */
+const entered = new WeakMap();
+function currentFrame(page) {
+    const scope = entered.get(page);
+    if (!scope) {
+        throw new SdodsError('NOT_SUPPORTED', 'No iframe has been entered.', {
+            hint: 'Use `Given I enter the frame "<selector or name>"` before addressing elements inside it.',
+        });
+    }
+    return scope.frame;
+}
+/* ── entering and leaving ─────────────────────────────────────────────── */
+Given('I enter the frame {string}', async ({ page, apiContext, env }, selector) => {
+    const resolved = render(selector, ...scopesOf(apiContext, env));
+    // A bare word is treated as a name/title/id, which is how frames are
+    // usually identified in markup; anything else is a CSS selector.
+    const css = /^[\w-]+$/.test(resolved)
+        ? `iframe[name="${resolved}"], iframe[title="${resolved}"], iframe#${resolved}`
+        : resolved;
+    const handle = page.locator(css).first();
+    // Assert the element EXISTS before entering. `frameLocator` on a selector
+    // that matches nothing fails later, inside an unrelated step, with a
+    // message about the element you were looking for rather than the frame you
+    // never entered.
+    await expect(handle, `the frame "${resolved}" should be present before entering it`).toBeAttached();
+    entered.set(page, { frame: page.frameLocator(css), description: resolved });
+});
+Given('I leave the frame', async ({ page }) => {
+    entered.delete(page);
+});
+/* ── acting inside the frame ──────────────────────────────────────────── */
+When('I fill the frame field {string} with {string}', async ({ page, apiContext, env }, label, value) => {
+    const scopes = scopesOf(apiContext, env);
+    const frame = currentFrame(page);
+    await frame
+        .getByLabel(render(label, ...scopes))
+        .or(frame.getByPlaceholder(render(label, ...scopes)))
+        .first()
+        .fill(render(value, ...scopes));
+});
+When('I click the frame element {string}', async ({ page, apiContext, env }, selector) => {
+    await currentFrame(page)
+        .locator(render(selector, ...scopesOf(apiContext, env)))
+        .first()
+        .click();
+});
+When('I click the frame {role} {string}', async ({ page, apiContext, env }, role, name) => {
+    await currentFrame(page)
+        .getByRole(role, { name: render(name, ...scopesOf(apiContext, env)) })
+        .first()
+        .click();
+});
+/* ── asserting inside the frame ───────────────────────────────────────── */
+Then('the frame should contain the text {string}', async ({ page, apiContext, env }, text) => {
+    await expect(currentFrame(page)
+        .getByText(render(text, ...scopesOf(apiContext, env)))
+        .first()).toBeVisible();
+});
+Then('the frame element {string} should be visible', async ({ page, apiContext, env }, selector) => {
+    await expect(currentFrame(page)
+        .locator(render(selector, ...scopesOf(apiContext, env)))
+        .first()).toBeVisible();
+});
+Then('the page should have {int} frame(s)', async ({ page }, count) => {
+    // `page.frames()` includes the main frame; the count a scenario means is the
+    // number of embedded documents, so the main frame is excluded.
+    await expect
+        .poll(() => page.frames().length - 1, {
+        message: `the page should embed ${count} frame(s)`,
+    })
+        .toBe(count);
+});
+//# sourceMappingURL=iframe.steps.js.map

package/dist/steps/index.d.ts

@@ -7,6 +7,16 @@ import './api.steps.js';
 import './ui.steps.js';
 import './data.steps.js';
 import './hybrid.steps.js';
+import './iframe.steps.js';
+import './tabs.steps.js';
+import './db.steps.js';
+import './clock.steps.js';
+import './webhook.steps.js';
+import './a11y.steps.js';
+import './browser.steps.js';
+import './dom.steps.js';
+import './net.steps.js';
+import './perf.steps.js';
 import '../shots/hooks.js';
-export { coreStepsGlob, coreStepsDir } from './glob.js';
+export { coreStepsGlob, coreStepsPatterns, coreStepNames, coreStepsDir } from './glob.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/steps/index.js

@@ -7,6 +7,16 @@ import './api.steps.js';
 import './ui.steps.js';
 import './data.steps.js';
 import './hybrid.steps.js';
+import './iframe.steps.js';
+import './tabs.steps.js';
+import './db.steps.js';
+import './clock.steps.js';
+import './webhook.steps.js';
+import './a11y.steps.js';
+import './browser.steps.js';
+import './dom.steps.js';
+import './net.steps.js';
+import './perf.steps.js';
 import '../shots/hooks.js';
-export { coreStepsGlob, coreStepsDir } from './glob.js';
+export { coreStepsGlob, coreStepsPatterns, coreStepNames, coreStepsDir } from './glob.js';
 //# sourceMappingURL=index.js.map

package/dist/steps/net.steps.d.ts

@@ -0,0 +1,63 @@
+import './params.js';
+import type { APIRequestContext, TestInfo } from '@playwright/test';
+import type { EnvConfig } from '@sdods/contracts';
+import type { ResolvedConfig } from '../config/resolve.js';
+import type { ApiContext } from '../fixtures/api-context.js';
+export interface RawSnapshot {
+    method: string;
+    url: string;
+    requestBody?: string;
+    status: number;
+    statusText: string;
+    /** Lower-cased, comma-joined by Playwright for repeats — use `setCookies` for Set-Cookie. */
+    headers: Record<string, string>;
+    /** Every individual Set-Cookie line, which `headers()` would have collapsed into one string. */
+    setCookies: string[];
+    body: string;
+}
+export interface SendRawOptions {
+    body?: string;
+    form?: Record<string, string>;
+}
+/**
+ * One request with `maxRedirects: 0`. The whole point is to keep the 3xx instead of chasing it,
+ * and to keep `Set-Cookie` unredacted — the two things the recorded ApiSnapshot cannot carry.
+ */
+export declare function sendRaw(deps: {
+    request: APIRequestContext;
+    apiContext: ApiContext;
+    env: EnvConfig;
+    config: ResolvedConfig;
+    testInfo?: Pick<TestInfo, 'attach'>;
+}, method: string, pathOrUrl: string, opts?: SendRawOptions): Promise<RawSnapshot>;
+export declare function redactForReport(headers: Record<string, string>): Record<string, string>;
+export interface StreamEvent {
+    /** The SSE `event:` field, else the parsed JSON payload's `type`, else the raw sentinel. */
+    type: string | undefined;
+    data: string;
+    json?: unknown;
+}
+export interface StreamCapture {
+    status: number;
+    contentType: string;
+    events: StreamEvent[];
+    /** The body ended on a frame boundary — a stream cut mid-frame does not. */
+    endedWithDelimiter: boolean;
+    /** Transport failure (reset, timeout). Present means the stream did not finish. */
+    error?: string;
+}
+/**
+ * Parse an SSE body into frames. Frames are separated by a blank line; `data:` lines within one
+ * frame join with a newline; a frame carrying only a comment (`: keepalive`) is not an event.
+ */
+export declare function parseEventStream(text: string): Pick<StreamCapture, 'events' | 'endedWithDelimiter'>;
+/**
+ * Playwright `page.route` glob semantics, restricted to the three operators that matter:
+ * `**` matches anything including `/`, `*` matches anything except `/`, `?` matches one
+ * non-`/` character. Anchored, like Playwright's own matcher. Kept deliberately compatible so a
+ * counting step and a `I mock {string} …` step can be given the same string.
+ */
+export declare function globToRegExp(glob: string): RegExp;
+/** Every credential shape found in `text`, named. Exported so the patterns are testable. */
+export declare function credentialFindings(text: string): string[];
+//# sourceMappingURL=net.steps.d.ts.map