@brillout/test-e2e 0.1.3

package/dist/utils/assert.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectErrorPrefix = exports.getProjectError = exports.assertInfo = exports.assertWarning = exports.assertUsage = exports.assert = void 0;
+const createErrorWithCleanStackTrace_1 = require("./createErrorWithCleanStackTrace");
+const projectInfo_1 = require("./projectInfo");
+const errorPrefix = `[${projectInfo_1.projectInfo.npmPackageName}]`;
+exports.projectErrorPrefix = errorPrefix;
+const internalErrorPrefix = `${errorPrefix}[Bug]`;
+const usageErrorPrefix = `${errorPrefix}[Wrong Usage]`;
+const warningPrefix = `${errorPrefix}[Warning]`;
+const infoPrefix = `${errorPrefix}[Info]`;
+const numberOfStackTraceLinesToRemove = 2;
+function assert(condition, debugInfo) {
+    if (condition) {
+        return;
+    }
+    const debugStr = (() => {
+        if (!debugInfo) {
+            return '';
+        }
+        const debugInfoSerialized = typeof debugInfo === 'string' ? debugInfo : '`' + JSON.stringify(debugInfo) + '`';
+        return `Debug info (this is for the ${projectInfo_1.projectInfo.projectName} maintainers; you can ignore this): ${debugInfoSerialized}.`;
+    })();
+    const internalError = (0, createErrorWithCleanStackTrace_1.createErrorWithCleanStackTrace)([
+        `${internalErrorPrefix} You stumbled upon a bug in ${projectInfo_1.projectInfo.projectName}'s source code.`,
+        `Reach out at ${projectInfo_1.projectInfo.githubRepository}/issues/new and include this error stack (the error stack is usually enough to fix the problem).`,
+        'A maintainer will fix the bug (usually under 24 hours).',
+        `Do not hesitate to reach out as it makes ${projectInfo_1.projectInfo.projectName} more robust.`,
+        debugStr
+    ].join(' '), numberOfStackTraceLinesToRemove);
+    throw internalError;
+}
+exports.assert = assert;
+function assertUsage(condition, errorMessage) {
+    if (condition) {
+        return;
+    }
+    const whiteSpace = errorMessage.startsWith('[') ? '' : ' ';
+    const usageError = (0, createErrorWithCleanStackTrace_1.createErrorWithCleanStackTrace)(`${usageErrorPrefix}${whiteSpace}${errorMessage}`, numberOfStackTraceLinesToRemove);
+    throw usageError;
+}
+exports.assertUsage = assertUsage;
+function getProjectError(errorMessage) {
+    const pluginError = (0, createErrorWithCleanStackTrace_1.createErrorWithCleanStackTrace)(`${errorPrefix} ${errorMessage}`, numberOfStackTraceLinesToRemove);
+    return pluginError;
+}
+exports.getProjectError = getProjectError;
+let loggedWarnings = new Set();
+function assertWarning(condition, errorMessage, { onlyOnce }) {
+    if (condition) {
+        return;
+    }
+    const msg = `${warningPrefix} ${errorMessage}`;
+    if (onlyOnce) {
+        const key = onlyOnce === true ? msg : onlyOnce;
+        if (loggedWarnings.has(key)) {
+            return;
+        }
+        else {
+            loggedWarnings.add(key);
+        }
+    }
+    console.warn(msg);
+}
+exports.assertWarning = assertWarning;
+function assertInfo(condition, errorMessage) {
+    if (condition) {
+        return;
+    }
+    console.warn(`${infoPrefix} ${errorMessage}`);
+}
+exports.assertInfo = assertInfo;

package/dist/utils/createErrorWithCleanStackTrace.d.ts

@@ -0,0 +1,2 @@
+export { createErrorWithCleanStackTrace };
+declare function createErrorWithCleanStackTrace(errorMessage: string, numberOfStackTraceLinesToRemove: number): Error;

package/dist/utils/createErrorWithCleanStackTrace.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createErrorWithCleanStackTrace = void 0;
+function createErrorWithCleanStackTrace(errorMessage, numberOfStackTraceLinesToRemove) {
+    let err;
+    {
+        var stackTraceLimit__original = Error.stackTraceLimit;
+        Error.stackTraceLimit = Infinity;
+        err = new Error(errorMessage);
+        Error.stackTraceLimit = stackTraceLimit__original;
+    }
+    err.stack = clean(err.stack, numberOfStackTraceLinesToRemove);
+    return err;
+}
+exports.createErrorWithCleanStackTrace = createErrorWithCleanStackTrace;
+function clean(errStack, numberOfStackTraceLinesToRemove) {
+    if (!errStack) {
+        return errStack;
+    }
+    const stackLines = splitByLine(errStack);
+    let linesRemoved = 0;
+    const stackLine__cleaned = stackLines
+        .filter((line) => {
+        // Remove internal stack traces
+        if (line.includes(' (internal/') || line.includes(' (node:internal')) {
+            return false;
+        }
+        if (linesRemoved < numberOfStackTraceLinesToRemove && isStackTraceLine(line)) {
+            linesRemoved++;
+            return false;
+        }
+        return true;
+    })
+        .join('\n');
+    return stackLine__cleaned;
+}
+function isStackTraceLine(line) {
+    return line.startsWith('    at ');
+}
+function splitByLine(str) {
+    // https://stackoverflow.com/questions/21895233/how-in-node-to-split-string-by-newline-n
+    return str.split(/\r?\n/);
+}

package/dist/utils/findFiles.d.ts

@@ -0,0 +1,7 @@
+export { findFiles };
+export type { FindFilter };
+declare type FindFilter = {
+    terms: string[];
+    exclude: boolean;
+};
+declare function findFiles(pattern: string, findFilter: null | FindFilter): Promise<string[]>;

package/dist/utils/findFiles.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findFiles = void 0;
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const path_1 = __importDefault(require("path"));
+const runCommand_1 = require("./runCommand");
+const cwd = process.cwd();
+let gitFiles;
+async function findFiles(pattern, findFilter) {
+    let files = (await (0, fast_glob_1.default)([pattern], { ignore: ['**/node_modules/**', '**/.git/**'], cwd, dot: true }))
+        .filter((filePathRelative) => applyFilter(filePathRelative, findFilter))
+        .map((filePathRelative) => path_1.default.join(cwd, filePathRelative));
+    files = await filterGitIgnoredFiles(files);
+    return files;
+}
+exports.findFiles = findFiles;
+async function filterGitIgnoredFiles(files) {
+    if (!gitFiles) {
+        const stdout1 = await (0, runCommand_1.runCommand)('git ls-files', { cwd });
+        // Also include untracked files.
+        //  - In other words, we remove git ignored files. (Staged files are tracked and listed by `$ git ls-files`.)
+        //  - `git ls-files --others --exclude-standard` from https://stackoverflow.com/questions/3801321/git-list-only-untracked-files-also-custom-commands/3801554#3801554
+        const stdout2 = await (0, runCommand_1.runCommand)('git ls-files --others --exclude-standard', { cwd });
+        gitFiles = [...stdout1.split(' '), ...stdout2.split(' ')].map((filePathRelative) => path_1.default.join(cwd, filePathRelative));
+    }
+    const filesFiltered = files.filter((file) => gitFiles.includes(file));
+    return filesFiltered;
+}
+function applyFilter(filePathRelative, findFilter) {
+    if (!findFilter) {
+        return true;
+    }
+    const { terms, exclude } = findFilter;
+    for (const term of terms) {
+        if (!filePathRelative.includes(term) && !exclude) {
+            return false;
+        }
+        if (filePathRelative.includes(term) && exclude) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/utils/humanizeTime.d.ts

@@ -0,0 +1 @@
+export declare function humanizeTime(milliseconds: number): string;

package/dist/utils/humanizeTime.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.humanizeTime = void 0;
+function humanizeTime(milliseconds) {
+    const seconds = milliseconds / 1000;
+    if (seconds < 120) {
+        return `${round(seconds)} seconds`;
+    }
+    const minutes = seconds / 60;
+    return `${round(minutes)} minutes`;
+}
+exports.humanizeTime = humanizeTime;
+function round(n) {
+    return n.toFixed(1);
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from './sleep';
+export * from './runCommand';
+export * from './assert';
+export * from './humanizeTime';
+export * from './isTTY';
+export * from './findFiles';

package/dist/utils/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./sleep"), exports);
+__exportStar(require("./runCommand"), exports);
+__exportStar(require("./assert"), exports);
+__exportStar(require("./humanizeTime"), exports);
+__exportStar(require("./isTTY"), exports);
+__exportStar(require("./findFiles"), exports);

package/dist/utils/isTTY.d.ts

@@ -0,0 +1 @@
+export declare const isTTY: boolean;

package/dist/utils/isTTY.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTTY = void 0;
+// https://stackoverflow.com/questions/34570452/node-js-stdout-clearline-and-cursorto-functions#comment80319576_34570694
+exports.isTTY = !!process.stdout.clearLine;

package/dist/utils/projectInfo.d.ts

@@ -0,0 +1,5 @@
+export declare const projectInfo: {
+    projectName: "@brillout/test-e2e";
+    npmPackageName: "@brillout/test-e2e";
+    githubRepository: "https://github.com/brillout/test-e2e";
+};

package/dist/utils/projectInfo.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectInfo = void 0;
+exports.projectInfo = {
+    projectName: '@brillout/test-e2e',
+    npmPackageName: '@brillout/test-e2e',
+    githubRepository: 'https://github.com/brillout/test-e2e'
+};

package/dist/utils/runCommand.d.ts

@@ -0,0 +1,6 @@
+export { runCommand };
+declare function runCommand(cmd: string, { swallowError, timeout, cwd }?: {
+    swallowError?: true;
+    timeout?: number;
+    cwd?: string;
+}): Promise<string>;

package/dist/utils/runCommand.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommand = void 0;
+const child_process_1 = require("child_process");
+function runCommand(cmd, { swallowError, timeout = 5000, cwd } = {}) {
+    const { promise, resolvePromise } = genPromise();
+    const t = setTimeout(() => {
+        console.error(`Command call \`${cmd}\` timeout [${timeout / 1000} seconds][${cwd}].`);
+        process.exit(1);
+    }, timeout);
+    const options = { cwd };
+    (0, child_process_1.exec)(cmd, options, (err, stdout, stderr) => {
+        clearTimeout(t);
+        if (err || stderr) {
+            if (swallowError) {
+                resolvePromise('SWALLOWED_ERROR');
+            }
+            else {
+                if (stdout) {
+                    console.log(stdout);
+                }
+                if (stderr) {
+                    console.error(stderr);
+                }
+                if (err) {
+                    console.error(err);
+                }
+                throw new Error(`Command \`${cmd}\` failed [cwd: ${cwd}]`);
+            }
+        }
+        else {
+            resolvePromise(stdout);
+        }
+    });
+    return promise;
+}
+exports.runCommand = runCommand;
+function genPromise() {
+    let resolvePromise;
+    let rejectPromise;
+    const promise = new Promise((resolve, reject) => {
+        resolvePromise = resolve;
+        rejectPromise = reject;
+    });
+    return { promise, resolvePromise, rejectPromise };
+}

package/dist/utils/sleep.d.ts

@@ -0,0 +1,2 @@
+export { sleep };
+declare function sleep(milliseconds: number): Promise<void>;

package/dist/utils/sleep.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = void 0;
+function sleep(milliseconds) {
+    return new Promise((r) => setTimeout(r, milliseconds));
+}
+exports.sleep = sleep;

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@brillout/test-e2e",
+  "version": "0.1.3",
+  "bin": "./bin.js",
+  "main": "./dist/index.js",
+  "scripts": {
+    "// === Dev ===": "",
+    "dev": "tsc --watch --project ./tsconfig.dev.json",
+    "// === Build ===": "",
+    "build": "rm -rf dist/ && tsc",
+    "// === Release ===": "",
+    "prepublishOnly": "pnpm run build",
+    "release": "npm version patch && npm publish && git push && git push --tags"
+  },
+  "dependencies": {
+    "@brillout/part-regex": "^0.1.2",
+    "@types/chai": "^4.3.3",
+    "@types/node": "^15.6.1",
+    "@types/node-fetch": "^2.5.12",
+    "chai": "^4.3.6",
+    "esbuild": "^0.15.9",
+    "fast-glob": "^3.2.12",
+    "kolorist": "^1.4.1",
+    "node-fetch": "^2.6.1",
+    "playwright-chromium": "^1.22.2",
+    "source-map-support": "^0.5.21",
+    "strip-ansi": "^6.0.1",
+    "typescript": "^4.8.3"
+  },
+  "repository": "github:brillout/test-e2e",
+  "files": [
+    "dist/"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}