pokeedex 0.1.0

data/node_modules/playwright/lib/common/suiteUtils.js

@@ -0,0 +1,133 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyRepeatEachIndex = applyRepeatEachIndex;
+exports.bindFileSuiteToProject = bindFileSuiteToProject;
+exports.filterByFocusedLine = filterByFocusedLine;
+exports.filterByTestIds = filterByTestIds;
+exports.filterOnly = filterOnly;
+exports.filterSuite = filterSuite;
+exports.filterSuiteWithOnlySemantics = filterSuiteWithOnlySemantics;
+exports.filterTestsRemoveEmptySuites = filterTestsRemoveEmptySuites;
+var _path = _interopRequireDefault(require("path"));
+var _utils = require("playwright-core/lib/utils");
+var _util = require("../util");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+* Copyright Microsoft Corporation. All rights reserved.
+*
+* 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.
+*/
+
+function filterSuite(suite, suiteFilter, testFilter) {
+  for (const child of suite.suites) {
+    if (!suiteFilter(child)) filterSuite(child, suiteFilter, testFilter);
+  }
+  const filteredTests = suite.tests.filter(testFilter);
+  const entries = new Set([...suite.suites, ...filteredTests]);
+  suite._entries = suite._entries.filter(e => entries.has(e)); // Preserve the order.
+}
+function filterTestsRemoveEmptySuites(suite, filter) {
+  const filteredSuites = suite.suites.filter(child => filterTestsRemoveEmptySuites(child, filter));
+  const filteredTests = suite.tests.filter(filter);
+  const entries = new Set([...filteredSuites, ...filteredTests]);
+  suite._entries = suite._entries.filter(e => entries.has(e)); // Preserve the order.
+  return !!suite._entries.length;
+}
+function bindFileSuiteToProject(project, suite) {
+  const relativeFile = _path.default.relative(project.project.testDir, suite.location.file);
+  const fileId = (0, _utils.calculateSha1)((0, _utils.toPosixPath)(relativeFile)).slice(0, 20);
+
+  // Clone suite.
+  const result = suite._deepClone();
+  result._fileId = fileId;
+
+  // Assign test properties with project-specific values.
+  result.forEachTest((test, suite) => {
+    var _inheritedRetries, _inheritedTimeout;
+    suite._fileId = fileId;
+    // At the point of the query, suite is not yet attached to the project, so we only get file, describe and test titles.
+    const [file, ...titles] = test.titlePath();
+    const testIdExpression = `[project=${project.id}]${(0, _utils.toPosixPath)(file)}\x1e${titles.join('\x1e')}`;
+    const testId = fileId + '-' + (0, _utils.calculateSha1)(testIdExpression).slice(0, 20);
+    test.id = testId;
+    test._projectId = project.id;
+
+    // Inherit properties from parent suites.
+    let inheritedRetries;
+    let inheritedTimeout;
+    test.annotations = [];
+    for (let parentSuite = suite; parentSuite; parentSuite = parentSuite.parent) {
+      if (parentSuite._staticAnnotations.length) test.annotations = [...parentSuite._staticAnnotations, ...test.annotations];
+      if (inheritedRetries === undefined && parentSuite._retries !== undefined) inheritedRetries = parentSuite._retries;
+      if (inheritedTimeout === undefined && parentSuite._timeout !== undefined) inheritedTimeout = parentSuite._timeout;
+    }
+    test.retries = (_inheritedRetries = inheritedRetries) !== null && _inheritedRetries !== void 0 ? _inheritedRetries : project.project.retries;
+    test.timeout = (_inheritedTimeout = inheritedTimeout) !== null && _inheritedTimeout !== void 0 ? _inheritedTimeout : project.project.timeout;
+    test.annotations.push(...test._staticAnnotations);
+
+    // Skip annotations imply skipped expectedStatus.
+    if (test.annotations.some(a => a.type === 'skip' || a.type === 'fixme')) test.expectedStatus = 'skipped';
+
+    // We only compute / set digest in the runner.
+    if (test._poolDigest) test._workerHash = `${project.id}-${test._poolDigest}-0`;
+  });
+  return result;
+}
+function applyRepeatEachIndex(project, fileSuite, repeatEachIndex) {
+  // Assign test properties with project-specific values.
+  fileSuite.forEachTest((test, suite) => {
+    if (repeatEachIndex) {
+      const [file, ...titles] = test.titlePath();
+      const testIdExpression = `[project=${project.id}]${(0, _utils.toPosixPath)(file)}\x1e${titles.join('\x1e')} (repeat:${repeatEachIndex})`;
+      const testId = suite._fileId + '-' + (0, _utils.calculateSha1)(testIdExpression).slice(0, 20);
+      test.id = testId;
+      test.repeatEachIndex = repeatEachIndex;
+      if (test._poolDigest) test._workerHash = `${project.id}-${test._poolDigest}-${repeatEachIndex}`;
+    }
+  });
+}
+function filterOnly(suite) {
+  if (!suite._getOnlyItems().length) return;
+  const suiteFilter = suite => suite._only;
+  const testFilter = test => test._only;
+  return filterSuiteWithOnlySemantics(suite, suiteFilter, testFilter);
+}
+function filterSuiteWithOnlySemantics(suite, suiteFilter, testFilter) {
+  const onlySuites = suite.suites.filter(child => filterSuiteWithOnlySemantics(child, suiteFilter, testFilter) || suiteFilter(child));
+  const onlyTests = suite.tests.filter(testFilter);
+  const onlyEntries = new Set([...onlySuites, ...onlyTests]);
+  if (onlyEntries.size) {
+    suite._entries = suite._entries.filter(e => onlyEntries.has(e)); // Preserve the order.
+    return true;
+  }
+  return false;
+}
+function filterByFocusedLine(suite, focusedTestFileLines) {
+  if (!focusedTestFileLines.length) return;
+  const matchers = focusedTestFileLines.map(createFileMatcherFromFilter);
+  const testFileLineMatches = (testFileName, testLine, testColumn) => matchers.some(m => m(testFileName, testLine, testColumn));
+  const suiteFilter = suite => !!suite.location && testFileLineMatches(suite.location.file, suite.location.line, suite.location.column);
+  const testFilter = test => testFileLineMatches(test.location.file, test.location.line, test.location.column);
+  return filterSuite(suite, suiteFilter, testFilter);
+}
+function filterByTestIds(suite, testIdMatcher) {
+  if (!testIdMatcher) return;
+  filterTestsRemoveEmptySuites(suite, test => testIdMatcher(test.id));
+}
+function createFileMatcherFromFilter(filter) {
+  const fileMatcher = (0, _util.createFileMatcher)(filter.re || filter.exact || '');
+  return (testFileName, testLine, testColumn) => fileMatcher(testFileName) && (filter.line === testLine || filter.line === null) && (filter.column === testColumn || filter.column === null);
+}

data/node_modules/playwright/lib/common/test.js

@@ -0,0 +1,311 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TestCase = exports.Suite = void 0;
+var _testType = require("./testType");
+var _teleReceiver = require("../isomorphic/teleReceiver");
+/**
+ * Copyright Microsoft Corporation. All rights reserved.
+ *
+ * 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.
+ */
+
+class Base {
+  constructor(title) {
+    this.title = void 0;
+    this._only = false;
+    this._requireFile = '';
+    this.title = title;
+  }
+}
+class Suite extends Base {
+  constructor(title, type, testTypeImpl) {
+    super(title);
+    this.location = void 0;
+    this.parent = void 0;
+    this._use = [];
+    this._entries = [];
+    this._hooks = [];
+    this._timeout = void 0;
+    this._retries = void 0;
+    // Annotations known statically before running the test, e.g. `test.describe.skip()` or `test.describe({ annotation }, body)`.
+    this._staticAnnotations = [];
+    // Explicitly declared tags that are not a part of the title.
+    this._tags = [];
+    this._modifiers = [];
+    this._parallelMode = 'none';
+    this._fullProject = void 0;
+    this._fileId = void 0;
+    this._type = void 0;
+    this._testTypeImpl = void 0;
+    this._type = type;
+    this._testTypeImpl = testTypeImpl;
+  }
+  get type() {
+    return this._type;
+  }
+  entries() {
+    return this._entries;
+  }
+  get suites() {
+    return this._entries.filter(entry => entry instanceof Suite);
+  }
+  get tests() {
+    return this._entries.filter(entry => entry instanceof TestCase);
+  }
+  _addTest(test) {
+    test.parent = this;
+    this._entries.push(test);
+  }
+  _addSuite(suite) {
+    suite.parent = this;
+    this._entries.push(suite);
+  }
+  _prependSuite(suite) {
+    suite.parent = this;
+    this._entries.unshift(suite);
+  }
+  allTests() {
+    const result = [];
+    const visit = suite => {
+      for (const entry of suite._entries) {
+        if (entry instanceof Suite) visit(entry);else result.push(entry);
+      }
+    };
+    visit(this);
+    return result;
+  }
+  _hasTests() {
+    let result = false;
+    const visit = suite => {
+      for (const entry of suite._entries) {
+        if (result) return;
+        if (entry instanceof Suite) visit(entry);else result = true;
+      }
+    };
+    visit(this);
+    return result;
+  }
+  titlePath() {
+    const titlePath = this.parent ? this.parent.titlePath() : [];
+    // Ignore anonymous describe blocks.
+    if (this.title || this._type !== 'describe') titlePath.push(this.title);
+    return titlePath;
+  }
+  _collectGrepTitlePath(path) {
+    if (this.parent) this.parent._collectGrepTitlePath(path);
+    if (this.title || this._type !== 'describe') path.push(this.title);
+    path.push(...this._tags);
+  }
+  _getOnlyItems() {
+    const items = [];
+    if (this._only) items.push(this);
+    for (const suite of this.suites) items.push(...suite._getOnlyItems());
+    items.push(...this.tests.filter(test => test._only));
+    return items;
+  }
+  _deepClone() {
+    const suite = this._clone();
+    for (const entry of this._entries) {
+      if (entry instanceof Suite) suite._addSuite(entry._deepClone());else suite._addTest(entry._clone());
+    }
+    return suite;
+  }
+  _deepSerialize() {
+    const suite = this._serialize();
+    suite.entries = [];
+    for (const entry of this._entries) {
+      if (entry instanceof Suite) suite.entries.push(entry._deepSerialize());else suite.entries.push(entry._serialize());
+    }
+    return suite;
+  }
+  static _deepParse(data) {
+    const suite = Suite._parse(data);
+    for (const entry of data.entries) {
+      if (entry.kind === 'suite') suite._addSuite(Suite._deepParse(entry));else suite._addTest(TestCase._parse(entry));
+    }
+    return suite;
+  }
+  forEachTest(visitor) {
+    for (const entry of this._entries) {
+      if (entry instanceof Suite) entry.forEachTest(visitor);else visitor(entry, this);
+    }
+  }
+  _serialize() {
+    return {
+      kind: 'suite',
+      title: this.title,
+      type: this._type,
+      location: this.location,
+      only: this._only,
+      requireFile: this._requireFile,
+      timeout: this._timeout,
+      retries: this._retries,
+      staticAnnotations: this._staticAnnotations.slice(),
+      tags: this._tags.slice(),
+      modifiers: this._modifiers.slice(),
+      parallelMode: this._parallelMode,
+      hooks: this._hooks.map(h => ({
+        type: h.type,
+        location: h.location,
+        title: h.title
+      })),
+      fileId: this._fileId
+    };
+  }
+  static _parse(data) {
+    const suite = new Suite(data.title, data.type);
+    suite.location = data.location;
+    suite._only = data.only;
+    suite._requireFile = data.requireFile;
+    suite._timeout = data.timeout;
+    suite._retries = data.retries;
+    suite._staticAnnotations = data.staticAnnotations;
+    suite._tags = data.tags;
+    suite._modifiers = data.modifiers;
+    suite._parallelMode = data.parallelMode;
+    suite._hooks = data.hooks.map(h => ({
+      type: h.type,
+      location: h.location,
+      title: h.title,
+      fn: () => {}
+    }));
+    suite._fileId = data.fileId;
+    return suite;
+  }
+  _clone() {
+    const data = this._serialize();
+    const suite = Suite._parse(data);
+    suite._use = this._use.slice();
+    suite._hooks = this._hooks.slice();
+    suite._fullProject = this._fullProject;
+    return suite;
+  }
+  project() {
+    var _this$_fullProject, _this$parent;
+    return ((_this$_fullProject = this._fullProject) === null || _this$_fullProject === void 0 ? void 0 : _this$_fullProject.project) || ((_this$parent = this.parent) === null || _this$parent === void 0 ? void 0 : _this$parent.project());
+  }
+}
+exports.Suite = Suite;
+class TestCase extends Base {
+  constructor(title, fn, testType, location) {
+    super(title);
+    this.fn = void 0;
+    this.results = [];
+    this.location = void 0;
+    this.parent = void 0;
+    this.type = 'test';
+    this.expectedStatus = 'passed';
+    this.timeout = 0;
+    this.annotations = [];
+    this.retries = 0;
+    this.repeatEachIndex = 0;
+    this._testType = void 0;
+    this.id = '';
+    this._pool = void 0;
+    this._poolDigest = '';
+    this._workerHash = '';
+    this._projectId = '';
+    // Annotations known statically before running the test, e.g. `test.skip()` or `test(title, { annotation }, body)`.
+    this._staticAnnotations = [];
+    // Explicitly declared tags that are not a part of the title.
+    this._tags = [];
+    this.fn = fn;
+    this._testType = testType;
+    this.location = location;
+  }
+  titlePath() {
+    const titlePath = this.parent ? this.parent.titlePath() : [];
+    titlePath.push(this.title);
+    return titlePath;
+  }
+  outcome() {
+    return (0, _teleReceiver.computeTestCaseOutcome)(this);
+  }
+  ok() {
+    const status = this.outcome();
+    return status === 'expected' || status === 'flaky' || status === 'skipped';
+  }
+  get tags() {
+    return this._grepTitle().match(/@[\S]+/g) || [];
+  }
+  _serialize() {
+    return {
+      kind: 'test',
+      id: this.id,
+      title: this.title,
+      retries: this.retries,
+      timeout: this.timeout,
+      expectedStatus: this.expectedStatus,
+      location: this.location,
+      only: this._only,
+      requireFile: this._requireFile,
+      poolDigest: this._poolDigest,
+      workerHash: this._workerHash,
+      staticAnnotations: this._staticAnnotations.slice(),
+      annotations: this.annotations.slice(),
+      tags: this._tags.slice(),
+      projectId: this._projectId
+    };
+  }
+  static _parse(data) {
+    const test = new TestCase(data.title, () => {}, _testType.rootTestType, data.location);
+    test.id = data.id;
+    test.retries = data.retries;
+    test.timeout = data.timeout;
+    test.expectedStatus = data.expectedStatus;
+    test._only = data.only;
+    test._requireFile = data.requireFile;
+    test._poolDigest = data.poolDigest;
+    test._workerHash = data.workerHash;
+    test._staticAnnotations = data.staticAnnotations;
+    test.annotations = data.annotations;
+    test._tags = data.tags;
+    test._projectId = data.projectId;
+    return test;
+  }
+  _clone() {
+    const data = this._serialize();
+    const test = TestCase._parse(data);
+    test._testType = this._testType;
+    test.fn = this.fn;
+    return test;
+  }
+  _appendTestResult() {
+    const result = {
+      retry: this.results.length,
+      parallelIndex: -1,
+      workerIndex: -1,
+      duration: 0,
+      startTime: new Date(),
+      stdout: [],
+      stderr: [],
+      attachments: [],
+      status: 'skipped',
+      steps: [],
+      errors: []
+    };
+    this.results.push(result);
+    return result;
+  }
+  _grepTitle() {
+    const path = [];
+    this.parent._collectGrepTitlePath(path);
+    path.push(this.title);
+    path.push(...this._tags);
+    return path.join(' ');
+  }
+}
+exports.TestCase = TestCase;

data/node_modules/playwright/lib/common/testLoader.js

@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultTimeout = void 0;
+exports.loadTestFile = loadTestFile;
+var _path = _interopRequireDefault(require("path"));
+var _util = _interopRequireDefault(require("util"));
+var _globals = require("./globals");
+var _test = require("./test");
+var _transform = require("../transform/transform");
+var _util2 = require("../util");
+var _compilationCache = require("../transform/compilationCache");
+var esmLoaderHost = _interopRequireWildcard(require("./esmLoaderHost"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Copyright Microsoft Corporation. All rights reserved.
+ *
+ * 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.
+ */
+
+const defaultTimeout = exports.defaultTimeout = 30000;
+
+// To allow multiple loaders in the same process without clearing require cache,
+// we make these maps global.
+const cachedFileSuites = new Map();
+async function loadTestFile(file, rootDir, testErrors) {
+  if (cachedFileSuites.has(file)) return cachedFileSuites.get(file);
+  const suite = new _test.Suite(_path.default.relative(rootDir, file) || _path.default.basename(file), 'file');
+  suite._requireFile = file;
+  suite.location = {
+    file,
+    line: 0,
+    column: 0
+  };
+  (0, _globals.setCurrentlyLoadingFileSuite)(suite);
+  if (!(0, _globals.isWorkerProcess)()) {
+    (0, _compilationCache.startCollectingFileDeps)();
+    await esmLoaderHost.startCollectingFileDeps();
+  }
+  try {
+    await (0, _transform.requireOrImport)(file);
+    cachedFileSuites.set(file, suite);
+  } catch (e) {
+    if (!testErrors) throw e;
+    testErrors.push(serializeLoadError(file, e));
+  } finally {
+    (0, _globals.setCurrentlyLoadingFileSuite)(undefined);
+    if (!(0, _globals.isWorkerProcess)()) {
+      (0, _compilationCache.stopCollectingFileDeps)(file);
+      await esmLoaderHost.stopCollectingFileDeps(file);
+    }
+  }
+  {
+    // Test locations that we discover potentially have different file name.
+    // This could be due to either
+    //   a) use of source maps or due to
+    //   b) require of one file from another.
+    // Try fixing (a) w/o regressing (b).
+
+    const files = new Set();
+    suite.allTests().map(t => files.add(t.location.file));
+    if (files.size === 1) {
+      // All tests point to one file.
+      const mappedFile = files.values().next().value;
+      if (suite.location.file !== mappedFile) {
+        // The file is different, check for a likely source map case.
+        if (_path.default.extname(mappedFile) !== _path.default.extname(suite.location.file)) suite.location.file = mappedFile;
+      }
+    }
+  }
+  return suite;
+}
+function serializeLoadError(file, error) {
+  if (error instanceof Error) {
+    const result = (0, _util2.filterStackTrace)(error);
+    // Babel parse errors have location.
+    const loc = error.loc;
+    result.location = loc ? {
+      file,
+      line: loc.line || 0,
+      column: loc.column || 0
+    } : undefined;
+    return result;
+  }
+  return {
+    value: _util.default.inspect(error)
+  };
+}