@gjsify/url 0.0.4 → 0.1.0

package/README.md

@@ -1,6 +1,32 @@
 # @gjsify/url
 
-Node.js url module for Gjs
-## Inspirations
+GJS implementation of the Node.js `url` module using GLib.Uri. Provides URL and URLSearchParams.
+
+Part of the [gjsify](https://github.com/gjsify/gjsify) project — Node.js and Web APIs for GJS (GNOME JavaScript).
+
+## Installation
+
+```bash
+npm install @gjsify/url
+# or
+yarn add @gjsify/url
+```
+
+## Usage
+
+```typescript
+import { URL, URLSearchParams } from '@gjsify/url';
+
+const url = new URL('https://example.com/path?foo=bar');
+console.log(url.hostname); // 'example.com'
+console.log(url.searchParams.get('foo')); // 'bar'
+```
+
+## Inspirations and credits
+
 - https://github.com/defunctzombie/node-url
-- https://github.com/denoland/deno_std/blob/main/node/url.ts
+- https://github.com/denoland/deno_std/blob/main/node/url.ts
+
+## License
+
+MIT

package/lib/esm/index.js

@@ -1,6 +1,444 @@
-export * from "@gjsify/deno_std/node/url";
-import _default from "@gjsify/deno_std/node/url";
-var src_default = _default;
+import GLib from "@girs/glib-2.0";
+const PARSE_FLAGS = GLib.UriFlags.HAS_PASSWORD | GLib.UriFlags.ENCODED | GLib.UriFlags.SCHEME_NORMALIZE;
+class URLSearchParams {
+  _entries = [];
+  constructor(init) {
+    if (!init) return;
+    if (typeof init === "string") {
+      const s = init.startsWith("?") ? init.slice(1) : init;
+      if (s) {
+        for (const pair of s.split("&")) {
+          const eqIdx = pair.indexOf("=");
+          if (eqIdx === -1) {
+            this._entries.push([decodeComponent(pair), ""]);
+          } else {
+            this._entries.push([decodeComponent(pair.slice(0, eqIdx)), decodeComponent(pair.slice(eqIdx + 1))]);
+          }
+        }
+      }
+    } else if (Array.isArray(init)) {
+      for (const [k, v] of init) {
+        this._entries.push([String(k), String(v)]);
+      }
+    } else if (init instanceof URLSearchParams) {
+      this._entries = init._entries.map(([k, v]) => [k, v]);
+    } else {
+      for (const key of Object.keys(init)) {
+        this._entries.push([key, String(init[key])]);
+      }
+    }
+  }
+  get(name) {
+    for (const [k, v] of this._entries) {
+      if (k === name) return v;
+    }
+    return null;
+  }
+  getAll(name) {
+    return this._entries.filter(([k]) => k === name).map(([, v]) => v);
+  }
+  set(name, value) {
+    let found = false;
+    this._entries = this._entries.filter(([k]) => {
+      if (k === name) {
+        if (!found) {
+          found = true;
+          return true;
+        }
+        return false;
+      }
+      return true;
+    });
+    if (found) {
+      for (let i = 0; i < this._entries.length; i++) {
+        if (this._entries[i][0] === name) {
+          this._entries[i][1] = value;
+          break;
+        }
+      }
+    } else {
+      this._entries.push([name, value]);
+    }
+  }
+  has(name) {
+    return this._entries.some(([k]) => k === name);
+  }
+  delete(name) {
+    this._entries = this._entries.filter(([k]) => k !== name);
+  }
+  append(name, value) {
+    this._entries.push([name, value]);
+  }
+  sort() {
+    this._entries.sort((a, b) => {
+      if (a[0] < b[0]) return -1;
+      if (a[0] > b[0]) return 1;
+      return 0;
+    });
+  }
+  toString() {
+    return this._entries.map(([k, v]) => encodeComponent(k) + "=" + encodeComponent(v)).join("&");
+  }
+  forEach(callback) {
+    for (const [k, v] of this._entries) {
+      callback(v, k, this);
+    }
+  }
+  *entries() {
+    yield* this._entries;
+  }
+  *keys() {
+    for (const [k] of this._entries) yield k;
+  }
+  *values() {
+    for (const [, v] of this._entries) yield v;
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  get size() {
+    return this._entries.length;
+  }
+}
+function decodeComponent(s) {
+  try {
+    return decodeURIComponent(s.replace(/\+/g, " "));
+  } catch {
+    return s;
+  }
+}
+function encodeComponent(s) {
+  return encodeURIComponent(s).replace(/%20/g, "+");
+}
+class URL {
+  #uri;
+  // GLib.Uri
+  #searchParams;
+  constructor(url, base) {
+    const urlStr = url instanceof URL ? url.href : String(url);
+    try {
+      if (base !== void 0) {
+        const baseStr = base instanceof URL ? base.href : String(base);
+        const baseUri = GLib.Uri.parse(baseStr, PARSE_FLAGS);
+        this.#uri = baseUri.parse_relative(urlStr, PARSE_FLAGS);
+      } else {
+        this.#uri = GLib.Uri.parse(urlStr, PARSE_FLAGS);
+      }
+    } catch (e) {
+      throw new TypeError(`Invalid URL: ${urlStr}`);
+    }
+    if (!this.#uri) {
+      throw new TypeError(`Invalid URL: ${urlStr}`);
+    }
+    this.#searchParams = new URLSearchParams(this.#uri.get_query() || "");
+  }
+  get protocol() {
+    return this.#uri.get_scheme() + ":";
+  }
+  get hostname() {
+    return (this.#uri.get_host() || "").toLowerCase();
+  }
+  get port() {
+    const p = this.#uri.get_port();
+    if (p === -1) return "";
+    const scheme = this.#uri.get_scheme();
+    if ((scheme === "http" || scheme === "ws") && p === 80) return "";
+    if ((scheme === "https" || scheme === "wss") && p === 443) return "";
+    if (scheme === "ftp" && p === 21) return "";
+    return String(p);
+  }
+  get host() {
+    const hostname = this.hostname;
+    const port = this.port;
+    return port ? `${hostname}:${port}` : hostname;
+  }
+  get pathname() {
+    return this.#uri.get_path() || "/";
+  }
+  get search() {
+    const q = this.#uri.get_query();
+    return q ? "?" + q : "";
+  }
+  get hash() {
+    const f = this.#uri.get_fragment();
+    return f ? "#" + f : "";
+  }
+  get origin() {
+    const p = this.protocol;
+    if (p === "http:" || p === "https:" || p === "ftp:") {
+      return `${p}//${this.host}`;
+    }
+    return "null";
+  }
+  get username() {
+    return this.#uri.get_user() || "";
+  }
+  get password() {
+    return this.#uri.get_password() || "";
+  }
+  get href() {
+    let result = this.protocol;
+    const scheme = this.#uri.get_scheme();
+    const isSpecial = scheme === "http" || scheme === "https" || scheme === "ftp" || scheme === "file" || scheme === "ws" || scheme === "wss";
+    if (isSpecial || this.hostname) {
+      result += "//";
+    }
+    const user = this.username;
+    const pass = this.password;
+    if (user) {
+      result += user;
+      if (pass) result += ":" + pass;
+      result += "@";
+    }
+    result += this.hostname;
+    if (this.port) result += ":" + this.port;
+    const pathname = this.pathname;
+    result += pathname;
+    result += this.search;
+    result += this.hash;
+    return result;
+  }
+  get searchParams() {
+    return this.#searchParams;
+  }
+  toString() {
+    return this.href;
+  }
+  toJSON() {
+    return this.href;
+  }
+}
+function parse(urlString, parseQueryString, slashesDenoteHost) {
+  if (typeof urlString !== "string") {
+    throw new TypeError('The "url" argument must be of type string. Received type ' + typeof urlString);
+  }
+  const result = {
+    protocol: null,
+    slashes: null,
+    auth: null,
+    host: null,
+    port: null,
+    hostname: null,
+    hash: null,
+    search: null,
+    query: null,
+    pathname: null,
+    path: null,
+    href: urlString
+  };
+  let rest = urlString.trim();
+  const hashIdx = rest.indexOf("#");
+  if (hashIdx !== -1) {
+    result.hash = rest.slice(hashIdx);
+    rest = rest.slice(0, hashIdx);
+  }
+  const qIdx = rest.indexOf("?");
+  if (qIdx !== -1) {
+    result.search = rest.slice(qIdx);
+    result.query = parseQueryString ? Object.fromEntries(new URLSearchParams(rest.slice(qIdx + 1))) : rest.slice(qIdx + 1);
+    rest = rest.slice(0, qIdx);
+  }
+  const protoMatch = /^([a-z][a-z0-9.+-]*:)/i.exec(rest);
+  if (protoMatch) {
+    result.protocol = protoMatch[1].toLowerCase();
+    rest = rest.slice(result.protocol.length);
+  }
+  if (slashesDenoteHost || result.protocol) {
+    const hasSlashes = rest.startsWith("//");
+    if (hasSlashes) {
+      result.slashes = true;
+      rest = rest.slice(2);
+    }
+  }
+  if (result.slashes || result.protocol && !["javascript:", "data:", "mailto:"].includes(result.protocol)) {
+    let hostEnd = -1;
+    for (let i = 0; i < rest.length; i++) {
+      const ch = rest[i];
+      if (ch === "/" || ch === "\\") {
+        hostEnd = i;
+        break;
+      }
+    }
+    const hostPart = hostEnd === -1 ? rest : rest.slice(0, hostEnd);
+    rest = hostEnd === -1 ? "" : rest.slice(hostEnd);
+    const atIdx = hostPart.lastIndexOf("@");
+    if (atIdx !== -1) {
+      result.auth = decodeURIComponent(hostPart.slice(0, atIdx));
+      const hostWithPort = hostPart.slice(atIdx + 1);
+      parseHostPort(hostWithPort, result);
+    } else {
+      parseHostPort(hostPart, result);
+    }
+  }
+  result.pathname = rest || (result.slashes ? "/" : null);
+  if (result.pathname !== null || result.search !== null) {
+    result.path = (result.pathname || "") + (result.search || "");
+  }
+  result.href = format(result);
+  return result;
+}
+function parseHostPort(hostPart, result) {
+  if (!hostPart) return;
+  const bracketIdx = hostPart.indexOf("[");
+  if (bracketIdx !== -1) {
+    const bracketEnd = hostPart.indexOf("]", bracketIdx);
+    if (bracketEnd !== -1) {
+      const portStr = hostPart.slice(bracketEnd + 1);
+      if (portStr.startsWith(":")) {
+        result.port = portStr.slice(1);
+      }
+      result.hostname = hostPart.slice(bracketIdx, bracketEnd + 1);
+      result.host = result.hostname + (result.port ? ":" + result.port : "");
+      return;
+    }
+  }
+  const colonIdx = hostPart.lastIndexOf(":");
+  if (colonIdx !== -1) {
+    const portCandidate = hostPart.slice(colonIdx + 1);
+    if (/^\d*$/.test(portCandidate)) {
+      result.port = portCandidate || null;
+      result.hostname = hostPart.slice(0, colonIdx).toLowerCase();
+    } else {
+      result.hostname = hostPart.toLowerCase();
+    }
+  } else {
+    result.hostname = hostPart.toLowerCase();
+  }
+  result.host = result.hostname + (result.port ? ":" + result.port : "");
+}
+function format(urlObject) {
+  if (typeof urlObject === "string") {
+    return urlObject;
+  }
+  if (urlObject instanceof URL) {
+    return urlObject.href;
+  }
+  const obj = urlObject;
+  let result = "";
+  if (obj.protocol) {
+    result += obj.protocol;
+  }
+  if (obj.slashes || obj.protocol && !["javascript:", "data:", "mailto:"].includes(obj.protocol || "")) {
+    result += "//";
+  }
+  if (obj.auth) {
+    result += encodeURIComponent(obj.auth) + "@";
+  }
+  if (obj.host) {
+    result += obj.host;
+  } else {
+    if (obj.hostname) {
+      result += obj.hostname;
+    }
+    if (obj.port) {
+      result += ":" + obj.port;
+    }
+  }
+  if (obj.pathname) {
+    result += obj.pathname;
+  }
+  if (obj.search) {
+    result += obj.search;
+  } else if (obj.query && typeof obj.query === "object") {
+    const qs = new URLSearchParams(obj.query).toString();
+    if (qs) result += "?" + qs;
+  }
+  if (obj.hash) {
+    result += obj.hash;
+  }
+  return result;
+}
+function resolve(from, to) {
+  return new URL(to, new URL(from, "resolve://")).href.replace(/^resolve:\/\//, "");
+}
+function fileURLToPath(url) {
+  if (typeof url === "string") {
+    url = new URL(url);
+  }
+  if (!(url instanceof URL)) {
+    throw new TypeError('The "url" argument must be of type string or URL. Received type ' + typeof url);
+  }
+  if (url.protocol !== "file:") {
+    throw new TypeError("The URL must be of scheme file");
+  }
+  if (url.hostname !== "" && url.hostname !== "localhost") {
+    throw new TypeError(
+      `File URL host must be "localhost" or empty on linux`
+    );
+  }
+  const pathname = url.pathname;
+  for (let i = 0; i < pathname.length; i++) {
+    if (pathname[i] === "%") {
+      const third = pathname.codePointAt(i + 2) | 32;
+      if (pathname[i + 1] === "2" && third === 102) {
+        throw new TypeError("File URL path must not include encoded / characters");
+      }
+    }
+  }
+  return decodeURIComponent(pathname);
+}
+function pathToFileURL(filepath) {
+  let resolved = filepath;
+  if (filepath[0] !== "/") {
+    if (typeof globalThis.process?.cwd === "function") {
+      resolved = globalThis.process.cwd() + "/" + filepath;
+    } else {
+      try {
+        if (GLib?.get_current_dir) {
+          resolved = GLib.get_current_dir() + "/" + filepath;
+        }
+      } catch {
+      }
+    }
+  }
+  return new URL("file://" + encodePathForURL(resolved));
+}
+function encodePathForURL(filepath) {
+  let result = "";
+  for (let i = 0; i < filepath.length; i++) {
+    const ch = filepath[i];
+    if (ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "/" || ch === "-" || ch === "_" || ch === "." || ch === "~" || ch === ":" || ch === "@" || ch === "!") {
+      result += ch;
+    } else {
+      result += encodeURIComponent(ch);
+    }
+  }
+  return result;
+}
+function domainToASCII(domain) {
+  try {
+    return new URL(`http://${domain}`).hostname;
+  } catch {
+    return "";
+  }
+}
+function domainToUnicode(domain) {
+  try {
+    return new URL(`http://${domain}`).hostname;
+  } catch {
+    return "";
+  }
+}
+var index_default = {
+  URL,
+  URLSearchParams,
+  parse,
+  format,
+  resolve,
+  fileURLToPath,
+  pathToFileURL,
+  domainToASCII,
+  domainToUnicode
+};
 export {
-  src_default as default
+  URL,
+  URLSearchParams,
+  index_default as default,
+  domainToASCII,
+  domainToUnicode,
+  fileURLToPath,
+  format,
+  parse,
+  pathToFileURL,
+  resolve
 };

package/lib/types/index.d.ts

@@ -1,3 +1,72 @@
-export type * from 'node:url';
-import type url from 'node:url';
-export default url;
+export declare class URLSearchParams {
+    _entries: [string, string][];
+    constructor(init?: string | Record<string, string> | [string, string][] | URLSearchParams);
+    get(name: string): string | null;
+    getAll(name: string): string[];
+    set(name: string, value: string): void;
+    has(name: string): boolean;
+    delete(name: string): void;
+    append(name: string, value: string): void;
+    sort(): void;
+    toString(): string;
+    forEach(callback: (value: string, key: string, parent: URLSearchParams) => void): void;
+    entries(): IterableIterator<[string, string]>;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<string>;
+    [Symbol.iterator](): IterableIterator<[string, string]>;
+    get size(): number;
+}
+export declare class URL {
+    #private;
+    constructor(url: string | URL, base?: string | URL);
+    get protocol(): string;
+    get hostname(): string;
+    get port(): string;
+    get host(): string;
+    get pathname(): string;
+    get search(): string;
+    get hash(): string;
+    get origin(): string;
+    get username(): string;
+    get password(): string;
+    get href(): string;
+    get searchParams(): URLSearchParams;
+    toString(): string;
+    toJSON(): string;
+}
+export interface UrlObject {
+    protocol?: string | null;
+    slashes?: boolean | null;
+    auth?: string | null;
+    host?: string | null;
+    port?: string | null;
+    hostname?: string | null;
+    hash?: string | null;
+    search?: string | null;
+    query?: string | Record<string, string> | null;
+    pathname?: string | null;
+    path?: string | null;
+    href?: string;
+}
+export interface Url extends UrlObject {
+    href: string;
+}
+export declare function parse(urlString: string, parseQueryString?: boolean, slashesDenoteHost?: boolean): Url;
+export declare function format(urlObject: UrlObject | string | URL): string;
+export declare function resolve(from: string, to: string): string;
+export declare function fileURLToPath(url: string | URL): string;
+export declare function pathToFileURL(filepath: string): URL;
+export declare function domainToASCII(domain: string): string;
+export declare function domainToUnicode(domain: string): string;
+declare const _default: {
+    URL: typeof URL;
+    URLSearchParams: typeof URLSearchParams;
+    parse: typeof parse;
+    format: typeof format;
+    resolve: typeof resolve;
+    fileURLToPath: typeof fileURLToPath;
+    pathToFileURL: typeof pathToFileURL;
+    domainToASCII: typeof domainToASCII;
+    domainToUnicode: typeof domainToUnicode;
+};
+export default _default;

package/package.json

@@ -1,33 +1,26 @@
 {
   "name": "@gjsify/url",
-  "version": "0.0.4",
+  "version": "0.1.0",
   "description": "Node.js url module for Gjs",
   "type": "module",
-  "main": "lib/cjs/index.js",
   "module": "lib/esm/index.js",
+  "types": "lib/types/index.d.ts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./lib/types/index.d.ts",
-        "default": "./lib/esm/index.js"
-      },
-      "require": {
-        "types": "./lib/types/index.d.ts",
-        "default": "./lib/cjs/index.js"
-      }
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/esm/index.js"
     }
   },
   "scripts": {
-    "clear": "rm -rf lib/cjs lib/esm tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo || exit 0",
-    "print:name": "echo '@gjsify/url'",
-    "build": "yarn print:name && yarn build:gjsify && yarn build:types",
+    "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo test.gjs.mjs test.node.mjs || exit 0",
+    "check": "tsc --noEmit",
+    "build": "yarn build:gjsify && yarn build:types",
     "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.ts' 'src/test.ts'",
-    "build:types": "echo 'The types are currently handwritten'",
-    "build:real_types": "tsc --project tsconfig.types.json || exit 0",
+    "build:types": "tsc",
     "build:test": "yarn build:test:gjs && yarn build:test:node",
     "build:test:gjs": "gjsify build src/test.ts --app gjs --outfile test.gjs.mjs",
     "build:test:node": "gjsify build src/test.ts --app node --outfile test.node.mjs",
-    "test": "yarn print:name && yarn build:gjsify && yarn build:test && yarn test:node && yarn test:gjs",
+    "test": "yarn build:gjsify && yarn build:test && yarn test:node && yarn test:gjs",
     "test:gjs": "gjs -m test.gjs.mjs",
     "test:node": "node test.node.mjs"
   },
@@ -36,13 +29,13 @@
     "node",
     "fs"
   ],
-  "devDependencies": {
-    "@gjsify/cli": "^0.0.4",
-    "@gjsify/unit": "^0.0.4",
-    "typescript": "^5.3.3"
-  },
   "dependencies": {
-    "@gjsify/deno_std": "^0.0.4",
-    "@types/node": "^20.10.5"
+    "@girs/glib-2.0": "^2.88.0-4.0.0-beta.42"
+  },
+  "devDependencies": {
+    "@gjsify/cli": "^0.1.0",
+    "@gjsify/unit": "^0.1.0",
+    "@types/node": "^25.5.0",
+    "typescript": "^6.0.2"
   }
 }