denoland-deno/extensions/url/00_url.js

// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
"use strict";

((window) => {
  const core = window.Deno.core;

  function requiredArguments(name, length, required) {
    if (length < required) {
      const errMsg = `${name} requires at least ${required} argument${
        required === 1 ? "" : "s"
      }, but only ${length} present`;
      throw new TypeError(errMsg);
    }
  }

  const paramLists = new WeakMap();
  const urls = new WeakMap();

  class URLSearchParams {
    #params = [];

    constructor(init = "") {
      if (typeof init === "string") {
        // Overload: USVString
        // If init is a string and starts with U+003F (?),
        // remove the first code point from init.
        if (init[0] == "?") {
          init = init.slice(1);
        }

        this.#params = core.opSync("op_url_parse_search_params", init);
      } else if (
        Array.isArray(init) ||
        typeof init?.[Symbol.iterator] == "function"
      ) {
        // Overload: sequence<sequence<USVString>>
        for (const pair of init) {
          // If pair does not contain exactly two items, then throw a TypeError.
          if (pair.length !== 2) {
            throw new TypeError(
              "URLSearchParams.constructor sequence argument must only contain pair elements",
            );
          }
          this.#params.push([String(pair[0]), String(pair[1])]);
        }
      } else if (Object(init) !== init) {
        // pass
      } else if (init instanceof URLSearchParams) {
        this.#params = [...init.#params];
      } else {
        // Overload: record<USVString, USVString>
        for (const key of Object.keys(init)) {
          this.#params.push([key, String(init[key])]);
        }
      }

      paramLists.set(this, this.#params);
      urls.set(this, null);
    }

    #updateUrlSearch = () => {
      const url = urls.get(this);
      if (url == null) {
        return;
      }
      const parseArgs = { href: url.href, setSearch: this.toString() };
      parts.set(url, core.opSync("op_url_parse", parseArgs));
    };

    append(name, value) {
      requiredArguments("URLSearchParams.append", arguments.length, 2);
      this.#params.push([String(name), String(value)]);
      this.#updateUrlSearch();
    }

    delete(name) {
      requiredArguments("URLSearchParams.delete", arguments.length, 1);
      name = String(name);
      let i = 0;
      while (i < this.#params.length) {
        if (this.#params[i][0] === name) {
          this.#params.splice(i, 1);
        } else {
          i++;
        }
      }
      this.#updateUrlSearch();
    }

    getAll(name) {
      requiredArguments("URLSearchParams.getAll", arguments.length, 1);
      name = String(name);
      const values = [];
      for (const entry of this.#params) {
        if (entry[0] === name) {
          values.push(entry[1]);
        }
      }

      return values;
    }

    get(name) {
      requiredArguments("URLSearchParams.get", arguments.length, 1);
      name = String(name);
      for (const entry of this.#params) {
        if (entry[0] === name) {
          return entry[1];
        }
      }

      return null;
    }

    has(name) {
      requiredArguments("URLSearchParams.has", arguments.length, 1);
      name = String(name);
      return this.#params.some((entry) => entry[0] === name);
    }

    set(name, value) {
      requiredArguments("URLSearchParams.set", arguments.length, 2);

      // If there are any name-value pairs whose name is name, in list,
      // set the value of the first such name-value pair to value
      // and remove the others.
      name = String(name);
      value = String(value);
      let found = false;
      let i = 0;
      while (i < this.#params.length) {
        if (this.#params[i][0] === name) {
          if (!found) {
            this.#params[i][1] = value;
            found = true;
            i++;
          } else {
            this.#params.splice(i, 1);
          }
        } else {
          i++;
        }
      }

      // Otherwise, append a new name-value pair whose name is name
      // and value is value, to list.
      if (!found) {
        this.#params.push([String(name), String(value)]);
      }

      this.#updateUrlSearch();
    }

    sort() {
      this.#params.sort((a, b) => (a[0] === b[0] ? 0 : a[0] > b[0] ? 1 : -1));
      this.#updateUrlSearch();
    }

    forEach(callbackfn, thisArg) {
      requiredArguments("URLSearchParams.forEach", arguments.length, 1);

      if (typeof thisArg !== "undefined") {
        callbackfn = callbackfn.bind(thisArg);
      }

      for (const [key, value] of this.#params) {
        callbackfn(value, key, this);
      }
    }

    *keys() {
      for (const [key] of this.#params) {
        yield key;
      }
    }

    *values() {
      for (const [, value] of this.#params) {
        yield value;
      }
    }

    *entries() {
      yield* this.#params;
    }

    *[Symbol.iterator]() {
      yield* this.#params;
    }

    toString() {
      return core.opSync("op_url_stringify_search_params", this.#params);
    }
  }

  const parts = new WeakMap();

  class URL {
    #searchParams = null;

    constructor(url, base) {
      new.target;

      if (url instanceof URL && base === undefined) {
        parts.set(this, parts.get(url));
      } else {
        base = base !== undefined ? String(base) : base;
        const parseArgs = { href: String(url), baseHref: base };
        parts.set(this, core.opSync("op_url_parse", parseArgs));
      }
    }

    [Symbol.for("Deno.customInspect")](inspect) {
      const object = {
        href: this.href,
        origin: this.origin,
        protocol: this.protocol,
        username: this.username,
        password: this.password,
        host: this.host,
        hostname: this.hostname,
        port: this.port,
        pathname: this.pathname,
        hash: this.hash,
        search: this.search,
      };
      return `${this.constructor.name} ${inspect(object)}`;
    }

    #updateSearchParams = () => {
      if (this.#searchParams != null) {
        const params = paramLists.get(this.#searchParams);
        const newParams = core.opSync(
          "op_url_parse_search_params",
          this.search.slice(1),
        );
        params.splice(0, params.length, ...newParams);
      }
    };

    get hash() {
      return parts.get(this).hash;
    }

    set hash(value) {
      try {
        const parseArgs = { href: this.href, setHash: String(value) };
        parts.set(this, core.opSync("op_url_parse", parseArgs));
      } catch {
        /* pass */
      }
    }

    get host() {
      return parts.get(this).host;
    }

    set host(value) {
      try {
        const parseArgs = { href: this.href, setHost: String(value) };
        parts.set(this, core.opSync("op_url_parse", parseArgs));
      } catch {
        /* pass */
      }
    }

    get hostname() {
      return parts.get(this).hostname;
    }

    set hostname(value) {
      try {
        const parseArgs = { href: this.href, setHostname: String(value) };
        parts.set(this, core.opSync("op_url_parse", parseArgs));
      } catch {
        /* pass */
      }
    }

    get href() {
      return parts.get(this).href;
    }

    set href(value) {
      try {
        const parseArgs = { href: String(value) };
        parts.set(this, core.opSync("op_url_parse", parseArgs));
      } catch {
        throw new TypeError("Invalid URL");
      }
      this.#updateSearchParams();
    }

    get origin() {
      return parts.get(this).origin;
    }

    get password() {
      return parts.get(this).password;
    }

    set password(value) {
      try {
        const parseArgs = { href: this.href, setPassword: String(value) };
        parts.set(this, core.opSync("op_url_parse", parseArgs));
      } catch {
        /* pass */
      }
    }

    get pathname() {
      return parts.get(this).pathname;
    }

    set pathname(value) {
      try {
        const parseArgs = { href: this.href, setPathname: String(value) };
        parts.set(this, core.opSync("op_url_parse", parseArgs));
      } catch {
        /* pass */
      }
    }

    get port() {
      return parts.get(this).port;
    }

    set port(value) {
      try {
        const parseArgs = { href: this.href, setPort: String(value) };
        parts.set(this, core.opSync("op_url_parse", parseArgs));
      } catch {
        /* pass */
      }
    }

    get protocol() {
      return parts.get(this).protocol;
    }

    set protocol(value) {
      try {
        const parseArgs = { href: this.href, setProtocol: String(value) };
        parts.set(this, core.opSync("op_url_parse", parseArgs));
      } catch {
        /* pass */
      }
    }

    get search() {
      return parts.get(this).search;
    }

    set search(value) {
      try {
        const parseArgs = { href: this.href, setSearch: String(value) };
        parts.set(this, core.opSync("op_url_parse", parseArgs));
        this.#updateSearchParams();
      } catch {
        /* pass */
      }
    }

    get username() {
      return parts.get(this).username;
    }

    set username(value) {
      try {
        const parseArgs = { href: this.href, setUsername: String(value) };
        parts.set(this, core.opSync("op_url_parse", parseArgs));
      } catch {
        /* pass */
      }
    }

    get searchParams() {
      if (this.#searchParams == null) {
        this.#searchParams = new URLSearchParams(this.search);
        urls.set(this.#searchParams, this);
      }
      return this.#searchParams;
    }

    toString() {
      return this.href;
    }

    toJSON() {
      return this.href;
    }
  }

  /**
   * This function implements application/x-www-form-urlencoded parsing.
   * https://url.spec.whatwg.org/#concept-urlencoded-parser
   * @param {Uint8Array} bytes
   * @returns {[string, string][]}
   */
  function parseUrlEncoded(bytes) {
    return core.opSync("op_url_parse_search_params", null, bytes);
  }

  window.__bootstrap.url = {
    URL,
    URLSearchParams,
    parseUrlEncoded,
  };
})(this);