@empiricalrun/playwright-utils 0.6.3 → 0.7.1

package/dist/reporter/util.js

@@ -0,0 +1,351 @@
+"use strict";
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveImportSpecifierExtension = exports.fileIsModule = exports.normalizeAndSaveAttachment = exports.resolveReporterOutputPath = exports.getPackageJsonPath = exports.callLogText = exports.debugTest = exports.getContainedPath = exports.sanitizeFilePathBeforeExtension = exports.addSuffixToFilePath = exports.trimLongString = exports.windowsFilesystemFriendlyLength = exports.expectTypes = exports.errorWithFile = exports.formatLocation = exports.relativeFilePath = exports.forceRegExp = exports.mergeObjects = exports.createTitleMatcher = exports.createFileMatcher = exports.createFileMatcherFromArguments = exports.createFileFiltersFromArguments = exports.serializeError = exports.filteredStackTrace = exports.filterStackFile = exports.filterStackTrace = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("playwright-core/lib/utils");
+const utilsBundle_1 = require("playwright-core/lib/utilsBundle");
+const url_1 = __importDefault(require("url"));
+const util_1 = __importDefault(require("util"));
+const PLAYWRIGHT_TEST_PATH = path_1.default.join(__dirname, "..");
+const PLAYWRIGHT_CORE_PATH = path_1.default.dirname(require.resolve("playwright-core/package.json"));
+function filterStackTrace(e) {
+    const name = e.name ? e.name + ": " : "";
+    // if (process.env.PWDEBUGIMPL)
+    //   return { message: name + e.message, stack: e.stack || "" };
+    const stackLines = (0, utils_1.stringifyStackFrames)(filteredStackTrace(e.stack?.split("\n") || []));
+    return {
+        message: name + e.message,
+        // @ts-ignore - not able to get types from playwright-core
+        stack: `${name}${e.message}${stackLines.map((line) => "\n" + line).join("")}`,
+    };
+}
+exports.filterStackTrace = filterStackTrace;
+function filterStackFile(file) {
+    if ( /*!process.env.PWDEBUGIMPL &&*/file.startsWith(PLAYWRIGHT_TEST_PATH))
+        return false;
+    if ( /*!process.env.PWDEBUGIMPL &&*/file.startsWith(PLAYWRIGHT_CORE_PATH))
+        return false;
+    return true;
+}
+exports.filterStackFile = filterStackFile;
+function filteredStackTrace(rawStack) {
+    const frames = [];
+    for (const line of rawStack) {
+        const frame = (0, utilsBundle_1.parseStackTraceLine)(line);
+        if (!frame || !frame.file)
+            continue;
+        if (!filterStackFile(frame.file))
+            continue;
+        frames.push(frame);
+    }
+    return frames;
+}
+exports.filteredStackTrace = filteredStackTrace;
+function serializeError(error) {
+    if (error instanceof Error)
+        return filterStackTrace(error);
+    return {
+        value: util_1.default.inspect(error),
+    };
+}
+exports.serializeError = serializeError;
+function createFileFiltersFromArguments(args) {
+    return args.map((arg) => {
+        const match = /^(.*?):(\d+):?(\d+)?$/.exec(arg);
+        // !!ARUSH
+        return {
+            re: forceRegExp(match ? (match[1] ?? "") : arg),
+            line: match ? parseInt(match[2] ?? "", 10) : null,
+            column: match?.[3] ? parseInt(match[3], 10) : null,
+        };
+    });
+}
+exports.createFileFiltersFromArguments = createFileFiltersFromArguments;
+function createFileMatcherFromArguments(args) {
+    const filters = createFileFiltersFromArguments(args);
+    return createFileMatcher(filters.map((filter) => filter.re || filter.exact || ""));
+}
+exports.createFileMatcherFromArguments = createFileMatcherFromArguments;
+function createFileMatcher(patterns) {
+    const reList = [];
+    const filePatterns = [];
+    for (const pattern of Array.isArray(patterns) ? patterns : [patterns]) {
+        // @empiricalrun
+        if ((0, utils_1.isRegExp)(pattern) && typeof pattern !== "string") {
+            reList.push(pattern);
+        }
+        else {
+            // @empiricalrun
+            if (typeof pattern !== "string")
+                continue;
+            if (!pattern.startsWith("**/"))
+                filePatterns.push("**/" + pattern);
+            else
+                filePatterns.push(pattern);
+        }
+    }
+    return (filePath) => {
+        for (const re of reList) {
+            re.lastIndex = 0;
+            if (re.test(filePath))
+                return true;
+        }
+        // Windows might still receive unix style paths from Cygwin or Git Bash.
+        // Check against the file url as well.
+        if (path_1.default.sep === "\\") {
+            const fileURL = url_1.default.pathToFileURL(filePath).href;
+            for (const re of reList) {
+                re.lastIndex = 0;
+                if (re.test(fileURL))
+                    return true;
+            }
+        }
+        for (const pattern of filePatterns) {
+            if ((0, utilsBundle_1.minimatch)(filePath, pattern, { nocase: true, dot: true }))
+                return true;
+        }
+        return false;
+    };
+}
+exports.createFileMatcher = createFileMatcher;
+function createTitleMatcher(patterns) {
+    const reList = Array.isArray(patterns) ? patterns : [patterns];
+    return (value) => {
+        for (const re of reList) {
+            re.lastIndex = 0;
+            if (re.test(value))
+                return true;
+        }
+        return false;
+    };
+}
+exports.createTitleMatcher = createTitleMatcher;
+function mergeObjects(a, b, c) {
+    const result = { ...a };
+    for (const x of [b, c].filter(Boolean)) {
+        for (const [name, value] of Object.entries(x)) {
+            if (!Object.is(value, undefined))
+                result[name] = value;
+        }
+    }
+    return result;
+}
+exports.mergeObjects = mergeObjects;
+function forceRegExp(pattern) {
+    const match = pattern.match(/^\/(.*)\/([gi]*)$/);
+    // @empiricalrun
+    if (match)
+        return new RegExp(match[1] ?? "", match[2]);
+    return new RegExp(pattern, "gi");
+}
+exports.forceRegExp = forceRegExp;
+function relativeFilePath(file) {
+    if (!path_1.default.isAbsolute(file))
+        return file;
+    return path_1.default.relative(process.cwd(), file);
+}
+exports.relativeFilePath = relativeFilePath;
+function formatLocation(location) {
+    return (relativeFilePath(location.file) +
+        ":" +
+        location.line +
+        ":" +
+        location.column);
+}
+exports.formatLocation = formatLocation;
+function errorWithFile(file, message) {
+    return new Error(`${relativeFilePath(file)}: ${message}`);
+}
+exports.errorWithFile = errorWithFile;
+function expectTypes(receiver, types, matcherName) {
+    if (typeof receiver !== "object" ||
+        !types.includes(receiver.constructor.name)) {
+        const commaSeparated = types.slice();
+        const lastType = commaSeparated.pop();
+        const typesString = commaSeparated.length
+            ? commaSeparated.join(", ") + " or " + lastType
+            : lastType;
+        throw new Error(`${matcherName} can be only used with ${typesString} object${types.length > 1 ? "s" : ""}`);
+    }
+}
+exports.expectTypes = expectTypes;
+exports.windowsFilesystemFriendlyLength = 60;
+function trimLongString(s, length = 100) {
+    if (s.length <= length)
+        return s;
+    const hash = (0, utils_1.calculateSha1)(s);
+    const middle = `-${hash.substring(0, 5)}-`;
+    const start = Math.floor((length - middle.length) / 2);
+    const end = length - middle.length - start;
+    return s.substring(0, start) + middle + s.slice(-end);
+}
+exports.trimLongString = trimLongString;
+function addSuffixToFilePath(filePath, suffix) {
+    const ext = path_1.default.extname(filePath);
+    const base = filePath.substring(0, filePath.length - ext.length);
+    return base + suffix + ext;
+}
+exports.addSuffixToFilePath = addSuffixToFilePath;
+function sanitizeFilePathBeforeExtension(filePath) {
+    const ext = path_1.default.extname(filePath);
+    const base = filePath.substring(0, filePath.length - ext.length);
+    return (0, utils_1.sanitizeForFilePath)(base) + ext;
+}
+exports.sanitizeFilePathBeforeExtension = sanitizeFilePathBeforeExtension;
+/**
+ * Returns absolute path contained within parent directory.
+ */
+function getContainedPath(parentPath, subPath = "") {
+    const resolvedPath = path_1.default.resolve(parentPath, subPath);
+    if (resolvedPath === parentPath ||
+        resolvedPath.startsWith(parentPath + path_1.default.sep))
+        return resolvedPath;
+    return null;
+}
+exports.getContainedPath = getContainedPath;
+exports.debugTest = (0, utilsBundle_1.debug)("pw:test");
+exports.callLogText = utils_1.formatCallLog;
+const folderToPackageJsonPath = new Map();
+function getPackageJsonPath(folderPath) {
+    const cached = folderToPackageJsonPath.get(folderPath);
+    if (cached !== undefined)
+        return cached;
+    const packageJsonPath = path_1.default.join(folderPath, "package.json");
+    if (fs_1.default.existsSync(packageJsonPath)) {
+        folderToPackageJsonPath.set(folderPath, packageJsonPath);
+        return packageJsonPath;
+    }
+    const parentFolder = path_1.default.dirname(folderPath);
+    if (folderPath === parentFolder) {
+        folderToPackageJsonPath.set(folderPath, "");
+        return "";
+    }
+    const result = getPackageJsonPath(parentFolder);
+    folderToPackageJsonPath.set(folderPath, result);
+    return result;
+}
+exports.getPackageJsonPath = getPackageJsonPath;
+function resolveReporterOutputPath(defaultValue, configDir, configValue) {
+    if (configValue)
+        return path_1.default.resolve(configDir, configValue);
+    let basePath = getPackageJsonPath(configDir);
+    basePath = basePath ? path_1.default.dirname(basePath) : process.cwd();
+    return path_1.default.resolve(basePath, defaultValue);
+}
+exports.resolveReporterOutputPath = resolveReporterOutputPath;
+async function normalizeAndSaveAttachment(outputPath, name, options = {}) {
+    if (options.path === undefined && options.body === undefined)
+        return { name, contentType: "text/plain" };
+    if ((options.path !== undefined ? 1 : 0) +
+        (options.body !== undefined ? 1 : 0) !==
+        1)
+        throw new Error(`Exactly one of "path" and "body" must be specified`);
+    if (options.path !== undefined) {
+        const hash = (0, utils_1.calculateSha1)(options.path);
+        if (!(0, utils_1.isString)(name))
+            throw new Error('"name" should be string.');
+        const sanitizedNamePrefix = (0, utils_1.sanitizeForFilePath)(name) + "-";
+        const dest = path_1.default.join(outputPath, "attachments", sanitizedNamePrefix + hash + path_1.default.extname(options.path));
+        await fs_1.default.promises.mkdir(path_1.default.dirname(dest), { recursive: true });
+        await fs_1.default.promises.copyFile(options.path, dest);
+        const contentType = options.contentType ??
+            (utilsBundle_1.mime.getType(path_1.default.basename(options.path)) || "application/octet-stream");
+        return { name, contentType, path: dest };
+    }
+    else {
+        const contentType = options.contentType ??
+            (typeof options.body === "string"
+                ? "text/plain"
+                : "application/octet-stream");
+        return {
+            name,
+            contentType,
+            body: typeof options.body === "string"
+                ? Buffer.from(options.body)
+                : options.body,
+        };
+    }
+}
+exports.normalizeAndSaveAttachment = normalizeAndSaveAttachment;
+function fileIsModule(file) {
+    if (file.endsWith(".mjs") || file.endsWith(".mts"))
+        return true;
+    if (file.endsWith(".cjs") || file.endsWith(".cts"))
+        return false;
+    const folder = path_1.default.dirname(file);
+    return folderIsModule(folder);
+}
+exports.fileIsModule = fileIsModule;
+function folderIsModule(folder) {
+    const packageJsonPath = getPackageJsonPath(folder);
+    if (!packageJsonPath)
+        return false;
+    // Rely on `require` internal caching logic.
+    return require(packageJsonPath).type === "module";
+}
+// This follows the --moduleResolution=bundler strategy from tsc.
+// https://devblogs.microsoft.com/typescript/announcing-typescript-5-0-beta/#moduleresolution-bundler
+const kExtLookups = new Map([
+    [".js", [".jsx", ".ts", ".tsx"]],
+    [".jsx", [".tsx"]],
+    [".cjs", [".cts"]],
+    [".mjs", [".mts"]],
+    ["", [".js", ".ts", ".jsx", ".tsx", ".cjs", ".mjs", ".cts", ".mts"]],
+]);
+function resolveImportSpecifierExtension(resolved, isPathMapping, isESM) {
+    if (fileExists(resolved))
+        return resolved;
+    for (const [ext, others] of kExtLookups) {
+        if (!resolved.endsWith(ext))
+            continue;
+        for (const other of others) {
+            const modified = resolved.substring(0, resolved.length - ext.length) + other;
+            if (fileExists(modified))
+                return modified;
+        }
+        break; // Do not try '' when a more specific extension like '.jsx' matched.
+    }
+    // After TypeScript path mapping, here's how directories with a `package.json` are resolved:
+    //  - `package.json#exports` is not respected
+    //  - `package.json#main` is respected only in CJS mode
+    //  - `index.js` default is respected only in CJS mode
+    //
+    // More info:
+    //  - https://www.typescriptlang.org/docs/handbook/modules/reference.html#paths-should-not-point-to-monorepo-packages-or-node_modules-packages
+    //  - https://www.typescriptlang.org/docs/handbook/modules/reference.html#directory-modules-index-file-resolution
+    //  - https://nodejs.org/dist/latest-v20.x/docs/api/modules.html#folders-as-modules
+    const shouldNotResolveDirectory = isPathMapping && isESM;
+    if (!shouldNotResolveDirectory && dirExists(resolved)) {
+        // If we import a package, let Node.js figure out the correct import based on package.json.
+        if (fileExists(path_1.default.join(resolved, "package.json")))
+            return resolved;
+        const dirImport = path_1.default.join(resolved, "index");
+        return resolveImportSpecifierExtension(dirImport, isPathMapping, isESM);
+    }
+}
+exports.resolveImportSpecifierExtension = resolveImportSpecifierExtension;
+function fileExists(resolved) {
+    return fs_1.default.statSync(resolved, { throwIfNoEntry: false })?.isFile();
+}
+function dirExists(resolved) {
+    return fs_1.default.statSync(resolved, { throwIfNoEntry: false })?.isDirectory();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@empiricalrun/playwright-utils",
-  "version": "0.6.3",
+  "version": "0.7.1",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
@@ -21,13 +21,6 @@
     "url": "https://github.com/empirical-run/empirical.git"
   },
   "author": "Empirical Team <hey@empirical.run>",
-  "devDependencies": {
-    "@playwright/test": "^1.44.1",
-    "@types/node": "^20.14.9"
-  },
-  "dependencies": {
-    "mailosaur": "^8.6.1"
-  },
   "scripts": {
     "dev": "tsc --build --watch",
     "build": "tsc --build && node ./../../tools/static-env-vars.js dist",
@@ -35,5 +28,21 @@
     "lint": "eslint .",
     "test": "vitest run",
     "test:watch": "vitest"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.44.1",
+    "@types/node": "^20.14.9"
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.614.0",
+    "@aws-sdk/s3-request-presigner": "^3.614.0",
+    "@babel/code-frame": "^7.24.7",
+    "@types/babel__code-frame": "^7.0.6",
+    "@types/md5": "^2.3.5",
+    "@types/mime": "3.0.0",
+    "mailosaur": "^8.6.1",
+    "md5": "^2.3.0",
+    "mime": "3.0.0",
+    "playwright-core": "^1.46.1"
   }
-}
+}