5267614267

pending completion

Build # 5267614267

Build Type

push

github

Committed by

jumpinjackie

Commit Message

#1418: Revert "Remove usage of qs and url-parse modules with URL and URLSearchParams which now that we've dropped IE support can be assured to be supported by all browsers."

The URL class is so half-baked with its inability to handle relative URLs that going back to qs and url-parse is worth the small overhead.

This reverts commit d9acacc53.

# Conflicts:
#	package.json

Run Details

886 of 1904 branches covered (46.53%)

20 of 20 new or added lines in 1 file covered. (100.0%)

2524 of 3929 relevant lines covered (64.24%)

21.18 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

85.21

/src/utils/url.ts

import queryString from "qs";
import type { IInvokeUrlCommandParameter } from "../api/common";
import { strIsNullOrEmpty } from './string';
const parse = require("url-parse");

const DEFAULT_PARSE_OPTIONS = { ignoreQueryPrefix: true };

/**
 * Indicates if the given arrays are equal
 *
 * @param {(string[]|null)} a
 * @param {(string[]|null)} b
 * @returns {boolean}
 */
function arraysEqual(a: string[] | null, b: string[] | null): boolean {
    if (a === b) return true;
    if (a == null || b == null) return false;
    if (a.length != b.length) return false;

    // If you don't care about the order of the elements inside
    // the array, you should sort both arrays here.

    for (let i = 0; i < a.length; ++i) {
        if (a[i] !== b[i]) {
            return false;
        }
    }
    return true;
}

/**
 * Indicates if the given sets of parameterse are the same
 *
 * @param {*} params1
 * @param {*} params2
 * @returns {boolean}
 */
function areParamsEqual(params1: any, params2: any): boolean {
    //HACK: locale is an optional part of the mapname/session/locale triplet
    //For the purpose of the same url test, the presence (or lack thereof) of
    //this parameter should not break the url equality test
    const keys1 = Object.keys(params1).filter(k => k.toLowerCase() != "locale").sort();
    const keys2 = Object.keys(params2).filter(k => k.toLowerCase() != "locale").sort();
    if (arraysEqual(keys1, keys2)) {
        for (const key of keys1) {
            if (params1[key] != params2[key]) {
                return false;
            }
        }
        return true;
    }
    return false;
}

/**
 * Indicates if the given URLs are the same
 *
 * @export
 * @param {string} url1
 * @param {string} url2
 * @returns {boolean}
 */
export function areUrlsSame(url1: string, url2: string): boolean {
    const parsed1 = parse(url1);
    const parsed2 = parse(url2);
    const params1 = queryString.parse(parsed1.query, DEFAULT_PARSE_OPTIONS);
    const params2 = queryString.parse(parsed2.query, DEFAULT_PARSE_OPTIONS);

    const same = parsed1.protocol == parsed2.protocol
        && parsed1.slashes == parsed2.slashes
        && parsed1.auth == parsed2.auth
        && parsed1.username == parsed2.username
        && parsed1.password == parsed2.password
        && parsed1.host == parsed2.host
        && parsed1.hostname == parsed2.hostname
        && parsed1.port == parsed2.port
        && parsed1.pathname == parsed2.pathname
        && parsed1.hash == parsed2.hash
        && parsed1.host == parsed2.host
        && areParamsEqual(params1, params2);

    return same;
}

/**
 * A parsed component URI
 * 
 * @export
 * @interface ParsedComponentUri
 */
export interface ParsedComponentUri {
    name: string;
    props: any;
}

/**
 * Indicates if the given URI is a component URI
 * 
 * @export
 * @param {string} uri 
 * @returns {boolean} 
 */
export function isComponentUri(uri: string): boolean {
    return uri.indexOf("component://") >= 0;
}

/**
 * Parses the given component URI. If it not a valid component URI returns undefined
 * 
 * @export
 * @param {string} uri 
 * @returns {(ParsedComponentUri | undefined)} 
 */
export function parseComponentUri(uri: string): ParsedComponentUri | undefined {
    if (isComponentUri(uri)) {
        const qi = uri.lastIndexOf("?");
        const name = qi < 0 ? uri.substring(12) : uri.substring(12, qi);
        const props = qi < 0 ? {} : queryString.parse(uri.substring(qi), DEFAULT_PARSE_OPTIONS);
        return {
            name,
            props
        };
    }
}

/**
 * Normalizes the given URL to ensure it has the baseline set of required parameters for invoking any server-side script that uses the MapGuide Web API
 * 
 * @export
 * @param {string} url The url to normalize
 * @param {(string | undefined)} mapName The name of the current runtime map
 * @param {(string | undefined)} session The current session id
 * @param {string} [locale] An optional locale
 * @param {boolean} [uppercase=true] If true, will uppercase all parameter names
 * @param {IInvokeUrlCommandParameter[]} [extraParameters=[]] Any extra parameters to append to the URL
 * @returns {string} 
 */
export function ensureParameters(url: string, mapName: string | undefined, session: string | undefined, locale?: string, uppercase = true, extraParameters: IInvokeUrlCommandParameter[] = []): string {
    //If this is a component URL, let it be
    if (isComponentUri(url)) {
        return url;
    }
    const parsed = parseUrl(url);
    const params: any = parsed.query != null ? queryString.parse(parsed.query, DEFAULT_PARSE_OPTIONS) : {};
    let bNeedMapName = true;
    let bNeedSession = true;
    let bNeedLocale = true;
    for (const key in params) {
        const name = key.toLowerCase();
        switch (name) {
            case "session":
                bNeedSession = false;
                break;
            case "mapname":
                bNeedMapName = false;
                break;
            case "locale":
                bNeedLocale = false;
                break;
        }
    }
    if (bNeedMapName && !strIsNullOrEmpty(mapName)) {
        if (uppercase) {
            params.MAPNAME = mapName;
        } else {
            params.mapname = mapName;
        }
    }
    if (bNeedSession && !strIsNullOrEmpty(session)) {
        if (uppercase) {
            params.SESSION = session;
        } else {
            params.session = session;
        }
    }
    if (bNeedLocale) {
        if (uppercase) {
            params.LOCALE = locale;
        } else {
            params.locale = locale;
        }
    }

    for (const p of extraParameters) {
        params[p.name] = p.value;
    }

    /*
    parsed.query = queryString.stringify(params);
    const result = parsed.toString();

    if (url.indexOf(parsed.protocol) >= 0 || url.indexOf("/") == 0) {
        return result;
    }

    return result;
    */
    //Don't uppercase the parameters here if true, uppercasing is only for filling in
    //missing parameters
    return appendParameters(url, params, true, false /*uppercase*/);
}

/**
 * Represents a parsed URL with query string separated
 *
 * @export
 * @interface IParsedUrl
 * @since 0.12
 */
export interface IParsedUrl {
    url: string;
    query: any;
}

/**
 * Parses the given URL and separates out the query string parameters
 *
 * @export
 * @param {string} url The URL to parse
 * @returns {IParsedUrl}
 * @since 0.12
 */
export function parseUrl(url: string): IParsedUrl {
    //return queryString.parseUrl(url);
    const qi = url.lastIndexOf("?");
    const parsedUrl = qi < 0 ? url : url.substring(0, qi);
    const query = qi < 0 ? {} : queryString.parse(url.substring(qi), DEFAULT_PARSE_OPTIONS);
    return {
        url: parsedUrl,
        query
    };
}

/**
 * Converts the given object to a query string fragment
 *
 * @export
 * @param {*} parameters The object to stringify
 * @returns {string} The query string fragment
 */
export function stringifyQuery(parameters: any): string {
    return queryString.stringify(parameters);
}

/**
 * Appends the specified parameters to the given URL
 *
 * @export
 * @param {string} url The URL to append parameters to
 * @param {*} parameters The parameters to append
 * @param {boolean} [bOverwriteExisting=true] If true, will overwrite any existing parameters if the URL already has them
 * @param {boolean} [bConvertToUppercase=false] If true, will ensure all parameter names are uppercase
 * @param {boolean} [bDiscardExistingParams=false] If true, will discard existing query string params before appending
 * @since 0.12
 */
export function appendParameters(url: string, parameters: any, bOverwriteExisting: boolean = true, bConvertToUppercase: boolean = false, bDiscardExistingParams: boolean = false) {
    const parsed = parse(url);
    let currentParams: any;
    if (!bDiscardExistingParams) {
        currentParams = parsed.query != null ? queryString.parse(parsed.query, DEFAULT_PARSE_OPTIONS) : {};
    } else {
        currentParams = {};
    }

    const paramNames: any = {};
    for (const key in currentParams) {
        paramNames[key.toUpperCase()] = key;
    }

    for (const name in parameters) {
        //See if this parameter name was normalized
        const key = paramNames[name.toUpperCase()] || name;
        //If it was and we've got an existing value there, skip if not overwriting
        if (key && currentParams[key] && !bOverwriteExisting) {
            continue;
        }
        //Put the parameter value
        currentParams[key] = parameters[name];
    }

    if (bConvertToUppercase) {
        let params2: any = {};
        for (const name in currentParams) {
            params2[name.toUpperCase()] = currentParams[name];
        }
        currentParams = params2;
    }

    parsed.query = queryString.stringify(currentParams);
    const result = parsed.toString();

    if (url.indexOf(parsed.protocol) >= 0 || url.indexOf("/") == 0) {
        return result;
    }

    return result;
}

/**
 * Parses the query string section of the given URL and returns the parsed
 * parameters as an object
 * @param url The URL to parse
 * @since 0.13
 */
export function parseUrlParameters(url: string): any {
    const parsed = parse(url);
    const currentParams: any = parsed.query != null ? queryString.parse(parsed.query, DEFAULT_PARSE_OPTIONS) : {};
    return currentParams;
}

1	import queryString from "qs";	3✔
2	import type { IInvokeUrlCommandParameter } from "../api/common";
3	import { strIsNullOrEmpty } from './string';	3✔
4	const parse = require("url-parse");	3✔
5
6	const DEFAULT_PARSE_OPTIONS = { ignoreQueryPrefix: true };	3✔
7
8	/**
9	* Indicates if the given arrays are equal
10	*
11	* @param {(string[]\|null)} a
12	* @param {(string[]\|null)} b
13	* @returns {boolean}
14	*/
15	function arraysEqual(a: string[] \| null, b: string[] \| null): boolean {
16	if (a === b) return true;	3!
17	if (a == null \|\| b == null) return false;	3!
18	if (a.length != b.length) return false;	3!
19
20	// If you don't care about the order of the elements inside
21	// the array, you should sort both arrays here.
22
23	for (let i = 0; i < a.length; ++i) {	3✔
24	if (a[i] !== b[i]) {	4!
25	return false;	×
26	}
27	}
28	return true;	3✔
29	}
30
31	/**
32	* Indicates if the given sets of parameterse are the same
33	*
34	* @param {*} params1
35	* @param {*} params2
36	* @returns {boolean}
37	*/
38	function areParamsEqual(params1: any, params2: any): boolean {
39	//HACK: locale is an optional part of the mapname/session/locale triplet
40	//For the purpose of the same url test, the presence (or lack thereof) of
41	//this parameter should not break the url equality test
42	const keys1 = Object.keys(params1).filter(k => k.toLowerCase() != "locale").sort();	4✔
43	const keys2 = Object.keys(params2).filter(k => k.toLowerCase() != "locale").sort();	5✔
44	if (arraysEqual(keys1, keys2)) {	3✔
45	for (const key of keys1) {	6✔
46	if (params1[key] != params2[key]) {	3✔
47	return false;	1✔
48	}
49	}
50	return true;	2✔
51	}
52	return false;	×
53	}
54
55	/**
56	* Indicates if the given URLs are the same
57	*
58	* @export
59	* @param {string} url1
60	* @param {string} url2
61	* @returns {boolean}
62	*/
63	export function areUrlsSame(url1: string, url2: string): boolean {	3✔
64	const parsed1 = parse(url1);	5✔
65	const parsed2 = parse(url2);	5✔
66	const params1 = queryString.parse(parsed1.query, DEFAULT_PARSE_OPTIONS);	5✔
67	const params2 = queryString.parse(parsed2.query, DEFAULT_PARSE_OPTIONS);	5✔
68
69	const same = parsed1.protocol == parsed2.protocol	5✔
70	&& parsed1.slashes == parsed2.slashes
71	&& parsed1.auth == parsed2.auth
72	&& parsed1.username == parsed2.username
73	&& parsed1.password == parsed2.password
74	&& parsed1.host == parsed2.host
75	&& parsed1.hostname == parsed2.hostname
76	&& parsed1.port == parsed2.port
77	&& parsed1.pathname == parsed2.pathname
78	&& parsed1.hash == parsed2.hash
79	&& parsed1.host == parsed2.host
80	&& areParamsEqual(params1, params2);
81
82	return same;	5✔
83	}
84
85	/**
86	* A parsed component URI
87	*
88	* @export
89	* @interface ParsedComponentUri
90	*/
91	export interface ParsedComponentUri {
92	name: string;
93	props: any;
94	}
95
96	/**
97	* Indicates if the given URI is a component URI
98	*
99	* @export
100	* @param {string} uri
101	* @returns {boolean}
102	*/
103	export function isComponentUri(uri: string): boolean {	3✔
104	return uri.indexOf("component://") >= 0;	16✔
105	}
106
107	/**
108	* Parses the given component URI. If it not a valid component URI returns undefined
109	*
110	* @export
111	* @param {string} uri
112	* @returns {(ParsedComponentUri \| undefined)}
113	*/
114	export function parseComponentUri(uri: string): ParsedComponentUri \| undefined {	3✔
115	if (isComponentUri(uri)) {	4✔
116	const qi = uri.lastIndexOf("?");	3✔
117	const name = qi < 0 ? uri.substring(12) : uri.substring(12, qi);	3✔
118	const props = qi < 0 ? {} : queryString.parse(uri.substring(qi), DEFAULT_PARSE_OPTIONS);	3✔
119	return {	3✔
120	name,
121	props
122	};
123	}
124	}
125
126	/**
127	* Normalizes the given URL to ensure it has the baseline set of required parameters for invoking any server-side script that uses the MapGuide Web API
128	*
129	* @export
130	* @param {string} url The url to normalize
131	* @param {(string \| undefined)} mapName The name of the current runtime map
132	* @param {(string \| undefined)} session The current session id
133	* @param {string} [locale] An optional locale
134	* @param {boolean} [uppercase=true] If true, will uppercase all parameter names
135	* @param {IInvokeUrlCommandParameter[]} [extraParameters=[]] Any extra parameters to append to the URL
136	* @returns {string}
137	*/
138	export function ensureParameters(url: string, mapName: string \| undefined, session: string \| undefined, locale?: string, uppercase = true, extraParameters: IInvokeUrlCommandParameter[] = []): string {	18✔
139	//If this is a component URL, let it be
140	if (isComponentUri(url)) {	9✔
141	return url;	1✔
142	}
143	const parsed = parseUrl(url);	8✔
144	const params: any = parsed.query != null ? queryString.parse(parsed.query, DEFAULT_PARSE_OPTIONS) : {};	8!
145	let bNeedMapName = true;	8✔
146	let bNeedSession = true;	8✔
147	let bNeedLocale = true;	8✔
148	for (const key in params) {	8✔
149	const name = key.toLowerCase();	12✔
150	switch (name) {	12✔
151	case "session":
152	bNeedSession = false;	4✔
153	break;	4✔
154	case "mapname":
155	bNeedMapName = false;	6✔
156	break;	6✔
157	case "locale":
158	bNeedLocale = false;	2✔
159	break;	2✔
160	}
161	}
162	if (bNeedMapName && !strIsNullOrEmpty(mapName)) {	8✔
163	if (uppercase) {	2!
164	params.MAPNAME = mapName;	2✔
165	} else {
166	params.mapname = mapName;	×
167	}
168	}
169	if (bNeedSession && !strIsNullOrEmpty(session)) {	8✔
170	if (uppercase) {	4!
171	params.SESSION = session;	4✔
172	} else {
173	params.session = session;	×
174	}
175	}
176	if (bNeedLocale) {	8✔
177	if (uppercase) {	6!
178	params.LOCALE = locale;	6✔
179	} else {
180	params.locale = locale;	×
181	}
182	}
183
184	for (const p of extraParameters) {	16✔
185	params[p.name] = p.value;	×
186	}
187
188	/*
189	parsed.query = queryString.stringify(params);
190	const result = parsed.toString();
191
192	if (url.indexOf(parsed.protocol) >= 0 \|\| url.indexOf("/") == 0) {
193	return result;
194	}
195
196	return result;
197	*/
198	//Don't uppercase the parameters here if true, uppercasing is only for filling in
199	//missing parameters
200	return appendParameters(url, params, true, false /uppercase/);	8✔
201	}
202
203	/**
204	* Represents a parsed URL with query string separated
205	*
206	* @export
207	* @interface IParsedUrl
208	* @since 0.12
209	*/
210	export interface IParsedUrl {
211	url: string;
212	query: any;
213	}
214
215	/**
216	* Parses the given URL and separates out the query string parameters
217	*
218	* @export
219	* @param {string} url The URL to parse
220	* @returns {IParsedUrl}
221	* @since 0.12
222	*/
223	export function parseUrl(url: string): IParsedUrl {	3✔
224	//return queryString.parseUrl(url);
225	const qi = url.lastIndexOf("?");	11✔
226	const parsedUrl = qi < 0 ? url : url.substring(0, qi);	11✔
227	const query = qi < 0 ? {} : queryString.parse(url.substring(qi), DEFAULT_PARSE_OPTIONS);	11✔
228	return {	11✔
229	url: parsedUrl,
230	query
231	};
232	}
233
234	/**
235	* Converts the given object to a query string fragment
236	*
237	* @export
238	* @param {*} parameters The object to stringify
239	* @returns {string} The query string fragment
240	*/
241	export function stringifyQuery(parameters: any): string {	3✔
242	return queryString.stringify(parameters);	×
243	}
244
245	/**
246	* Appends the specified parameters to the given URL
247	*
248	* @export
249	* @param {string} url The URL to append parameters to
250	* @param {*} parameters The parameters to append
251	* @param {boolean} [bOverwriteExisting=true] If true, will overwrite any existing parameters if the URL already has them
252	* @param {boolean} [bConvertToUppercase=false] If true, will ensure all parameter names are uppercase
253	* @param {boolean} [bDiscardExistingParams=false] If true, will discard existing query string params before appending
254	* @since 0.12
255	*/
256	export function appendParameters(url: string, parameters: any, bOverwriteExisting: boolean = true, bConvertToUppercase: boolean = false, bDiscardExistingParams: boolean = false) {	44✔
257	const parsed = parse(url);	22✔
258	let currentParams: any;
259	if (!bDiscardExistingParams) {	22!
260	currentParams = parsed.query != null ? queryString.parse(parsed.query, DEFAULT_PARSE_OPTIONS) : {};	22!
261	} else {
262	currentParams = {};	×
263	}
264
265	const paramNames: any = {};	22✔
266	for (const key in currentParams) {	22✔
267	paramNames[key.toUpperCase()] = key;	20✔
268	}
269
270	for (const name in parameters) {	22✔
271	//See if this parameter name was normalized
272	const key = paramNames[name.toUpperCase()] \|\| name;	38✔
273	//If it was and we've got an existing value there, skip if not overwriting
274	if (key && currentParams[key] && !bOverwriteExisting) {	38✔
275	continue;	4✔
276	}
277	//Put the parameter value
278	currentParams[key] = parameters[name];	34✔
279	}
280
281	if (bConvertToUppercase) {	22✔
282	let params2: any = {};	6✔
283	for (const name in currentParams) {	6✔
284	params2[name.toUpperCase()] = currentParams[name];	6✔
285	}
286	currentParams = params2;	6✔
287	}
288
289	parsed.query = queryString.stringify(currentParams);	22✔
290	const result = parsed.toString();	22✔
291
292	if (url.indexOf(parsed.protocol) >= 0 \|\| url.indexOf("/") == 0) {	22!
293	return result;	22✔
294	}
295
296	return result;	×
297	}
298
299	/**
300	* Parses the query string section of the given URL and returns the parsed
301	* parameters as an object
302	* @param url The URL to parse
303	* @since 0.13
304	*/
305	export function parseUrlParameters(url: string): any {	3✔
306	const parsed = parse(url);	×
307	const currentParams: any = parsed.query != null ? queryString.parse(parsed.query, DEFAULT_PARSE_OPTIONS) : {};	×
308	return currentParams;	×
309	}

jumpinjackie / mapguide-react-layout / 5267614267

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous