quickwin 1.0.0

package/lib/url.ts

@@ -0,0 +1,201 @@
+export {} // make this a module so declare global works
+
+declare global {
+    interface URLSearchParams extends URLSearchParamsImpl {}
+    var URLSearchParams: typeof URLSearchParamsImpl
+    interface URL extends URLImpl {}
+    var URL: typeof URLImpl
+}
+
+function _encode(s: string): string { return encodeURIComponent(s) }
+function _decode(s: string): string {
+    try { return decodeURIComponent(s.replace(/\+/g, ' ')) }
+    catch { return s }
+}
+
+function _normalizePath(path: string): string {
+    if (!path) return '/'
+    const parts = path.split('/')
+    const out: string[] = []
+    let hasRoot = path[0] === '/'
+    if (hasRoot) out.push('')
+    for (const p of parts) {
+        if (p === '' || p === '.') continue
+        if (p === '..') {
+            const last = out[out.length - 1]
+            if (last !== undefined && last !== '') out.pop()
+        } else {
+            out.push(p)
+        }
+    }
+    if (path.endsWith('/') && out[out.length - 1] !== '') out.push('')
+    const result = out.join('/')
+    if (hasRoot && !result.startsWith('/')) return '/' + result
+    return result || '/'
+}
+
+function _parseURL(url: string): { scheme: string; user: string; pass: string; host: string; port: string; path: string; query: string; fragment: string } {
+    const r = { scheme: '', user: '', pass: '', host: '', port: '', path: '/', query: '', fragment: '' }
+    const fi = url.indexOf('#')
+    if (fi >= 0) { r.fragment = url.slice(fi + 1); url = url.slice(0, fi) }
+    const qi = url.indexOf('?')
+    if (qi >= 0) { r.query = url.slice(qi + 1); url = url.slice(0, qi) }
+    const sm = url.match(/^([a-zA-Z][a-zA-Z0-9+\-.]*):(.*)$/)
+    if (sm) { r.scheme = sm[1]!.toLowerCase(); url = sm[2]! }
+    if (url.startsWith('//')) {
+        url = url.slice(2)
+        const si = url.indexOf('/')
+        let auth: string
+        if (si < 0) { auth = url; url = '' } else { auth = url.slice(0, si); url = url.slice(si) }
+        const ai = auth.lastIndexOf('@')
+        if (ai >= 0) {
+            const ui = auth.slice(0, ai); auth = auth.slice(ai + 1)
+            const ci = ui.indexOf(':')
+            if (ci >= 0) { r.user = _decode(ui.slice(0, ci)); r.pass = _decode(ui.slice(ci + 1)) }
+            else r.user = _decode(ui)
+        }
+        if (auth.startsWith('[')) {
+            const cb = auth.indexOf(']')
+            r.host = auth.slice(1, cb).toLowerCase()
+            const pp = auth.slice(cb + 1)
+            if (pp.startsWith(':')) r.port = pp.slice(1)
+        } else {
+            const ci = auth.lastIndexOf(':')
+            if (ci >= 0 && ci === auth.lastIndexOf(':')) { r.host = auth.slice(0, ci).toLowerCase(); r.port = auth.slice(ci + 1) }
+            else r.host = auth.toLowerCase()
+        }
+    }
+    r.path = url
+    if (r.host && !r.path.startsWith('/')) r.path = '/' + r.path
+    return r
+}
+
+class URLSearchParamsImpl {
+    private _list: [string, string][] = []
+
+    constructor(init?: string | [string, string][] | Record<string, string>) {
+        if (typeof init === 'string') {
+            const s = init.startsWith('?') ? init.slice(1) : init
+            if (!s) return
+            for (const p of s.split('&')) {
+                const eq = p.indexOf('=')
+                if (eq < 0) { this._list.push([_decode(p), '']); continue }
+                this._list.push([_decode(p.slice(0, eq)), _decode(p.slice(eq + 1))])
+            }
+        } else if (init) {
+            if (Array.isArray(init)) for (const [k, v] of init) this._list.push([String(k), String(v)])
+            else for (const k of Object.keys(init)) this._list.push([k, String(init[k])])
+        }
+    }
+
+    append(key: string, value: string): void { this._list.push([key, value]) }
+    delete(key: string): void { this._list = this._list.filter(([k]) => k !== key) }
+    get(key: string): string | null { for (const [k, v] of this._list) if (k === key) return v; return null }
+    getAll(key: string): string[] { return this._list.filter(([k]) => k === key).map(([, v]) => v) }
+    has(key: string): boolean { return this._list.some(([k]) => k === key) }
+    set(key: string, value: string): void {
+        let f = false
+        for (let i = 0; i < this._list.length; i++) {
+            if (this._list[i]![0] === key) { if (!f) { this._list[i]![1] = value; f = true } else { this._list.splice(i, 1); i-- } }
+        }
+        if (!f) this._list.push([key, value])
+    }
+    sort(): void { this._list.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0) }
+    forEach(fn: (v: string, k: string) => void): void { for (const [k, v] of this._list) fn(v, k) }
+
+    *keys(): IterableIterator<string> { for (const [k] of this._list) yield k }
+    *values(): IterableIterator<string> { for (const [, v] of this._list) yield v }
+    *entries(): IterableIterator<[string, string]> { for (const item of this._list) yield [item[0], item[1]] }
+    *[Symbol.iterator](): IterableIterator<[string, string]> { for (const item of this._list) yield item }
+
+    toString(): string { return this._list.map(([k, v]) => _encode(k) + '=' + _encode(v)).join('&') }
+    get size(): number { return this._list.length }
+}
+
+if (typeof globalThis.URLSearchParams === 'undefined') {
+    globalThis.URLSearchParams = URLSearchParamsImpl
+}
+
+class URLImpl {
+    private _scheme = ''
+    private _username = ''
+    private _password = ''
+    private _hostname = ''
+    private _port = ''
+    private _pathname = '/'
+    private _query = ''
+    private _fragment = ''
+    private _searchParams: URLSearchParams = new URLSearchParamsImpl()
+
+    constructor(url: string, base?: string) {
+        let p = _parseURL(url)
+        if (p.scheme) { this._apply(p); return }
+        if (base === undefined) throw new TypeError('Invalid URL')
+
+        const b = new URLImpl(base)
+        if (p.host) { p.scheme = b._scheme; this._apply(p); return }
+        if (!p.path && !p.query) {
+            this._apply({
+                scheme: b._scheme, user: b._username, pass: b._password,
+                host: b._hostname, port: b._port,
+                path: b._pathname, query: b._query, fragment: p.fragment || ''
+            }); return
+        }
+        p.scheme = b._scheme; if (!p.user) p.user = b._username; if (!p.pass) p.pass = b._password
+        if (!p.host) p.host = b._hostname; if (!p.port) p.port = b._port; if (!p.fragment) p.fragment = ''
+        if (p.path && !p.path.startsWith('/')) {
+            const bd = b._pathname.substring(0, b._pathname.lastIndexOf('/') + 1)
+            p.path = _normalizePath(bd + p.path)
+        } else if (!p.path) { p.path = b._pathname; if (!p.query) p.query = b._query }
+        this._apply(p)
+    }
+
+    private _apply(p: { scheme: string; user: string; pass: string; host: string; port: string; path: string; query: string; fragment: string }): void {
+        this._scheme = p.scheme; this._username = p.user; this._password = p.pass
+        this._hostname = p.host; this._port = p.port
+        this._pathname = _normalizePath(p.path || '/')
+        this._query = p.query; this._fragment = p.fragment
+        this._searchParams = new URLSearchParamsImpl(this._query)
+    }
+
+    get href(): string { return this.toString() }
+    get protocol(): string { return this._scheme + ':' }
+    get hostname(): string { return this._hostname }
+    get port(): string { return this._port }
+    get pathname(): string { return this._pathname }
+    get search(): string { return this._query ? '?' + this._query : '' }
+    get hash(): string { return this._fragment ? '#' + this._fragment : '' }
+    get host(): string {
+        const h = this._hostname
+        const ipv6 = h.includes(':')
+        return (ipv6 ? '[' + h + ']' : h) + (this._port ? ':' + this._port : '')
+    }
+    get origin(): string {
+        const h = this._hostname
+        const ipv6 = h.includes(':')
+        return this._scheme + '://' + (ipv6 ? '[' + h + ']' : h) + (this._port ? ':' + this._port : '')
+    }
+    get username(): string { return this._username }
+    get password(): string { return this._password }
+    get searchParams(): URLSearchParams { return this._searchParams }
+
+    toString(): string {
+        let s = this._scheme + ':'
+        const special = ['http', 'https', 'ws', 'wss', 'ftp', 'file']
+        if (this._hostname || (special.includes(this._scheme) && this._pathname.startsWith('/'))) {
+            s += '//'
+            if (this._username) { s += _encode(this._username); if (this._password) s += ':' + _encode(this._password); s += '@' }
+            s += this._hostname.includes(':') ? '[' + this._hostname + ']' : this._hostname
+            if (this._port) s += ':' + this._port
+        }
+        s += this._pathname
+        if (this._query) s += '?' + this._query
+        if (this._fragment) s += '#' + this._fragment
+        return s
+    }
+
+    toJSON(): string { return this.toString() }
+}
+if (typeof globalThis.URL === 'undefined') {
+    globalThis.URL = URLImpl
+}