vasuzex 2.0.13 → 2.0.15

package/frontend/react-ui/node_modules/jsdom/lib/jsdom/living/window/Location-impl.js

@@ -0,0 +1,228 @@
+"use strict";
+const whatwgURL = require("whatwg-url");
+const DOMException = require("../generated/DOMException");
+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 (whatwgURL.hasAnOpaquePath(copyURL)) {
+      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 (whatwgURL.hasAnOpaquePath(copyURL)) {
+      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 (whatwgURL.cannotHaveAUsernamePasswordPort(copyURL)) {
+      return;
+    }
+
+    whatwgURL.basicURLParse(v, { url: copyURL, stateOverride: "port" });
+
+    this._locationObjectSetterNavigate(copyURL);
+  }
+
+  get pathname() {
+    return whatwgURL.serializePath(this._url);
+  }
+  set pathname(v) {
+    const copyURL = { ...this._url };
+
+    if (whatwgURL.hasAnOpaquePath(copyURL)) {
+      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 };
+
+    const input = v[0] === "#" ? v.substring(1) : v;
+    copyURL.fragment = "";
+    whatwgURL.basicURLParse(input, { url: copyURL, stateOverride: "fragment" });
+
+    if (copyURL.fragment === this._url.fragment) {
+      return;
+    }
+
+    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);
+  }
+};

package/frontend/react-ui/node_modules/jsdom/lib/jsdom/living/window/Screen-impl.js

@@ -0,0 +1,13 @@
+"use strict";
+
+// https://drafts.csswg.org/cssom-view-1/#the-screen-interface
+class ScreenImpl {}
+
+ScreenImpl.prototype.availWidth = 0;
+ScreenImpl.prototype.availHeight = 0;
+ScreenImpl.prototype.width = 0;
+ScreenImpl.prototype.height = 0;
+ScreenImpl.prototype.colorDepth = 24;
+ScreenImpl.prototype.pixelDepth = 24;
+
+exports.implementation = ScreenImpl;

package/frontend/react-ui/node_modules/jsdom/lib/jsdom/living/window/SessionHistory.js

@@ -0,0 +1,163 @@
+"use strict";
+const whatwgURL = require("whatwg-url");
+const HashChangeEvent = require("../generated/HashChangeEvent.js");
+const PopStateEvent = require("../generated/PopStateEvent.js");
+const notImplemented = require("../../browser/not-implemented.js");
+const idlUtils = require("../generated/utils.js");
+const { fireAnEvent } = require("../helpers/events");
+
+// https://html.spec.whatwg.org/#session-history
+class SessionHistory {
+  constructor(initialEntry, window) {
+    this._window = window;
+    this._windowImpl = idlUtils.implForWrapper(window);
+    this._historyTraversalQueue = new Set();
+    this._entries = [initialEntry];
+    this._currentIndex = 0;
+  }
+
+  _queueHistoryTraversalTask(fn) {
+    const timeoutId = this._window.setTimeout(() => {
+      this._historyTraversalQueue.delete(timeoutId);
+      fn();
+    }, 0);
+
+    this._historyTraversalQueue.add(timeoutId);
+  }
+
+  clearHistoryTraversalTasks() {
+    for (const timeoutId of this._historyTraversalQueue) {
+      this._window.clearTimeout(timeoutId);
+    }
+    this._historyTraversalQueue.clear();
+  }
+
+  get length() {
+    return this._entries.length;
+  }
+
+  get currentEntry() {
+    return this._entries[this._currentIndex];
+  }
+
+  // https://html.spec.whatwg.org/#dom-history-pushstate
+  removeAllEntriesAfterCurrentEntry() {
+    this._entries.splice(this._currentIndex + 1, Infinity);
+  }
+
+  // https://html.spec.whatwg.org/#traverse-the-history-by-a-delta
+  traverseByDelta(delta) {
+    this._queueHistoryTraversalTask(() => {
+      const newIndex = this._currentIndex + delta;
+      if (newIndex < 0 || newIndex >= this.length) {
+        return;
+      }
+
+      const specifiedEntry = this._entries[newIndex];
+
+      // Not implemented: unload a document guard
+
+      // Not clear that this should be queued. html/browsers/history/the-history-interface/004.html can be fixed
+      // by removing the queue, but doing so breaks some tests in history.js that also pass in browsers.
+      this._queueHistoryTraversalTask(() => {
+        // If there is an ongoing attempt to navigate specified browsing context that has not yet matured,
+        // then cancel that attempt to navigate the browsing context.
+
+        // Doing this seems to break tests involving navigating via push/pop state and via fragments. I think this
+        // is because these navigations should already count as having "matured" because the document is not changing.
+
+        // this.clearHistoryTraversalTasks();
+
+        if (specifiedEntry.document !== this.currentEntry.document) {
+          // TODO: unload the active document with the recycle parameter set to false
+          notImplemented("Traversing history in a way that would change the window", this._window);
+        }
+        this.traverseHistory(specifiedEntry);
+      });
+    });
+  }
+
+  // https://html.spec.whatwg.org/#traverse-the-history
+  traverseHistory(specifiedEntry, flags = {}) {
+    if (!specifiedEntry.document) {
+      // If entry no longer holds a Document object, then navigate the browsing context to entry's URL
+      // to perform an entry update of entry, and abort these steps
+      notImplemented("Traversing the history to an entry that no longer holds a Document object", this._window);
+    }
+    // Not spec compliant, just minimal. Lots of missing steps.
+
+    const nonBlockingEvents = Boolean(flags.nonBlockingEvents);
+
+    const document = idlUtils.implForWrapper(this._window._document);
+
+    const { currentEntry } = this;
+
+    // If the current entry's title was not set by the pushState() or replaceState() methods, then set its title
+    // to the value returned by the document.title IDL attribute.
+    if (currentEntry.title === undefined) {
+      currentEntry.title = document.title;
+    }
+
+
+    if (specifiedEntry.document !== currentEntry.document) {
+      // If entry has a different Document object than the current entry, then...
+      notImplemented("Traversing the history to an entry with a different Document", this._window);
+    }
+
+    document._URL = specifiedEntry.url;
+
+    const hashChanged =
+      specifiedEntry.url.fragment !== currentEntry.url.fragment && specifiedEntry.document === currentEntry.document;
+    let oldURL, newURL;
+    if (hashChanged) {
+      oldURL = currentEntry.url;
+      newURL = specifiedEntry.url;
+    }
+
+    if (flags.replacement) {
+      // If the traversal was initiated with replacement enabled, remove the entry immediately before the
+      // specified entry in the session history.
+      this._entries.splice(this._entries.indexOf(specifiedEntry) - 1, 1);
+    }
+
+    this.updateCurrentEntry(specifiedEntry);
+
+    const state = specifiedEntry.stateObject; // TODO structured clone
+
+    // 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.
+    document._history._state = state;
+    const stateChanged = specifiedEntry.document._latestEntry !== specifiedEntry;
+    specifiedEntry.document._latestEntry = specifiedEntry;
+
+    const fireEvents = () => this._fireEvents(stateChanged, hashChanged, state, oldURL, newURL);
+
+    if (nonBlockingEvents) {
+      this._window.setTimeout(fireEvents, 0);
+    } else {
+      fireEvents();
+    }
+  }
+
+  _fireEvents(stateChanged, hashChanged, state, oldURL, newURL) {
+    if (stateChanged) {
+      fireAnEvent("popstate", this._windowImpl, PopStateEvent, { state });
+    }
+
+    if (hashChanged) {
+      fireAnEvent("hashchange", this._windowImpl, HashChangeEvent, {
+        oldURL: whatwgURL.serializeURL(oldURL),
+        newURL: whatwgURL.serializeURL(newURL)
+      });
+    }
+  }
+
+  addEntryAfterCurrentEntry(entry) {
+    this._entries.splice(this._currentIndex + 1, 0, entry);
+  }
+
+  updateCurrentEntry(entry) {
+    this._currentIndex = this._entries.indexOf(entry);
+  }
+}
+module.exports = SessionHistory;

package/frontend/react-ui/node_modules/jsdom/lib/jsdom/living/window/navigation.js

@@ -0,0 +1,85 @@
+"use strict";
+const whatwgURL = require("whatwg-url");
+const notImplemented = require("../../browser/not-implemented.js");
+const reportException = require("../helpers/runtime-script-errors.js");
+const idlUtils = require("../generated/utils.js");
+
+exports.evaluateJavaScriptURL = (window, urlRecord) => {
+  const urlString = whatwgURL.serializeURL(urlRecord);
+  const encodedScriptSource = urlString.substring("javascript:".length);
+  const scriptSource = Buffer.from(whatwgURL.percentDecodeString(encodedScriptSource)).toString();
+  if (window._runScripts === "dangerously") {
+    try {
+      return window.eval(scriptSource);
+    } catch (e) {
+      reportException(window, e, urlString);
+    }
+  }
+  return undefined;
+};
+
+// https://html.spec.whatwg.org/#navigating-across-documents
+exports.navigate = (window, newURL, flags) => {
+  // This is NOT a spec-compliant implementation of navigation in any way. It implements a few selective steps that
+  // are nice for jsdom users, regarding hash changes and JavaScript URLs. Full navigation support is being worked on
+  // and will likely require some additional hooks to be implemented.
+  if (!window._document) {
+    return;
+  }
+
+  const document = idlUtils.implForWrapper(window._document);
+  const currentURL = document._URL;
+
+  if (!flags.reloadTriggered && urlEquals(currentURL, newURL, { excludeFragments: true })) {
+    if (newURL.fragment !== currentURL.fragment) {
+      navigateToFragment(window, newURL, flags);
+    }
+    return;
+  }
+
+  // NOT IMPLEMENTED: Prompt to unload the active document of browsingContext.
+
+  // NOT IMPLEMENTED: form submission algorithm
+  // const navigationType = 'other';
+
+  // NOT IMPLEMENTED: if resource is a response...
+  if (newURL.scheme === "javascript") {
+    setTimeout(() => {
+      const result = exports.evaluateJavaScriptURL(window, newURL);
+      if (typeof result === "string") {
+        notImplemented("string results from 'javascript:' URLs", window);
+      }
+    }, 0);
+    return;
+  }
+  navigateFetch(window);
+};
+
+// https://html.spec.whatwg.org/#scroll-to-fragid
+function navigateToFragment(window, newURL, flags) {
+  const document = idlUtils.implForWrapper(window._document);
+
+  window._sessionHistory.clearHistoryTraversalTasks();
+
+  if (!flags.replacement) {
+    // handling replacement=true here deviates from spec, but matches real browser behaviour
+    // see https://github.com/whatwg/html/issues/2796 for spec bug
+    window._sessionHistory.removeAllEntriesAfterCurrentEntry();
+  }
+  const newEntry = { document, url: newURL };
+  window._sessionHistory.addEntryAfterCurrentEntry(newEntry);
+  window._sessionHistory.traverseHistory(newEntry, { nonBlockingEvents: true, replacement: flags.replacement });
+}
+
+// https://html.spec.whatwg.org/#process-a-navigate-fetch
+function navigateFetch(window) {
+  // TODO:
+  notImplemented("navigation (except hash changes)", window);
+}
+
+// https://url.spec.whatwg.org/#concept-url-equals
+function urlEquals(a, b, flags) {
+  const serializedA = whatwgURL.serializeURL(a, flags.excludeFragments);
+  const serializedB = whatwgURL.serializeURL(b, flags.excludeFragments);
+  return serializedA === serializedB;
+}

package/frontend/react-ui/node_modules/jsdom/lib/jsdom/living/xhr/FormData-impl.js

@@ -0,0 +1,191 @@
+"use strict";
+const DOMException = require("../generated/DOMException");
+const idlUtils = require("../generated/utils");
+const { closest } = require("../helpers/traversal");
+const { isDisabled, isButton, isSubmitButton } = require("../helpers/form-controls");
+const Blob = require("../generated/Blob.js");
+const File = require("../generated/File.js");
+const conversions = require("webidl-conversions");
+
+exports.implementation = class FormDataImpl {
+  constructor(globalObject, args) {
+    this._globalObject = globalObject;
+    this._entries = [];
+
+    if (args[0] !== undefined) {
+      const [form, submitter = null] = args;
+      if (submitter !== null) {
+        if (!isSubmitButton(submitter)) {
+          throw new TypeError("The specified element is not a submit button");
+        }
+        if (submitter.form !== form) {
+          throw DOMException.create(this._globalObject, [
+            "The specified element is not owned by this form element",
+            "NotFoundError"
+          ]);
+        }
+      }
+      this._entries = constructTheEntryList(form, submitter);
+    }
+  }
+
+  append(name, value, filename) {
+    const entry = createAnEntry(name, value, filename);
+    this._entries.push(entry);
+  }
+
+  delete(name) {
+    this._entries = this._entries.filter(entry => entry.name !== name);
+  }
+
+  get(name) {
+    const foundEntry = this._entries.find(entry => entry.name === name);
+    return foundEntry !== undefined ? idlUtils.tryWrapperForImpl(foundEntry.value) : null;
+  }
+
+  getAll(name) {
+    return this._entries.filter(entry => entry.name === name).map(entry => idlUtils.tryWrapperForImpl(entry.value));
+  }
+
+  has(name) {
+    return this._entries.findIndex(entry => entry.name === name) !== -1;
+  }
+
+  set(name, value, filename) {
+    const entry = createAnEntry(name, value, filename);
+
+    const foundIndex = this._entries.findIndex(e => e.name === name);
+    if (foundIndex !== -1) {
+      this._entries[foundIndex] = entry;
+      this._entries = this._entries.filter((e, i) => e.name !== name || i === foundIndex);
+    } else {
+      this._entries.push(entry);
+    }
+  }
+
+  * [Symbol.iterator]() {
+    for (const entry of this._entries) {
+      yield [entry.name, idlUtils.tryWrapperForImpl(entry.value)];
+    }
+  }
+};
+
+function createAnEntry(name, value, filename) {
+  const entry = { name };
+
+  // https://github.com/whatwg/xhr/issues/75
+
+  if (Blob.isImpl(value) && !File.isImpl(value)) {
+    const oldValue = value;
+    value = File.createImpl(value._globalObject, [
+      [],
+      "blob",
+      { type: oldValue.type }
+    ]);
+    // "representing the same bytes"
+    value._buffer = oldValue._buffer;
+  }
+
+  if (File.isImpl(value) && filename !== undefined) {
+    const oldValue = value;
+    value = File.createImpl(value._globalObject, [
+      [],
+      filename,
+      // spec makes no mention of `lastModified`; assume it is inherited
+      // (Chrome's behavior)
+      { type: oldValue.type, lastModified: oldValue.lastModified }
+    ]);
+    // "representing the same bytes"
+    value._buffer = oldValue._buffer;
+  }
+
+  entry.value = value;
+
+  return entry;
+}
+
+function constructTheEntryList(form, submitter) {
+  // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#constructing-the-form-data-set
+  // TODO: handle encoding
+  // TODO: handling "constructing entry list"
+
+  const controls = form._getSubmittableElementNodes();
+  const entryList = [];
+
+  for (const field of controls) {
+    if (closest(field, "datalist") !== null) {
+      continue;
+    }
+    if (isDisabled(field)) {
+      continue;
+    }
+    if (isButton(field) && field !== submitter) {
+      continue;
+    }
+    if (field.type === "checkbox" && field._checkedness === false) {
+      continue;
+    }
+    if (field.type === "radio" && field._checkedness === false) {
+      continue;
+    }
+    if (field.localName === "object") { // in jsdom, no objects are "using a plugin"
+      continue;
+    }
+
+    const name = field.getAttributeNS(null, "name");
+    if (field.localName === "input" && field.type === "image") {
+      const prefix = name ? `${name}.` : "";
+      const coordinate = field._selectedCoordinate ?? { x: 0, y: 0 };
+      appendAnEntry(entryList, `${prefix}x`, coordinate.x);
+      appendAnEntry(entryList, `${prefix}y`, coordinate.y);
+      continue;
+    }
+
+    // TODO: handle form-associated custom elements.
+
+    if (name === null || name === "") {
+      continue;
+    }
+
+    if (field.localName === "select") {
+      for (const option of field.options) {
+        if (option._selectedness === true && !isDisabled(field)) {
+          appendAnEntry(entryList, name, option._getValue());
+        }
+      }
+    } else if (field.localName === "input" && (field.type === "checkbox" || field.type === "radio")) {
+      const value = field.hasAttributeNS(null, "value") ? field.getAttributeNS(null, "value") : "on";
+      appendAnEntry(entryList, name, value);
+    } else if (field.type === "file") {
+      if (field.files.length === 0) {
+        const value = File.createImpl(form._globalObject, [[], "", { type: "application/octet-stream" }]);
+        appendAnEntry(entryList, name, value);
+      } else {
+        for (let i = 0; i < field.files.length; ++i) {
+          appendAnEntry(entryList, name, field.files.item(i));
+        }
+      }
+    } else {
+      appendAnEntry(entryList, name, field._getValue());
+    }
+
+    const dirname = field.getAttributeNS(null, "dirname");
+    if (dirname !== null && dirname !== "") {
+      const dir = "ltr"; // jsdom does not (yet?) implement actual directionality
+      appendAnEntry(entryList, dirname, dir);
+    }
+  }
+
+  // TODO: formdata event
+
+  return entryList;
+}
+
+function appendAnEntry(entryList, name, value) {
+  name = conversions.USVString(name);
+  if (!File.isImpl(value)) {
+    value = conversions.USVString(value);
+  }
+  const entry = createAnEntry(name, value);
+  entryList.push(entry);
+}