appmap 0.62.1 → 0.65.1

data/node_modules/jsdom/lib/jsdom/living/webstorage/Storage-impl.js

@@ -0,0 +1,102 @@
+"use strict";
+
+const DOMException = require("domexception/webidl2js-wrapper");
+const StorageEvent = require("../generated/StorageEvent");
+const idlUtils = require("../generated/utils");
+const { fireAnEvent } = require("../helpers/events");
+
+// https://html.spec.whatwg.org/multipage/webstorage.html#the-storage-interface
+class StorageImpl {
+  constructor(globalObject, args, privateData) {
+    const { associatedWindow, storageArea, url, type, storageQuota } = privateData;
+
+    this._associatedWindow = associatedWindow;
+    this._items = storageArea;
+    this._url = url;
+    this._type = type;
+    this._quota = storageQuota;
+
+    this._globalObject = globalObject;
+  }
+
+  _dispatchStorageEvent(key, oldValue, newValue) {
+    return this._associatedWindow._currentOriginData.windowsInSameOrigin
+      .filter(target => target !== this._associatedWindow)
+      .forEach(target => fireAnEvent("storage", target, StorageEvent, {
+        key,
+        oldValue,
+        newValue,
+        url: this._url,
+        storageArea: target["_" + this._type]
+      }));
+  }
+
+  get length() {
+    return this._items.size;
+  }
+
+  key(n) {
+    if (n >= this._items.size) {
+      return null;
+    }
+    return [...this._items.keys()][n];
+  }
+
+  getItem(key) {
+    if (this._items.has(key)) {
+      return this._items.get(key);
+    }
+    return null;
+  }
+
+  setItem(key, value) {
+    const oldValue = this._items.get(key) || null;
+
+    if (oldValue === value) {
+      return;
+    }
+
+    // Concatenate all keys and values to measure their length against the quota
+    let itemsTotalLength = key.length + value.length;
+    for (const [curKey, curValue] of this._items) {
+      // If the key already exists, skip it as it will be set to the new value instead
+      if (key !== curKey) {
+        itemsTotalLength += curKey.length + curValue.length;
+      }
+    }
+    if (itemsTotalLength > this._quota) {
+      throw DOMException.create(this._globalObject, [
+        `The ${this._quota}-code unit storage quota has been exceeded.`,
+        "QuotaExceededError"
+      ]);
+    }
+
+    setTimeout(this._dispatchStorageEvent.bind(this), 0, key, oldValue, value);
+
+    this._items.set(key, value);
+  }
+
+  removeItem(key) {
+    if (this._items.has(key)) {
+      setTimeout(this._dispatchStorageEvent.bind(this), 0, key, this._items.get(key), null);
+
+      this._items.delete(key);
+    }
+  }
+
+  clear() {
+    if (this._items.size > 0) {
+      setTimeout(this._dispatchStorageEvent.bind(this), 0, null, null, null);
+
+      this._items.clear();
+    }
+  }
+
+  get [idlUtils.supportedPropertyNames]() {
+    return this._items.keys();
+  }
+}
+
+module.exports = {
+  implementation: StorageImpl
+};

data/node_modules/jsdom/lib/jsdom/living/window/BarProp-impl.js

@@ -0,0 +1,10 @@
+"use strict";
+
+// https://html.spec.whatwg.org/multipage/window-object.html#browser-interface-elements
+class BarPropImpl {}
+
+// Since many BarProps do not apply to modern browsers,
+// returning true in all cases seems to be common practice.
+BarPropImpl.prototype.visible = true;
+
+exports.implementation = BarPropImpl;

data/node_modules/jsdom/lib/jsdom/living/window/External-impl.js

@@ -0,0 +1,9 @@
+"use strict";
+
+// https://html.spec.whatwg.org/multipage/obsolete.html#dom-external
+exports.implementation = class ExternalImpl {
+  // The AddSearchProvider() and IsSearchProviderInstalled() methods must do nothing
+  AddSearchProvider() {}
+
+  IsSearchProviderInstalled() {}
+};

data/node_modules/jsdom/lib/jsdom/living/window/History-impl.js

@@ -0,0 +1,134 @@
+"use strict";
+const DOMException = require("domexception/webidl2js-wrapper");
+const { documentBaseURLSerialized, parseURLToResultingURLRecord } = require("../helpers/document-base-url.js");
+
+// https://html.spec.whatwg.org/#history-3
+exports.implementation = class HistoryImpl {
+  constructor(globalObject, args, privateData) {
+    this._window = privateData.window;
+    this._document = privateData.document;
+    this._actAsIfLocationReloadCalled = privateData.actAsIfLocationReloadCalled;
+    this._state = null;
+
+    this._globalObject = globalObject;
+  }
+
+  _guardAgainstInactiveDocuments() {
+    if (!this._window) {
+      throw DOMException.create(this._globalObject, [
+        "History object is associated with a document that is not fully active.",
+        "SecurityError"
+      ]);
+    }
+  }
+
+  get length() {
+    this._guardAgainstInactiveDocuments();
+
+    return this._window._sessionHistory.length;
+  }
+
+  get state() {
+    this._guardAgainstInactiveDocuments();
+
+    return this._state;
+  }
+
+  go(delta) {
+    this._guardAgainstInactiveDocuments();
+
+    if (delta === 0) {
+      // When the go(delta) method is invoked, if delta is zero, the user agent must act as
+      // if the location.reload() method was called instead.
+      this._actAsIfLocationReloadCalled();
+    } else {
+      // Otherwise, the user agent must traverse the history by a delta whose value is delta
+      this._window._sessionHistory.traverseByDelta(delta);
+    }
+  }
+
+  back() {
+    this.go(-1);
+  }
+
+  forward() {
+    this.go(+1);
+  }
+
+  pushState(data, title, url) {
+    this._sharedPushAndReplaceState(data, title, url, "pushState");
+  }
+  replaceState(data, title, url) {
+    this._sharedPushAndReplaceState(data, title, url, "replaceState");
+  }
+
+  // https://html.spec.whatwg.org/#dom-history-pushstate
+  _sharedPushAndReplaceState(data, title, url, methodName) {
+    this._guardAgainstInactiveDocuments();
+
+    // TODO structured clone data
+
+    let newURL;
+    if (url !== null) {
+      // Not implemented: use of entry settings object's API base URL. Instead we just use the document base URL. The
+      // difference matters in the case of cross-frame calls.
+      newURL = parseURLToResultingURLRecord(url, this._document);
+
+      if (newURL === null) {
+        throw DOMException.create(this._globalObject, [
+          `Could not parse url argument "${url}" to ${methodName} against base URL ` +
+          `"${documentBaseURLSerialized(this._document)}".`,
+          "SecurityError"
+        ]);
+      }
+
+      if (newURL.scheme !== this._document._URL.scheme ||
+          newURL.username !== this._document._URL.username ||
+          newURL.password !== this._document._URL.password ||
+          newURL.host !== this._document._URL.host ||
+          newURL.port !== this._document._URL.port ||
+          newURL.cannotBeABaseURL !== this._document._URL.cannotBeABaseURL) {
+        throw DOMException.create(this._globalObject, [
+          `${methodName} cannot update history to a URL which differs in components other than in ` +
+          `path, query, or fragment.`,
+          "SecurityError"
+        ]);
+      }
+
+      // Not implemented: origin check (seems to only apply to documents with weird origins, e.g. sandboxed ones)
+    } else {
+      newURL = this._window._sessionHistory.currentEntry.url;
+    }
+
+    if (methodName === "pushState") {
+      this._window._sessionHistory.removeAllEntriesAfterCurrentEntry();
+
+      this._window._sessionHistory.clearHistoryTraversalTasks();
+
+      const newEntry = {
+        document: this._document,
+        stateObject: data,
+        title,
+        url: newURL
+      };
+      this._window._sessionHistory.addEntryAfterCurrentEntry(newEntry);
+      this._window._sessionHistory.updateCurrentEntry(newEntry);
+    } else {
+      const { currentEntry } = this._window._sessionHistory;
+      currentEntry.stateObject = data;
+      currentEntry.title = title;
+      currentEntry.url = newURL;
+    }
+
+    // TODO: If the current entry in the session history represents a non-GET request
+    // (e.g. it was the result of a POST submission) then update it to instead represent
+    // a GET request.
+
+    this._document._URL = newURL;
+
+    // arguably it's a bit odd that the state and latestEntry do not belong to the SessionHistory
+    // but the spec gives them to "History" and "Document" respecively.
+    this._state = data; // TODO clone again!! O_o
+    this._document._latestEntry = this._window._sessionHistory.currentEntry;
+  }
+};

data/node_modules/jsdom/lib/jsdom/living/window/Location-impl.js

@@ -0,0 +1,238 @@
+"use strict";
+const whatwgURL = require("whatwg-url");
+const DOMException = require("domexception/webidl2js-wrapper");
+const { documentBaseURL, parseURLToResultingURLRecord } = require("../helpers/document-base-url");
+const { navigate } = require("./navigation");
+
+// Not implemented: use of entry settings object's API base URL in href setter, assign, and replace. Instead we just
+// use the document base URL. The difference matters in the case of cross-frame calls.
+
+exports.implementation = class LocationImpl {
+  constructor(globalObject, args, privateData) {
+    this._relevantDocument = privateData.relevantDocument;
+    this.url = null;
+
+    this._globalObject = globalObject;
+  }
+
+  get _url() {
+    return this._relevantDocument._URL;
+  }
+
+  _locationObjectSetterNavigate(url) {
+    // Not implemented: extra steps here to determine replacement flag.
+
+    return this._locationObjectNavigate(url);
+  }
+
+  _locationObjectNavigate(url, { replacement = false } = {}) {
+    // Not implemented: the setup for calling navigate, which doesn't apply to our stub navigate anyway.
+
+    navigate(this._relevantDocument._defaultView, url, { replacement, exceptionsEnabled: true });
+  }
+
+  toString() {
+    return this.href;
+  }
+
+  get href() {
+    return whatwgURL.serializeURL(this._url);
+  }
+  set href(v) {
+    const newURL = whatwgURL.parseURL(v, { baseURL: documentBaseURL(this._relevantDocument) });
+    if (newURL === null) {
+      throw new TypeError(`Could not parse "${v}" as a URL`);
+    }
+
+    this._locationObjectSetterNavigate(newURL);
+  }
+
+  get origin() {
+    return whatwgURL.serializeURLOrigin(this._url);
+  }
+
+  get protocol() {
+    return this._url.scheme + ":";
+  }
+  set protocol(v) {
+    const copyURL = { ...this._url };
+
+    const possibleFailure = whatwgURL.basicURLParse(v + ":", { url: copyURL, stateOverride: "scheme start" });
+    if (possibleFailure === null) {
+      throw new TypeError(`Could not parse the URL after setting the procol to "${v}"`);
+    }
+
+    if (copyURL.scheme !== "http" && copyURL.scheme !== "https") {
+      return;
+    }
+
+    this._locationObjectSetterNavigate(copyURL);
+  }
+
+  get host() {
+    const url = this._url;
+
+    if (url.host === null) {
+      return "";
+    }
+    if (url.port === null) {
+      return whatwgURL.serializeHost(url.host);
+    }
+
+    return whatwgURL.serializeHost(url.host) + ":" + whatwgURL.serializeInteger(url.port);
+  }
+  set host(v) {
+    const copyURL = { ...this._url };
+
+    if (copyURL.cannotBeABaseURL) {
+      return;
+    }
+
+    whatwgURL.basicURLParse(v, { url: copyURL, stateOverride: "host" });
+
+    this._locationObjectSetterNavigate(copyURL);
+  }
+
+  get hostname() {
+    if (this._url.host === null) {
+      return "";
+    }
+
+    return whatwgURL.serializeHost(this._url.host);
+  }
+  set hostname(v) {
+    const copyURL = { ...this._url };
+
+    if (copyURL.cannotBeABaseURL) {
+      return;
+    }
+
+    whatwgURL.basicURLParse(v, { url: copyURL, stateOverride: "hostname" });
+
+    this._locationObjectSetterNavigate(copyURL);
+  }
+
+  get port() {
+    if (this._url.port === null) {
+      return "";
+    }
+
+    return whatwgURL.serializeInteger(this._url.port);
+  }
+  set port(v) {
+    const copyURL = { ...this._url };
+
+    if (copyURL.host === null || copyURL.cannotBeABaseURL || copyURL.scheme === "file") {
+      return;
+    }
+
+    whatwgURL.basicURLParse(v, { url: copyURL, stateOverride: "port" });
+
+    this._locationObjectSetterNavigate(copyURL);
+  }
+
+  get pathname() {
+    const url = this._url;
+
+    if (url.cannotBeABaseURL) {
+      return url.path[0];
+    }
+
+    return "/" + url.path.join("/");
+  }
+  set pathname(v) {
+    const copyURL = { ...this._url };
+
+    if (copyURL.cannotBeABaseURL) {
+      return;
+    }
+
+    copyURL.path = [];
+    whatwgURL.basicURLParse(v, { url: copyURL, stateOverride: "path start" });
+
+    this._locationObjectSetterNavigate(copyURL);
+  }
+
+  get search() {
+    if (this._url.query === null || this._url.query === "") {
+      return "";
+    }
+
+    return "?" + this._url.query;
+  }
+  set search(v) {
+    const copyURL = { ...this._url };
+
+    if (v === "") {
+      copyURL.query = null;
+    } else {
+      const input = v[0] === "?" ? v.substring(1) : v;
+      copyURL.query = "";
+      whatwgURL.basicURLParse(input, {
+        url: copyURL,
+        stateOverride: "query",
+        encodingOverride: this._relevantDocument.charset
+      });
+    }
+
+    this._locationObjectSetterNavigate(copyURL);
+  }
+
+  get hash() {
+    if (this._url.fragment === null || this._url.fragment === "") {
+      return "";
+    }
+
+    return "#" + this._url.fragment;
+  }
+  set hash(v) {
+    const copyURL = { ...this._url };
+
+    if (copyURL.scheme === "javascript") {
+      return;
+    }
+
+    if (v === "") {
+      copyURL.fragment = null;
+    } else {
+      const input = v[0] === "#" ? v.substring(1) : v;
+      copyURL.fragment = "";
+      whatwgURL.basicURLParse(input, { url: copyURL, stateOverride: "fragment" });
+    }
+
+    this._locationObjectSetterNavigate(copyURL);
+  }
+
+  assign(url) {
+    // Should be entry settings object; oh well
+    const parsedURL = parseURLToResultingURLRecord(url, this._relevantDocument);
+
+    if (parsedURL === null) {
+      throw DOMException.create(this._globalObject, [
+        `Could not resolve the given string "${url}" relative to the base URL "${this._relevantDocument.URL}"`,
+        "SyntaxError"
+      ]);
+    }
+
+    this._locationObjectNavigate(parsedURL);
+  }
+
+  replace(url) {
+    // Should be entry settings object; oh well
+    const parsedURL = parseURLToResultingURLRecord(url, this._relevantDocument);
+
+    if (parsedURL === null) {
+      throw DOMException.create(this._globalObject, [
+        `Could not resolve the given string "${url}" relative to the base URL "${this._relevantDocument.URL}"`,
+        "SyntaxError"
+      ]);
+    }
+
+    this._locationObjectNavigate(parsedURL, { replacement: true });
+  }
+
+  reload() {
+    const flags = { replace: true, reloadTriggered: true, exceptionsEnabled: true };
+    navigate(this._relevantDocument._defaultView, this._url, flags);
+  }
+};