oak-domain 4.0.0 → 4.0.2

package/lib/utils/url/index.native.js

@@ -1,7 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.urlSearchParams = exports.url = void 0;
-const url = URL;
-exports.url = url;
-const urlSearchParams = URLSearchParams;
-exports.urlSearchParams = urlSearchParams;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.urlSearchParams = exports.url = void 0;
+const url = URL;
+exports.url = url;
+const urlSearchParams = URLSearchParams;
+exports.urlSearchParams = urlSearchParams;

package/lib/utils/url/index.web.d.ts

@@ -1,12 +1,12 @@
-declare const url: {
-    new (url: string | URL, base?: string | URL | undefined): URL;
-    prototype: URL;
-    canParse(url: string | URL, base?: string | undefined): boolean;
-    createObjectURL(obj: Blob | MediaSource): string;
-    revokeObjectURL(url: string): void;
-};
-declare const urlSearchParams: {
-    new (init?: string | Record<string, string> | string[][] | URLSearchParams | undefined): URLSearchParams;
-    prototype: URLSearchParams;
-};
-export { url, urlSearchParams };
+declare const url: {
+    new (url: string | URL, base?: string | URL | undefined): URL;
+    prototype: URL;
+    canParse(url: string | URL, base?: string | undefined): boolean;
+    createObjectURL(obj: Blob | MediaSource): string;
+    revokeObjectURL(url: string): void;
+};
+declare const urlSearchParams: {
+    new (init?: string | Record<string, string> | string[][] | URLSearchParams | undefined): URLSearchParams;
+    prototype: URLSearchParams;
+};
+export { url, urlSearchParams };

package/lib/utils/url/index.web.js

@@ -1,7 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.urlSearchParams = exports.url = void 0;
-const url = URL;
-exports.url = url;
-const urlSearchParams = URLSearchParams;
-exports.urlSearchParams = urlSearchParams;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.urlSearchParams = exports.url = void 0;
+const url = URL;
+exports.url = url;
+const urlSearchParams = URLSearchParams;
+exports.urlSearchParams = urlSearchParams;

package/lib/utils/url/whatwg-url/index.d.ts

@@ -0,0 +1,3 @@
+declare const URL: URL;
+declare const URLSearchParams: URLSearchParams;
+export { URL, URLSearchParams };

package/lib/utils/url/whatwg-url/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.URLSearchParams = exports.URL = void 0;
+/**
+ * 为了能在小程序中使用URL、URLSearchParams
+ * 但whatwg-url-without-unicode这个库未更新，把其的代码放本地进行更新
+ */
+const whatwgUrl = require('./lib/URL');
+const whatwgUrlSearchParams = require('./lib/URLSearchParams');
+const sharedGlobalObject = {};
+whatwgUrl.install(sharedGlobalObject);
+whatwgUrlSearchParams.install(sharedGlobalObject);
+const URL = sharedGlobalObject.URL;
+exports.URL = URL;
+const URLSearchParams = sharedGlobalObject.URLSearchParams;
+exports.URLSearchParams = URLSearchParams;

package/lib/utils/url/whatwg-url/lib/URL-impl.d.ts

@@ -0,0 +1,20 @@
+declare const _default: {
+    implementation: {
+        new (globalObject: any, constructorArgs: any): {
+            href: string;
+            readonly origin: any;
+            protocol: string;
+            username: any;
+            password: any;
+            host: any;
+            hostname: any;
+            port: string;
+            pathname: any;
+            search: string;
+            readonly searchParams: any;
+            hash: string;
+            toJSON(): string;
+        };
+    };
+};
+export default _default;

package/lib/utils/url/whatwg-url/lib/URL-impl.js

@@ -0,0 +1,175 @@
+"use strict";
+// @ts-nocheck
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const url_state_machine_1 = tslib_1.__importDefault(require("./url-state-machine"));
+const urlencoded_1 = tslib_1.__importDefault(require("./urlencoded"));
+const URLSearchParams_1 = tslib_1.__importDefault(require("./URLSearchParams"));
+const implementation = class URLImpl {
+    constructor(globalObject, constructorArgs) {
+        const url = constructorArgs[0];
+        const base = constructorArgs[1];
+        let parsedBase = null;
+        if (base !== undefined) {
+            parsedBase = url_state_machine_1.default.basicURLParse(base);
+            if (parsedBase === null) {
+                throw new TypeError(`Invalid base URL: ${base}`);
+            }
+        }
+        const parsedURL = url_state_machine_1.default.basicURLParse(url, { baseURL: parsedBase });
+        if (parsedURL === null) {
+            throw new TypeError(`Invalid URL: ${url}`);
+        }
+        const query = parsedURL.query !== null ? parsedURL.query : "";
+        this._url = parsedURL;
+        // We cannot invoke the "new URLSearchParams object" algorithm without going through the constructor, which strips
+        // question mark by default. Therefore the doNotStripQMark hack is used.
+        this._query = URLSearchParams_1.default.createImpl(globalObject, [query], { doNotStripQMark: true });
+        this._query._url = this;
+    }
+    get href() {
+        return url_state_machine_1.default.serializeURL(this._url);
+    }
+    set href(v) {
+        const parsedURL = url_state_machine_1.default.basicURLParse(v);
+        if (parsedURL === null) {
+            throw new TypeError(`Invalid URL: ${v}`);
+        }
+        this._url = parsedURL;
+        this._query._list.splice(0);
+        const { query } = parsedURL;
+        if (query !== null) {
+            this._query._list = urlencoded_1.default.parseUrlencoded(query);
+        }
+    }
+    get origin() {
+        return url_state_machine_1.default.serializeURLOrigin(this._url);
+    }
+    get protocol() {
+        return this._url.scheme + ":";
+    }
+    set protocol(v) {
+        url_state_machine_1.default.basicURLParse(v + ":", { url: this._url, stateOverride: "scheme start" });
+    }
+    get username() {
+        return this._url.username;
+    }
+    set username(v) {
+        if (url_state_machine_1.default.cannotHaveAUsernamePasswordPort(this._url)) {
+            return;
+        }
+        url_state_machine_1.default.setTheUsername(this._url, v);
+    }
+    get password() {
+        return this._url.password;
+    }
+    set password(v) {
+        if (url_state_machine_1.default.cannotHaveAUsernamePasswordPort(this._url)) {
+            return;
+        }
+        url_state_machine_1.default.setThePassword(this._url, v);
+    }
+    get host() {
+        const url = this._url;
+        if (url.host === null) {
+            return "";
+        }
+        if (url.port === null) {
+            return url_state_machine_1.default.serializeHost(url.host);
+        }
+        return url_state_machine_1.default.serializeHost(url.host) + ":" + url_state_machine_1.default.serializeInteger(url.port);
+    }
+    set host(v) {
+        if (this._url.cannotBeABaseURL) {
+            return;
+        }
+        url_state_machine_1.default.basicURLParse(v, { url: this._url, stateOverride: "host" });
+    }
+    get hostname() {
+        if (this._url.host === null) {
+            return "";
+        }
+        return url_state_machine_1.default.serializeHost(this._url.host);
+    }
+    set hostname(v) {
+        if (this._url.cannotBeABaseURL) {
+            return;
+        }
+        url_state_machine_1.default.basicURLParse(v, { url: this._url, stateOverride: "hostname" });
+    }
+    get port() {
+        if (this._url.port === null) {
+            return "";
+        }
+        return url_state_machine_1.default.serializeInteger(this._url.port);
+    }
+    set port(v) {
+        if (url_state_machine_1.default.cannotHaveAUsernamePasswordPort(this._url)) {
+            return;
+        }
+        if (v === "") {
+            this._url.port = null;
+        }
+        else {
+            url_state_machine_1.default.basicURLParse(v, { url: this._url, stateOverride: "port" });
+        }
+    }
+    get pathname() {
+        if (this._url.cannotBeABaseURL) {
+            return this._url.path[0];
+        }
+        if (this._url.path.length === 0) {
+            return "";
+        }
+        return "/" + this._url.path.join("/");
+    }
+    set pathname(v) {
+        if (this._url.cannotBeABaseURL) {
+            return;
+        }
+        this._url.path = [];
+        url_state_machine_1.default.basicURLParse(v, { url: this._url, stateOverride: "path start" });
+    }
+    get search() {
+        if (this._url.query === null || this._url.query === "") {
+            return "";
+        }
+        return "?" + this._url.query;
+    }
+    set search(v) {
+        const url = this._url;
+        if (v === "") {
+            url.query = null;
+            this._query._list = [];
+            return;
+        }
+        const input = v[0] === "?" ? v.substring(1) : v;
+        url.query = "";
+        url_state_machine_1.default.basicURLParse(input, { url, stateOverride: "query" });
+        this._query._list = urlencoded_1.default.parseUrlencoded(input);
+    }
+    get searchParams() {
+        return this._query;
+    }
+    get hash() {
+        if (this._url.fragment === null || this._url.fragment === "") {
+            return "";
+        }
+        return "#" + this._url.fragment;
+    }
+    set hash(v) {
+        if (v === "") {
+            this._url.fragment = null;
+            return;
+        }
+        const input = v[0] === "#" ? v.substring(1) : v;
+        this._url.fragment = "";
+        url_state_machine_1.default.basicURLParse(input, { url: this._url, stateOverride: "fragment" });
+    }
+    toJSON() {
+        return this.href;
+    }
+};
+exports.default = {
+    implementation
+};

package/lib/utils/url/whatwg-url/lib/URL.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/utils/url/whatwg-url/lib/URL.js

@@ -0,0 +1,298 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+// @ts-nocheck
+const webidl_conversions_1 = tslib_1.__importDefault(require("webidl-conversions"));
+const utils_1 = tslib_1.__importDefault(require("./utils"));
+const impl = utils_1.default.implSymbol;
+const ctorRegistry = utils_1.default.ctorRegistrySymbol;
+const iface = {
+    // When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+    // method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+    // implementing this mixin interface.
+    _mixedIntoPredicates: [],
+    is(obj) {
+        if (obj) {
+            if (utils_1.default.hasOwn(obj, impl) && obj[impl] instanceof URL_impl_1.default.implementation) {
+                return true;
+            }
+            for (const isMixedInto of module.exports._mixedIntoPredicates) {
+                if (isMixedInto(obj)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    },
+    isImpl(obj) {
+        if (obj) {
+            if (obj instanceof URL_impl_1.default.implementation) {
+                return true;
+            }
+            const wrapper = utils_1.default.wrapperForImpl(obj);
+            for (const isMixedInto of module.exports._mixedIntoPredicates) {
+                if (isMixedInto(wrapper)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    },
+    convert(obj, { context = "The provided value" } = {}) {
+        if (module.exports.is(obj)) {
+            return utils_1.default.implForWrapper(obj);
+        }
+        throw new TypeError(`${context} is not of type 'URL'.`);
+    },
+    create(globalObject, constructorArgs, privateData) {
+        if (globalObject[ctorRegistry] === undefined) {
+            throw new Error("Internal error: invalid global object");
+        }
+        const ctor = globalObject[ctorRegistry]["URL"];
+        if (ctor === undefined) {
+            throw new Error("Internal error: constructor URL is not installed on the passed global object");
+        }
+        let obj = Object.create(ctor.prototype);
+        obj = iface.setup(obj, globalObject, constructorArgs, privateData);
+        return obj;
+    },
+    createImpl(globalObject, constructorArgs, privateData) {
+        const obj = iface.create(globalObject, constructorArgs, privateData);
+        return utils_1.default.implForWrapper(obj);
+    },
+    _internalSetup(obj) { },
+    setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+        privateData.wrapper = obj;
+        iface._internalSetup(obj);
+        Object.defineProperty(obj, impl, {
+            value: new URL_impl_1.default.implementation(globalObject, constructorArgs, privateData),
+            configurable: true
+        });
+        obj[impl][utils_1.default.wrapperSymbol] = obj;
+        if (URL_impl_1.default.init) {
+            URL_impl_1.default.init(obj[impl], privateData);
+        }
+        return obj;
+    },
+    install(globalObject) {
+        class URL {
+            constructor(url) {
+                if (arguments.length < 1) {
+                    throw new TypeError("Failed to construct 'URL': 1 argument required, but only " + arguments.length + " present.");
+                }
+                const args = [];
+                {
+                    let curArg = arguments[0];
+                    curArg = webidl_conversions_1.default["USVString"](curArg, { context: "Failed to construct 'URL': parameter 1" });
+                    args.push(curArg);
+                }
+                {
+                    let curArg = arguments[1];
+                    if (curArg !== undefined) {
+                        curArg = webidl_conversions_1.default["USVString"](curArg, { context: "Failed to construct 'URL': parameter 2" });
+                    }
+                    args.push(curArg);
+                }
+                return iface.setup(Object.create(this.constructor.prototype), globalObject, args);
+            }
+            toJSON() {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError("Illegal invocation");
+                }
+                return this[impl].toJSON();
+            }
+            get href() {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError("Illegal invocation");
+                }
+                return this[impl]["href"];
+            }
+            set href(V) {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError("Illegal invocation");
+                }
+                V = webidl_conversions_1.default["USVString"](V, { context: "Failed to set the 'href' property on 'URL': The provided value" });
+                this[impl]["href"] = V;
+            }
+            toString() {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError("Illegal invocation");
+                }
+                return this[impl]["href"];
+            }
+            get origin() {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError("Illegal invocation");
+                }
+                return this[impl]["origin"];
+            }
+            get protocol() {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError("Illegal invocation");
+                }
+                return this[impl]["protocol"];
+            }
+            set protocol(V) {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError("Illegal invocation");
+                }
+                V = webidl_conversions_1.default["USVString"](V, {
+                    context: "Failed to set the 'protocol' property on 'URL': The provided value"
+                });
+                this[impl]["protocol"] = V;
+            }
+            get username() {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError("Illegal invocation");
+                }
+                return this[impl]["username"];
+            }
+            set username(V) {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError("Illegal invocation");
+                }
+                V = webidl_conversions_1.default["USVString"](V, {
+                    context: "Failed to set the 'username' property on 'URL': The provided value"
+                });
+                this[impl]["username"] = V;
+            }
+            get password() {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError("Illegal invocation");
+                }
+                return this[impl]["password"];
+            }
+            set password(V) {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError("Illegal invocation");
+                }
+                V = webidl_conversions_1.default["USVString"](V, {
+                    context: "Failed to set the 'password' property on 'URL': The provided value"
+                });
+                this[impl]["password"] = V;
+            }
+            get host() {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError("Illegal invocation");
+                }
+                return this[impl]["host"];
+            }
+            set host(V) {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError("Illegal invocation");
+                }
+                V = webidl_conversions_1.default["USVString"](V, { context: "Failed to set the 'host' property on 'URL': The provided value" });
+                this[impl]["host"] = V;
+            }
+            get hostname() {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError("Illegal invocation");
+                }
+                return this[impl]["hostname"];
+            }
+            set hostname(V) {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError("Illegal invocation");
+                }
+                V = webidl_conversions_1.default["USVString"](V, {
+                    context: "Failed to set the 'hostname' property on 'URL': The provided value"
+                });
+                this[impl]["hostname"] = V;
+            }
+            get port() {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError("Illegal invocation");
+                }
+                return this[impl]["port"];
+            }
+            set port(V) {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError("Illegal invocation");
+                }
+                V = webidl_conversions_1.default["USVString"](V, { context: "Failed to set the 'port' property on 'URL': The provided value" });
+                this[impl]["port"] = V;
+            }
+            get pathname() {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError("Illegal invocation");
+                }
+                return this[impl]["pathname"];
+            }
+            set pathname(V) {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError("Illegal invocation");
+                }
+                V = webidl_conversions_1.default["USVString"](V, {
+                    context: "Failed to set the 'pathname' property on 'URL': The provided value"
+                });
+                this[impl]["pathname"] = V;
+            }
+            get search() {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError("Illegal invocation");
+                }
+                return this[impl]["search"];
+            }
+            set search(V) {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError("Illegal invocation");
+                }
+                V = webidl_conversions_1.default["USVString"](V, {
+                    context: "Failed to set the 'search' property on 'URL': The provided value"
+                });
+                this[impl]["search"] = V;
+            }
+            get searchParams() {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError("Illegal invocation");
+                }
+                return utils_1.default.getSameObject(this, "searchParams", () => {
+                    return utils_1.default.tryWrapperForImpl(this[impl]["searchParams"]);
+                });
+            }
+            get hash() {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError("Illegal invocation");
+                }
+                return this[impl]["hash"];
+            }
+            set hash(V) {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError("Illegal invocation");
+                }
+                V = webidl_conversions_1.default["USVString"](V, { context: "Failed to set the 'hash' property on 'URL': The provided value" });
+                this[impl]["hash"] = V;
+            }
+        }
+        Object.defineProperties(URL.prototype, {
+            toJSON: { enumerable: true },
+            href: { enumerable: true },
+            toString: { enumerable: true },
+            origin: { enumerable: true },
+            protocol: { enumerable: true },
+            username: { enumerable: true },
+            password: { enumerable: true },
+            host: { enumerable: true },
+            hostname: { enumerable: true },
+            port: { enumerable: true },
+            pathname: { enumerable: true },
+            search: { enumerable: true },
+            searchParams: { enumerable: true },
+            hash: { enumerable: true },
+            [Symbol.toStringTag]: { value: "URL", configurable: true }
+        });
+        if (globalObject[ctorRegistry] === undefined) {
+            globalObject[ctorRegistry] = Object.create(null);
+        }
+        globalObject[ctorRegistry]["URL"] = URL;
+        Object.defineProperty(globalObject, "URL", {
+            configurable: true,
+            writable: true,
+            value: URL
+        });
+    }
+};
+// iface
+module.exports = iface;
+// const Impl = require('./URL-impl');
+const URL_impl_1 = tslib_1.__importDefault(require("./URL-impl"));

package/lib/utils/url/whatwg-url/lib/URLSearchParams-impl.d.ts

@@ -0,0 +1,19 @@
+declare const _default: {
+    implementation: {
+        new (globalObject: any, constructorArgs: any, { doNotStripQMark }: {
+            doNotStripQMark?: boolean | undefined;
+        }): {
+            _updateSteps(): void;
+            append(name: any, value: any): void;
+            delete(name: any): void;
+            get(name: any): any;
+            getAll(name: any): any[];
+            has(name: any): boolean;
+            set(name: any, value: any): void;
+            sort(): void;
+            toString(): string;
+            [Symbol.iterator](): any;
+        };
+    };
+};
+export default _default;