@testpulse.run/reporter 0.1.1

package/dist/live/StreamUploader.d.ts

@@ -0,0 +1,21 @@
+import type { LiveCaptureState, SegmentKind, StreamDescriptor } from "./types.js";
+export declare class StreamUploader {
+    private readonly session;
+    private readonly streamId;
+    private readonly descriptor;
+    private readonly captureStartedAt;
+    private firstInitUploaded;
+    private firstMediaUploaded;
+    constructor(session: LiveCaptureState, streamId: string, descriptor: StreamDescriptor, captureStartedAt: number);
+    start(): Promise<void>;
+    uploadPreview(frame: Buffer): Promise<void>;
+    uploadSegment(segment: {
+        sequence: number;
+        gopId: number;
+        segmentKind: SegmentKind;
+        payload: Buffer;
+        publishedAtUtc: string;
+    }): Promise<void>;
+    stop(): Promise<void>;
+    private buildHeaders;
+}

package/dist/live/StreamUploader.js

@@ -0,0 +1,78 @@
+import { postJson, postJsonOrThrow } from "../shared/http.js";
+import { logTiming } from "./telemetry.js";
+export class StreamUploader {
+    session;
+    streamId;
+    descriptor;
+    captureStartedAt;
+    firstInitUploaded = false;
+    firstMediaUploaded = false;
+    constructor(session, streamId, descriptor, captureStartedAt) {
+        this.session = session;
+        this.streamId = streamId;
+        this.descriptor = descriptor;
+        this.captureStartedAt = captureStartedAt;
+    }
+    async start() {
+        await postJsonOrThrow(`${this.session.endpoint}/ingest/v1/projects/${encodeURIComponent(this.session.projectId)}/runs/${this.session.runId}/stream/start`, {
+            token: this.session.streamPublisherToken,
+            streamId: this.streamId,
+            profile: this.descriptor.profile,
+            mimeCodec: this.descriptor.mimeCodec,
+            width: this.descriptor.width,
+            height: this.descriptor.height,
+            framesPerSecond: this.descriptor.framesPerSecond,
+            targetBitrateKbps: this.descriptor.targetBitrateKbps,
+            segmentDurationMs: this.descriptor.segmentDurationMs,
+            gopDurationMs: this.descriptor.gopDurationMs
+        }, "TestPulse live request failed with", this.buildHeaders());
+    }
+    async uploadPreview(frame) {
+        await postJsonOrThrow(`${this.session.endpoint}/ingest/v1/projects/${encodeURIComponent(this.session.projectId)}/runs/${this.session.runId}/stream/preview`, {
+            token: this.session.streamPublisherToken,
+            streamId: this.streamId,
+            capturedAtUtc: new Date().toISOString(),
+            contentType: "image/jpeg",
+            payloadBase64: frame.toString("base64"),
+            width: this.descriptor.width,
+            height: this.descriptor.height
+        }, "TestPulse live request failed with", this.buildHeaders());
+    }
+    async uploadSegment(segment) {
+        await postJsonOrThrow(`${this.session.endpoint}/ingest/v1/projects/${encodeURIComponent(this.session.projectId)}/runs/${this.session.runId}/stream/segments`, {
+            token: this.session.streamPublisherToken,
+            streamId: this.streamId,
+            sequence: segment.sequence,
+            segmentKind: segment.segmentKind,
+            gopId: segment.gopId,
+            ptsStart: segment.sequence * this.descriptor.segmentDurationMs,
+            ptsEnd: (segment.sequence + 1) * this.descriptor.segmentDurationMs,
+            durationMs: this.descriptor.segmentDurationMs,
+            publishedAtUtc: segment.publishedAtUtc,
+            discontinuity: false,
+            streamResetRequired: false,
+            mimeCodec: this.descriptor.mimeCodec,
+            payloadBase64: segment.payload.toString("base64")
+        }, "TestPulse live request failed with", this.buildHeaders());
+        if (segment.segmentKind === "init" && !this.firstInitUploaded) {
+            this.firstInitUploaded = true;
+            logTiming("firstInitSegmentUploaded", this.captureStartedAt, { sequence: segment.sequence });
+        }
+        if (segment.segmentKind === "media" && !this.firstMediaUploaded) {
+            this.firstMediaUploaded = true;
+            logTiming("firstMediaSegmentUploaded", this.captureStartedAt, { sequence: segment.sequence });
+        }
+    }
+    async stop() {
+        await postJson(`${this.session.endpoint}/ingest/v1/projects/${encodeURIComponent(this.session.projectId)}/runs/${this.session.runId}/stream/stop`, {
+            token: this.session.streamPublisherToken,
+            streamId: this.streamId,
+            reason: "capture-stopped"
+        }, this.buildHeaders());
+    }
+    buildHeaders() {
+        return {
+            "X-Project-Api-Key": this.session.apiKey
+        };
+    }
+}

package/dist/live/telemetry.d.ts

@@ -0,0 +1,3 @@
+import type { TimingKey } from "./types.js";
+export declare function logTiming(key: TimingKey, captureStartedAt?: number, extra?: Record<string, number | string>): void;
+export declare function createTimingLogger(captureStartedAt: number): (key: TimingKey, extra?: Record<string, number | string>) => void;

package/dist/live/telemetry.js

@@ -0,0 +1,15 @@
+export function logTiming(key, captureStartedAt = Date.now(), extra) {
+    const elapsedMs = Math.max(0, Date.now() - captureStartedAt);
+    const suffix = extra ? ` ${JSON.stringify(extra)}` : "";
+    console.info(`[TestPulse] ${key} ${elapsedMs}ms${suffix}`);
+}
+export function createTimingLogger(captureStartedAt) {
+    const loggedTimings = new Set();
+    return (key, extra) => {
+        if (loggedTimings.has(key)) {
+            return;
+        }
+        loggedTimings.add(key);
+        logTiming(key, captureStartedAt, extra);
+    };
+}

package/dist/live/types.d.ts

@@ -0,0 +1,41 @@
+import type { Page } from "@playwright/test";
+export type LiveCaptureState = {
+    endpoint: string;
+    projectId: string;
+    apiKey: string;
+    runId: string;
+    streamPublisherToken: string;
+    createdAt: string;
+    intervalMs?: number;
+    profile?: StreamProfile;
+};
+export type StreamProfile = "focus" | "grid";
+export type StreamDescriptor = {
+    streamId: string;
+    profile: StreamProfile;
+    mimeCodec: string;
+    width: number;
+    height: number;
+    framesPerSecond: number;
+    targetBitrateKbps: number;
+    segmentDurationMs: number;
+    gopDurationMs: number;
+};
+export type SegmentKind = "init" | "media";
+export type TimingKey = "captureStart" | "firstScreenshotTaken" | "previewPosted" | "firstFrameWrittenToEncoder" | "firstInitSegmentUploaded" | "firstMediaSegmentUploaded";
+export interface LiveCaptureOptions {
+    endpoint?: string;
+    projectId?: string;
+    apiKey?: string;
+    runId?: string;
+    streamPublisherToken?: string;
+    sessionKey?: string;
+    stateDirectory?: string;
+    intervalMs?: number;
+    profile?: StreamProfile;
+}
+export interface LiveCaptureHandle {
+    stop(): Promise<void>;
+}
+export interface LivePage extends Pick<Page, "screenshot" | "viewportSize"> {
+}

package/dist/live/types.js

@@ -0,0 +1 @@
+export {};

package/dist/reporter/ArtifactUploader.d.ts

@@ -0,0 +1,13 @@
+import type { TestCase, TestResult } from "@playwright/test/reporter";
+import type { EventQueue } from "./EventQueue.js";
+import type { RunClient } from "./RunClient.js";
+export declare class ArtifactUploader {
+    private readonly eventQueue;
+    private readonly ensureRunStarted;
+    private readonly runClient;
+    private readonly uploadedArtifacts;
+    constructor(eventQueue: EventQueue, ensureRunStarted: () => Promise<string>, runClient: RunClient);
+    enqueueArtifacts(test: TestCase, result: TestResult, eventSequence: number): void;
+}
+export declare function getArtifactType(attachment: TestResult["attachments"][number]): "image" | "video" | null;
+export declare function getContentType(artifactType: "image" | "video"): string;

package/dist/reporter/ArtifactUploader.js

@@ -0,0 +1,48 @@
+export class ArtifactUploader {
+    eventQueue;
+    ensureRunStarted;
+    runClient;
+    uploadedArtifacts = new Set();
+    constructor(eventQueue, ensureRunStarted, runClient) {
+        this.eventQueue = eventQueue;
+        this.ensureRunStarted = ensureRunStarted;
+        this.runClient = runClient;
+    }
+    enqueueArtifacts(test, result, eventSequence) {
+        for (const attachment of result.attachments ?? []) {
+            if (!attachment.path) {
+                continue;
+            }
+            const artifactType = getArtifactType(attachment);
+            if (!artifactType || this.uploadedArtifacts.has(attachment.path)) {
+                continue;
+            }
+            this.uploadedArtifacts.add(attachment.path);
+            this.eventQueue.enqueue(async () => {
+                const runId = await this.ensureRunStarted();
+                await this.runClient.uploadArtifact(runId, {
+                    artifactType,
+                    filePath: attachment.path,
+                    contentType: attachment.contentType ?? getContentType(artifactType),
+                    testId: test.id,
+                    eventSequence: artifactType === "image" ? eventSequence : undefined
+                });
+            });
+        }
+    }
+}
+export function getArtifactType(attachment) {
+    const contentType = attachment.contentType?.toLowerCase() ?? "";
+    const name = attachment.name?.toLowerCase() ?? "";
+    const path = attachment.path?.toLowerCase() ?? "";
+    if (contentType.startsWith("image/") || name.includes("screenshot") || /\.(png|jpe?g|webp)$/i.test(path)) {
+        return "image";
+    }
+    if (contentType.startsWith("video/") || name.includes("video") || /\.(webm|mp4)$/i.test(path)) {
+        return "video";
+    }
+    return null;
+}
+export function getContentType(artifactType) {
+    return artifactType === "image" ? "image/png" : "video/webm";
+}

package/dist/reporter/EventQueue.d.ts

@@ -0,0 +1,7 @@
+export declare class EventQueue {
+    private sequence;
+    private chain;
+    nextSequence(task: (sequence: number) => Promise<void>): number;
+    enqueue(task: () => Promise<void>): void;
+    flush(): Promise<void>;
+}

package/dist/reporter/EventQueue.js

@@ -0,0 +1,15 @@
+export class EventQueue {
+    sequence = 0;
+    chain = Promise.resolve();
+    nextSequence(task) {
+        const sequence = ++this.sequence;
+        this.chain = this.chain.then(() => task(sequence));
+        return sequence;
+    }
+    enqueue(task) {
+        this.chain = this.chain.then(task);
+    }
+    async flush() {
+        await this.chain;
+    }
+}

package/dist/reporter/GitRuntimeMetadataResolver.d.ts

@@ -0,0 +1,11 @@
+type CommandExecutor = (command: string, args: string[], cwd: string) => Promise<string>;
+export interface GitRuntimeMetadataOptions {
+    branch?: string;
+    commitSha?: string;
+}
+export interface GitRuntimeMetadata {
+    branch?: string;
+    commitSha?: string;
+}
+export declare function resolveGitRuntimeMetadata(options: GitRuntimeMetadataOptions, cwd?: string, environment?: NodeJS.ProcessEnv, executor?: CommandExecutor): Promise<GitRuntimeMetadata>;
+export {};

package/dist/reporter/GitRuntimeMetadataResolver.js

@@ -0,0 +1,93 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const branchEnvironmentVariables = [
+    "TESTPULSE_BRANCH",
+    "GITHUB_HEAD_REF",
+    "GITHUB_REF_NAME",
+    "CI_COMMIT_REF_NAME",
+    "BUILD_SOURCEBRANCHNAME",
+    "BRANCH_NAME"
+];
+const commitEnvironmentVariables = [
+    "TESTPULSE_COMMIT_SHA",
+    "GITHUB_SHA",
+    "CI_COMMIT_SHA",
+    "BUILD_SOURCEVERSION",
+    "COMMIT_SHA"
+];
+export async function resolveGitRuntimeMetadata(options, cwd = process.cwd(), environment = process.env, executor = executeGitCommand) {
+    const branch = options.branch?.trim() || getFirstEnvironmentValue(branchEnvironmentVariables, environment);
+    const configuredCommitSha = options.commitSha?.trim();
+    if (branch && configuredCommitSha) {
+        return {
+            branch,
+            commitSha: configuredCommitSha
+        };
+    }
+    const gitBranch = branch || await tryGetGitBranch(cwd, executor);
+    const commitSha = configuredCommitSha || await tryGetGitCommit(cwd, environment, executor);
+    if (!commitSha) {
+        return {
+            branch: gitBranch || undefined,
+            commitSha: undefined
+        };
+    }
+    const hasPendingChanges = await tryHasPendingChanges(cwd, executor);
+    const displayCommitSha = shortenCommitSha(commitSha);
+    return {
+        branch: gitBranch || undefined,
+        commitSha: hasPendingChanges ? `${displayCommitSha} + pending changes` : displayCommitSha
+    };
+}
+async function tryGetGitBranch(cwd, executor) {
+    try {
+        const branch = await executor("git", ["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+        if (!branch || branch === "HEAD") {
+            return undefined;
+        }
+        return branch;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function tryGetGitCommit(cwd, environment, executor) {
+    const environmentCommit = getFirstEnvironmentValue(commitEnvironmentVariables, environment);
+    if (environmentCommit) {
+        return environmentCommit;
+    }
+    try {
+        return await executor("git", ["rev-parse", "HEAD"], cwd);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function tryHasPendingChanges(cwd, executor) {
+    try {
+        const status = await executor("git", ["status", "--porcelain"], cwd);
+        return status.length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+function getFirstEnvironmentValue(keys, environment) {
+    for (const key of keys) {
+        const value = environment[key]?.trim();
+        if (value) {
+            return value;
+        }
+    }
+    return undefined;
+}
+async function executeGitCommand(command, args, cwd) {
+    const result = await execFileAsync(command, args, { cwd });
+    return result.stdout.trim();
+}
+function shortenCommitSha(commitSha) {
+    return /^[0-9a-f]{8,}$/i.test(commitSha)
+        ? commitSha.slice(0, 7)
+        : commitSha;
+}

package/dist/reporter/PlaywrightReporter.d.ts

@@ -0,0 +1,21 @@
+import type { FullConfig, FullResult, Reporter, Suite, TestCase, TestResult } from "@playwright/test/reporter";
+import type { TestPulseReporterOptions } from "./types.js";
+export default class TestPulseReporter implements Reporter {
+    private readonly options;
+    private runId;
+    private metadataPromise;
+    private readonly eventQueue;
+    private readonly runClient;
+    private readonly artifactUploader;
+    private readonly resolvedOptions;
+    constructor(options: TestPulseReporterOptions);
+    onBegin(_config: FullConfig, _suite: Suite): Promise<void>;
+    onTestBegin(test: TestCase): void;
+    onTestEnd(test: TestCase, result: TestResult): void;
+    onStdOut(chunk: string | Buffer, test?: TestCase): void;
+    onStdErr(chunk: string | Buffer, test?: TestCase): void;
+    onEnd(result: FullResult): Promise<void>;
+    printsToStdio(): boolean;
+    private enqueueEvent;
+    private ensureRunStarted;
+}

package/dist/reporter/PlaywrightReporter.js

@@ -0,0 +1,126 @@
+import { deleteLiveCaptureState, writeLiveCaptureState } from "../live/LiveSessionState.js";
+import { resolveTestPulseEndpoint } from "../shared/endpoint.js";
+import { ArtifactUploader } from "./ArtifactUploader.js";
+import { EventQueue } from "./EventQueue.js";
+import { resolveGitRuntimeMetadata } from "./GitRuntimeMetadataResolver.js";
+import { RunClient } from "./RunClient.js";
+export default class TestPulseReporter {
+    options;
+    runId = null;
+    metadataPromise = null;
+    eventQueue = new EventQueue();
+    runClient;
+    artifactUploader;
+    resolvedOptions;
+    constructor(options) {
+        this.options = options;
+        this.resolvedOptions = {
+            ...options,
+            endpoint: resolveTestPulseEndpoint(options.endpoint)
+        };
+        this.runClient = new RunClient(this.resolvedOptions);
+        this.artifactUploader = new ArtifactUploader(this.eventQueue, () => this.ensureRunStarted(), this.runClient);
+    }
+    async onBegin(_config, _suite) {
+        await this.ensureRunStarted();
+    }
+    onTestBegin(test) {
+        this.enqueueEvent("test.started", {
+            testId: test.id,
+            testName: test.title,
+            location: test.location?.file
+        });
+    }
+    onTestEnd(test, result) {
+        const eventType = result.status === "passed"
+            ? "test.passed"
+            : result.status === "skipped"
+                ? "test.skipped"
+                : "test.failed";
+        const eventSequence = this.enqueueEvent(eventType, {
+            testId: test.id,
+            testName: test.title,
+            durationMs: result.duration,
+            retry: result.retry,
+            message: result.error?.message ?? null
+        });
+        if (result.retry > 0) {
+            this.enqueueEvent("test.retried", {
+                testId: test.id,
+                testName: test.title,
+                retry: result.retry
+            });
+        }
+        this.artifactUploader.enqueueArtifacts(test, result, eventSequence);
+    }
+    onStdOut(chunk, test) {
+        this.enqueueEvent("log", {
+            level: "info",
+            message: chunk.toString(),
+            testId: test?.id ?? null
+        });
+    }
+    onStdErr(chunk, test) {
+        this.enqueueEvent("log", {
+            level: "error",
+            message: chunk.toString(),
+            testId: test?.id ?? null
+        });
+    }
+    async onEnd(result) {
+        const runId = await this.ensureRunStarted();
+        await this.eventQueue.flush();
+        try {
+            await this.runClient.completeRun(runId, result.status === "failed" ? "Failed" : "Completed");
+        }
+        finally {
+            if (this.options.liveStreamingEnabled) {
+                await deleteLiveCaptureState(this.options.liveStreamSessionKey, this.options.liveCaptureStateDirectory);
+            }
+        }
+    }
+    printsToStdio() {
+        return false;
+    }
+    enqueueEvent(eventType, payload) {
+        return this.eventQueue.nextSequence(async (sequence) => {
+            const runId = await this.ensureRunStarted();
+            const envelope = {
+                sequence,
+                timestamp: new Date().toISOString(),
+                eventType,
+                payload
+            };
+            await this.runClient.sendEvents(runId, [envelope]);
+        });
+    }
+    async ensureRunStarted() {
+        if (this.runId) {
+            return this.runId;
+        }
+        if (!this.metadataPromise) {
+            this.metadataPromise = resolveGitRuntimeMetadata({
+                branch: this.options.branch,
+                commitSha: this.options.commitSha
+            });
+        }
+        const metadata = await this.metadataPromise;
+        const payload = await this.runClient.startRun(metadata);
+        this.runId = payload.runId;
+        if (this.options.liveStreamingEnabled) {
+            if (!payload.streamPublisherToken) {
+                throw new Error("TestPulse live streaming token was not returned by the backend.");
+            }
+            await writeLiveCaptureState({
+                endpoint: this.resolvedOptions.endpoint,
+                projectId: this.options.projectId,
+                apiKey: this.options.apiKey,
+                runId: this.runId,
+                streamPublisherToken: payload.streamPublisherToken,
+                createdAt: new Date().toISOString(),
+                intervalMs: this.options.liveCaptureIntervalMs
+            }, this.options.liveStreamSessionKey, this.options.liveCaptureStateDirectory);
+        }
+        return this.runId;
+    }
+}

package/dist/reporter/RunClient.d.ts

@@ -0,0 +1,19 @@
+import type { ResolvedTestPulseReporterOptions, RunEventEnvelope, StartRunResponse } from "./types.js";
+export declare class RunClient {
+    private readonly options;
+    constructor(options: ResolvedTestPulseReporterOptions);
+    startRun(metadata: {
+        branch?: string;
+        commitSha?: string;
+    }): Promise<StartRunResponse>;
+    sendEvents(runId: string, events: RunEventEnvelope[]): Promise<void>;
+    completeRun(runId: string, status: "Failed" | "Completed"): Promise<void>;
+    uploadArtifact(runId: string, artifact: {
+        artifactType: "image" | "video";
+        filePath: string;
+        contentType: string;
+        testId: string;
+        eventSequence?: number;
+    }): Promise<void>;
+    private buildHeaders;
+}

package/dist/reporter/RunClient.js

@@ -0,0 +1,42 @@
+import { readFile } from "node:fs/promises";
+import { postJson, postJsonOrThrow } from "../shared/http.js";
+export class RunClient {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async startRun(metadata) {
+        const response = await postJsonOrThrow(`${this.options.endpoint}/ingest/v1/projects/${encodeURIComponent(this.options.projectId)}/runs/start`, {
+            runName: this.options.runName,
+            branch: metadata.branch,
+            commitSha: metadata.commitSha
+        }, "TestPulse run start failed with", this.buildHeaders());
+        return response.json();
+    }
+    async sendEvents(runId, events) {
+        await postJson(`${this.options.endpoint}/ingest/v1/projects/${encodeURIComponent(this.options.projectId)}/runs/${runId}/events`, { events }, this.buildHeaders());
+    }
+    async completeRun(runId, status) {
+        await postJson(`${this.options.endpoint}/ingest/v1/projects/${encodeURIComponent(this.options.projectId)}/runs/${runId}/complete`, { status }, this.buildHeaders());
+    }
+    async uploadArtifact(runId, artifact) {
+        const bytes = await readFile(artifact.filePath);
+        const formData = new FormData();
+        formData.append("artifactType", artifact.artifactType);
+        formData.append("testId", artifact.testId);
+        if (artifact.eventSequence !== undefined) {
+            formData.append("eventSequence", String(artifact.eventSequence));
+        }
+        formData.append("file", new Blob([bytes], { type: artifact.contentType }), artifact.filePath.split(/[\\/]/).pop() ?? `${artifact.artifactType}.bin`);
+        await fetch(`${this.options.endpoint}/ingest/v1/projects/${encodeURIComponent(this.options.projectId)}/runs/${runId}/artifacts`, {
+            method: "POST",
+            headers: this.buildHeaders(),
+            body: formData
+        });
+    }
+    buildHeaders() {
+        return {
+            "X-Project-Api-Key": this.options.apiKey
+        };
+    }
+}

package/dist/reporter/types.d.ts

@@ -0,0 +1,26 @@
+export interface TestPulseReporterOptions {
+    endpoint?: string;
+    projectId: string;
+    apiKey: string;
+    runName?: string;
+    branch?: string;
+    commitSha?: string;
+    liveStreamingEnabled?: boolean;
+    liveCaptureIntervalMs?: number;
+    liveStreamSessionKey?: string;
+    liveCaptureStateDirectory?: string;
+}
+export type EventPayload = Record<string, unknown>;
+export type RunEventEnvelope = {
+    sequence: number;
+    timestamp: string;
+    eventType: string;
+    payload: EventPayload;
+};
+export type StartRunResponse = {
+    runId: string;
+    streamPublisherToken?: string;
+};
+export interface ResolvedTestPulseReporterOptions extends Omit<TestPulseReporterOptions, "endpoint"> {
+    endpoint: string;
+}

package/dist/reporter/types.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/endpoint.d.ts

@@ -0,0 +1 @@
+export declare function resolveTestPulseEndpoint(endpoint: string | undefined, environment?: NodeJS.ProcessEnv): string;

package/dist/shared/endpoint.js

@@ -0,0 +1,25 @@
+const defaultEndpoints = {
+    production: "https://testpulse.mevodo.com",
+    staging: "https://testpulse.staging.mevodo.com",
+    local: "http://localhost:5123"
+};
+export function resolveTestPulseEndpoint(endpoint, environment = process.env) {
+    const explicitEndpoint = trim(endpoint) ?? trim(environment.TESTPULSE_ENDPOINT);
+    if (explicitEndpoint) {
+        return trimTrailingSlash(explicitEndpoint);
+    }
+    return defaultEndpoints[parseEnvironment(environment.TESTPULSE_ENV)];
+}
+function parseEnvironment(value) {
+    const normalized = value?.trim().toLowerCase();
+    return normalized === "local" || normalized === "staging"
+        ? normalized
+        : "production";
+}
+function trim(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function trimTrailingSlash(value) {
+    return value.replace(/\/+$/, "");
+}

package/dist/shared/http.d.ts

@@ -0,0 +1,2 @@
+export declare function postJson(url: string, body: unknown, headers?: HeadersInit): Promise<Response>;
+export declare function postJsonOrThrow(url: string, body: unknown, errorPrefix: string, headers?: HeadersInit): Promise<Response>;

package/dist/shared/http.js

@@ -0,0 +1,17 @@
+export async function postJson(url, body, headers = {}) {
+    return fetch(url, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            ...headers
+        },
+        body: JSON.stringify(body)
+    });
+}
+export async function postJsonOrThrow(url, body, errorPrefix, headers = {}) {
+    const response = await postJson(url, body, headers);
+    if (!response.ok) {
+        throw new Error(`${errorPrefix} ${response.status}.`);
+    }
+    return response;
+}