@itmetsam/samurai-framework 0.21.5 → 0.22.0

package/dist/browser/emulation.js

@@ -1,180 +0,0 @@
-import { isUnsupported, UnsupportedOperationError, } from "../transport/unsupported.js";
-const ORIENTATIONS = [
-    "portrait-primary",
-    "portrait-secondary",
-    "landscape-primary",
-    "landscape-secondary",
-];
-/** A part of the options could not be applied; what was applied before it stays applied */
-export class EmulationError extends Error {
-    constructor(failed, applied, cause) {
-        const detail = cause instanceof Error ? cause.message : String(cause);
-        super(`emulate(): ${failed} failed${applied.length ? ` after applying ${applied.join(", ")}` : ""}: ${detail}`);
-        this.name = "EmulationError";
-        this.failed = failed;
-        this.applied = applied;
-        this.cause = cause;
-    }
-}
-/** The browser does not implement an emulation command */
-export class EmulationUnsupportedError extends UnsupportedOperationError {
-    constructor(option, applied) {
-        super(`emulate(): ${option} is not supported by the browser`);
-        this.name = "EmulationUnsupportedError";
-        this.option = option;
-        this.applied = applied;
-    }
-}
-const isNumber = (value) => typeof value === "number" && Number.isFinite(value);
-const isPositiveInteger = (value) => Number.isInteger(value) && value > 0;
-/** Turns the options into commands, in a fixed order; throws RangeError for an invalid value, before anything is sent */
-function plan(options) {
-    const steps = [];
-    if (options.locale !== undefined) {
-        if (options.locale !== null) {
-            try {
-                if (options.locale === "" ||
-                    Intl.getCanonicalLocales(options.locale).length !== 1)
-                    throw new RangeError();
-            }
-            catch {
-                throw new RangeError(`emulate(): invalid locale "${options.locale}"`);
-            }
-        }
-        steps.push({
-            option: "locale",
-            method: "emulation.setLocaleOverride",
-            params: { locale: options.locale },
-        });
-    }
-    if (options.timezone !== undefined) {
-        if (options.timezone !== null) {
-            try {
-                new Intl.DateTimeFormat(undefined, { timeZone: options.timezone });
-            }
-            catch {
-                throw new RangeError(`emulate(): unknown timezone "${options.timezone}"`);
-            }
-        }
-        steps.push({
-            option: "timezone",
-            method: "emulation.setTimezoneOverride",
-            params: { timezone: options.timezone },
-        });
-    }
-    if (options.userAgent !== undefined) {
-        if (options.userAgent === "")
-            throw new RangeError("emulate(): userAgent must not be empty");
-        steps.push({
-            option: "userAgent",
-            method: "emulation.setUserAgentOverride",
-            params: { userAgent: options.userAgent },
-        });
-    }
-    if (options.geolocation !== undefined) {
-        const place = options.geolocation;
-        if (place !== null) {
-            if (!isNumber(place.latitude) ||
-                place.latitude < -90 ||
-                place.latitude > 90) {
-                throw new RangeError("emulate(): latitude must be between -90 and 90");
-            }
-            if (!isNumber(place.longitude) ||
-                place.longitude < -180 ||
-                place.longitude > 180) {
-                throw new RangeError("emulate(): longitude must be between -180 and 180");
-            }
-            if (place.accuracy !== undefined &&
-                (!isNumber(place.accuracy) || place.accuracy < 0)) {
-                throw new RangeError("emulate(): accuracy must be 0 or more");
-            }
-        }
-        steps.push({
-            option: "geolocation",
-            method: "emulation.setGeolocationOverride",
-            params: { coordinates: place },
-        });
-    }
-    if (options.offline !== undefined) {
-        steps.push({
-            option: "offline",
-            method: "emulation.setNetworkConditions",
-            params: {
-                networkConditions: options.offline ? { type: "offline" } : null,
-            },
-        });
-    }
-    if (options.orientation !== undefined) {
-        let screenOrientation = null;
-        if (options.orientation !== null) {
-            const type = (options.orientation === "portrait" ||
-                options.orientation === "landscape"
-                ? `${options.orientation}-primary`
-                : options.orientation);
-            if (!ORIENTATIONS.includes(type))
-                throw new RangeError(`emulate(): unknown orientation "${options.orientation}"`);
-            screenOrientation = {
-                natural: type.startsWith("portrait") ? "portrait" : "landscape",
-                type,
-            };
-        }
-        steps.push({
-            option: "orientation",
-            method: "emulation.setScreenOrientationOverride",
-            params: { screenOrientation },
-        });
-    }
-    if (options.screen !== undefined) {
-        const area = options.screen;
-        if (area !== null &&
-            !(isPositiveInteger(area.width) && isPositiveInteger(area.height))) {
-            throw new RangeError("emulate(): screen width and height must be positive integers");
-        }
-        steps.push({
-            option: "screen",
-            method: "emulation.setScreenSettingsOverride",
-            params: { screenArea: area },
-        });
-    }
-    if (options.touch !== undefined) {
-        if (options.touch !== null && !isPositiveInteger(options.touch)) {
-            throw new RangeError("emulate(): touch must be a positive integer");
-        }
-        steps.push({
-            option: "touch",
-            method: "emulation.setTouchOverride",
-            params: { maxTouchPoints: options.touch },
-        });
-    }
-    if (options.javaScriptEnabled !== undefined) {
-        steps.push({
-            option: "javaScriptEnabled",
-            method: "emulation.setScriptingEnabled",
-            params: { enabled: options.javaScriptEnabled === false ? false : null },
-        });
-    }
-    return steps;
-}
-/** Throws RangeError when a value is invalid, without sending anything */
-export function validateEmulation(options) {
-    plan(options);
-}
-/**
- * Applies the options to `target`, one command after the other. Nothing is rolled back when one fails:
- * the error says what was applied.
- */
-export async function applyEmulation(connector, target, options) {
-    const applied = [];
-    for (const step of plan(options)) {
-        try {
-            await connector.send(step.method, { ...step.params, ...target });
-        }
-        catch (err) {
-            if (isUnsupported(err)) {
-                throw new EmulationUnsupportedError(step.option, applied);
-            }
-            throw new EmulationError(step.option, applied, err);
-        }
-        applied.push(step.option);
-    }
-}