@speedkit/cli 2.4.1

package/dist/helpers/build-query-helper.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStrippedParams = exports.getParameterReplaceFilter = exports.getParameterFilter = exports.getBlacklistedFilter = exports.getWhitelistedFilter = void 0;
+/**
+ * Returns the string between a left bound and a right bound.
+ *
+ * @param input - The input string to get the inner string from.
+ * @param leftBound - The left bound of the string to be cut.
+ * @param rightBound - The right bound of the string to be cut.
+ */
+function getStringBetween(input, leftBound, rightBound) {
+    return input.slice(input.indexOf(leftBound) + 1, input.lastIndexOf(rightBound));
+}
+/**
+ * Returns the comparison filter (like, regexp_like) as a SQL query string.
+ *
+ * @param property - The property to be compared
+ * @param sqlField -The SQL field to compare with.
+ * @param shouldEqual - True if the property should equal the sql value, false otherwise.
+ * @param type - Whether type of property is a pathname or url.
+ */
+function getFilterForProperty(property, sqlField, shouldEqual, type) {
+    if (typeof property === 'string') {
+        if (type === 'pathname') {
+            return `url_extract_path(${sqlField}) ${shouldEqual ? '' : 'not '}like '${property}%'`;
+        }
+        return `${sqlField} ${shouldEqual ? '' : 'not '}like 'https://${property}%'`;
+    }
+    const ignoreCase = isRegExpIgnoringCase(property);
+    const sqlRegExp = getStringBetween(String(property), '/', '/');
+    if (type === 'pathname') {
+        return `${shouldEqual ? '' : 'not '}regexp_like(url_extract_path(${sqlField}), '${ignoreCase ? '(?i)' : ''}${sqlRegExp}')`;
+    }
+    return `${shouldEqual ? '' : 'not '}regexp_like(${sqlField}, '${ignoreCase ? '(?i)' : ''}${sqlRegExp}')`;
+}
+/**
+ * Returns all properties of a speed kit rule with the given keys.
+ *
+ * @param speedKitRuleValues - The speed kit rule value to get the properties from (e.g. the whitelist).
+ * @param key - The key to get the properties with (e.g. 'pathname').
+ */
+function getRuleProp(speedKitRuleValues, key) {
+    const properties = [];
+    if (!speedKitRuleValues) {
+        return properties;
+    }
+    for (const ruleValue of speedKitRuleValues) {
+        Object.keys(ruleValue)
+            .filter(ruleKey => key === ruleKey)
+            .forEach(ruleKey => properties.push(...ruleValue[ruleKey]));
+    }
+    return properties;
+}
+/**
+ * Returns the whitelisted filter as a sql query string.
+ *
+ * @param parsedConfig - The speed kit config parsed as an object.
+ */
+function getWhitelistedFilter(parsedConfig) {
+    const { whitelist, enabledSites } = parsedConfig;
+    // TODO: use origins instead here
+    const whitelistedFilter = `(\n    ${(whitelist[0].host || whitelist[0].url).map(hostname => getFilterForProperty(hostname, 'url', true, 'url')).join('\n    or ')}\n  )`;
+    const enabledFilter = getRuleProp(enabledSites, 'pathname')
+        .map(pathname => getFilterForProperty(pathname, 'url', true, 'pathname')).join('\nor ');
+    if (!enabledFilter) {
+        return `${whitelistedFilter}`;
+    }
+    return `(${whitelistedFilter}) and (${enabledFilter})`;
+}
+exports.getWhitelistedFilter = getWhitelistedFilter;
+/**
+ * Returns the blacklisted filter as a SQL query string.
+ *
+ * @param parsedConfig - The speed kit config parsed as an object.
+ */
+function getBlacklistedFilter(parsedConfig) {
+    const { blacklist, disabledSites } = parsedConfig;
+    const blacklistedPathnamesFilter = getRuleProp(blacklist, 'pathname')
+        .map(pathname => getFilterForProperty(pathname, 'url', false, 'pathname')).join('\n  and ');
+    const blacklistedUrlsFilter = getRuleProp(blacklist, 'url')
+        .map(url => getFilterForProperty(url, 'url', false, 'url')).join('\n  and ');
+    const disabledFilter = getRuleProp(disabledSites, 'pathname')
+        .map(pathname => getFilterForProperty(pathname, 'url', false, 'pathname')).join('\n  and ');
+    let blacklistedFilter = '';
+    if (blacklistedPathnamesFilter) {
+        blacklistedFilter += blacklistedPathnamesFilter;
+    }
+    if (blacklistedUrlsFilter) {
+        blacklistedFilter += `\n and ${blacklistedUrlsFilter}`;
+    }
+    if (disabledFilter) {
+        blacklistedFilter += `\n and ${disabledFilter}`;
+    }
+    return blacklistedFilter;
+}
+exports.getBlacklistedFilter = getBlacklistedFilter;
+/**
+ * Returns the parameter filter as a SQL query string.
+ *
+ * @param params - The stripped parameters that are named within the speed kit config.
+ * @param skConfigVersion - The Speed Kit config ruleset version.
+ */
+function getParameterFilter(params, skConfigVersion = 1) {
+    return params.map(param => {
+        // Prefix comparison for strings
+        if (typeof param === 'string') {
+            if (skConfigVersion === 1) {
+                return `not regexp_like(key, '^${param}')`;
+            }
+            else {
+                return `key <> '${param}'`;
+            }
+        }
+        // Regexp like for complex regular expressions
+        const ignoreCase = isRegExpIgnoringCase(param);
+        return `not regexp_like(key, '${ignoreCase ? '(?i)' : ''}${getStringBetween(String(param), '/', '/')}')`;
+    }).join('\nand ');
+}
+exports.getParameterFilter = getParameterFilter;
+/**
+ * Returns the parameter replace (regexp_replace) as a SQL query string.
+ *
+ * @param params - The stripped parameters that are named within the speed kit config.
+ * @param skConfigVersion - The Speed Kit config ruleset version.
+ */
+function getParameterReplaceFilter(params, skConfigVersion = 1) {
+    const prefixParams = [];
+    const suffixParams = [];
+    const fullMatchParams = [];
+    const prefixIgnoreCaseParams = [];
+    const suffixIgnoreCaseParams = [];
+    const fullMatchIgnoreCaseParams = [];
+    params.forEach(param => {
+        // String params or regex params with start marker but no end marker
+        if (typeof param === 'string') {
+            if (skConfigVersion === 1) {
+                return prefixParams.push(param);
+            }
+            else {
+                return fullMatchParams.push(param);
+            }
+        }
+        const ignoreCase = isRegExpIgnoringCase(param);
+        // Regex params with start marker but no end marker
+        if (/\/\^[^$]+$/.test(String(param))) {
+            return (ignoreCase ? prefixIgnoreCaseParams : prefixParams).push(getStringBetween(String(param), '^', '/'));
+        }
+        // Regex params with end marker but no start marker
+        if (/\/[^^$]+\$/.test(String(param))) {
+            return (ignoreCase ? suffixIgnoreCaseParams : suffixParams).push(getStringBetween(String(param), '/', '$'));
+        }
+        // Regex params with start marker and end marker
+        if (/\/\^[^$]+\$\//.test(String(param))) {
+            return (ignoreCase ? fullMatchIgnoreCaseParams : fullMatchParams).push(getStringBetween(String(param), '^', '$'));
+        }
+        // Regex params with no start marker and no end marker are being considered full matches
+        (ignoreCase ? fullMatchIgnoreCaseParams : fullMatchParams).push(getStringBetween(String(param), '/', '/'));
+    });
+    let regExpQuery = "regexp_replace(url, '#.*' )";
+    const regExps = [
+        getParamPrefixRegExp(prefixParams, false),
+        getParamPrefixRegExp(prefixIgnoreCaseParams, true),
+        getParamSuffixRegExp(suffixParams, false),
+        getParamSuffixRegExp(suffixIgnoreCaseParams, true),
+        getParamFullMatchRegExp(fullMatchParams, false),
+        getParamFullMatchRegExp(fullMatchIgnoreCaseParams, true),
+    ];
+    // Nest all regexes inside each other:
+    regExps.forEach(regExp => {
+        if (regExp) {
+            regExpQuery = `regexp_replace(${regExpQuery}, '${regExp}', '')`;
+        }
+    });
+    return regExpQuery;
+}
+exports.getParameterReplaceFilter = getParameterReplaceFilter;
+function isRegExpIgnoringCase(regExp) {
+    return /\/i$/.test(String(regExp));
+}
+function getParamPrefixRegExp(params, ignoreCase) {
+    return params.length > 0 ? `${ignoreCase ? '(?i)' : ''}[?&](${params.join('|')})[^&]*` : null;
+}
+function getParamSuffixRegExp(params, ignoreCase) {
+    return params.length > 0 ? `${ignoreCase ? '(?i)' : ''}[?&][^&]*(${params.join('|')})(=[^&]*)?(?=&|$)` : null;
+}
+function getParamFullMatchRegExp(params, ignoreCase) {
+    return params.length > 0 ? `${ignoreCase ? '(?i)' : ''}[?&](${params.join('|')})(=[^&]*)?(?=&|$)` : null;
+}
+/**
+ * Returns the stripped parameters that are named within the speed kit config.
+ *
+ * @param parsedConfig - The speed kit config parsed as an object.
+ */
+function getStrippedParams(parsedConfig) {
+    const paramArray = parsedConfig.stripQueryParams;
+    if (!paramArray) {
+        return [];
+    }
+    const isSimpleArray = paramArray.every((param) => typeof param === 'string' || param instanceof RegExp);
+    if (isSimpleArray) {
+        return paramArray;
+    }
+    const params = [];
+    for (const entry of paramArray) {
+        if (!entry.params) {
+            continue;
+        }
+        if (!Array.isArray(entry.params)) {
+            params.push(entry.params);
+            continue;
+        }
+        params.push(...entry.params);
+    }
+    return params;
+}
+exports.getStrippedParams = getStrippedParams;

package/dist/helpers/cli-config.d.ts

@@ -0,0 +1,22 @@
+import { Config } from "@oclif/core/lib/config";
+export type UserCliConfig = {
+    chromePath: string;
+    chromeUserProfilePath: string;
+    slackToken: string;
+    speedKitBrowserExtensionPath: string;
+    testApp: string;
+    ideaDirectory: string;
+    diffExec: string;
+    diffExecTemplate: string;
+};
+export declare class CliConfig {
+    private config;
+    private userCliConfig;
+    constructor(config: Config);
+    load(): UserCliConfig;
+    private loadConfigFromEnvironment;
+    private getConfigFilePath;
+    private loadConfigFromConfigFile;
+    private createEmptyConfigFile;
+    private createEmptyUserConfig;
+}

package/dist/helpers/cli-config.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliConfig = void 0;
+const tslib_1 = require("tslib");
+const dotenv = tslib_1.__importStar(require("dotenv"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+dotenv.config();
+const envMapping = {
+    chromePath: "CHROME_PATH",
+    chromeUserProfilePath: "CHROME_USER_PROFILE_PATH",
+    slackToken: "SLACK_TOKEN",
+    speedKitBrowserExtensionPath: "SPEED_KIT_EXTENSION_PATH",
+    testApp: "TEST_APP",
+    ideaDirectory: "IDEA_INITIAL_DIRECTORY",
+    diffExec: "DIFF_EXEC",
+    diffExecTemplate: "DIFF_EXEC_TEMPLATE",
+};
+const CONFIG_FILE_NAME = "config.json";
+class CliConfig {
+    config;
+    userCliConfig = {
+        chromePath: "",
+        chromeUserProfilePath: "",
+        slackToken: "",
+        speedKitBrowserExtensionPath: "",
+        testApp: "",
+        ideaDirectory: "",
+        diffExec: "",
+        diffExecTemplate: "$exec $file1 $file2",
+    };
+    constructor(config) {
+        this.config = config;
+    }
+    load() {
+        this.loadConfigFromEnvironment();
+        this.loadConfigFromConfigFile();
+        return this.userCliConfig;
+    }
+    loadConfigFromEnvironment() {
+        for (const key in this.userCliConfig) {
+            const envVar = envMapping[key];
+            if (envVar in process.env && process.env[envVar].length > 0) {
+                this.userCliConfig[key] = process.env[envVar];
+            }
+        }
+    }
+    getConfigFilePath() {
+        return path_1.default.resolve(this.config.configDir, CONFIG_FILE_NAME);
+    }
+    loadConfigFromConfigFile() {
+        if (!fs_1.default.existsSync(this.getConfigFilePath())) {
+            this.createEmptyConfigFile();
+            return;
+        }
+        const configFileContent = fs_1.default.readFileSync(this.getConfigFilePath(), 'utf8');
+        try {
+            const configJson = JSON.parse(configFileContent);
+            for (const key in configJson) {
+                if (configJson[key].length > 0) {
+                    this.userCliConfig[key] = configJson[key];
+                }
+            }
+            return;
+        }
+        catch (error) {
+        }
+    }
+    createEmptyConfigFile() {
+        fs_1.default.mkdirSync(path_1.default.resolve(this.config.configDir), { recursive: true });
+        fs_1.default.writeFileSync(this.getConfigFilePath(), JSON.stringify(this.createEmptyUserConfig(), null, `\t`));
+    }
+    createEmptyUserConfig() {
+        return {
+            chromePath: "",
+            chromeUserProfilePath: "",
+            slackToken: "",
+            speedKitBrowserExtensionPath: "",
+            testApp: "",
+            ideaDirectory: "",
+            diffExec: "",
+        };
+    }
+}
+exports.CliConfig = CliConfig;

package/dist/helpers/file-helper.d.ts

@@ -0,0 +1,8 @@
+export declare function createTemporalDir(): Promise<string | null>;
+export declare function createEmptyFile(): Promise<string>;
+export declare function trimFileExtension(str: string): string;
+export declare function readLocalFile(basePath: string, fileName: string): Promise<string | null>;
+/**
+ * Returns the local path to the sk-onboarding project.
+ */
+export declare function getLocalPath(path: string): string;

package/dist/helpers/file-helper.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalPath = exports.readLocalFile = exports.trimFileExtension = exports.createEmptyFile = exports.createTemporalDir = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs-extra"));
+const path = tslib_1.__importStar(require("path"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const os = tslib_1.__importStar(require("os"));
+const core_1 = require("@oclif/core");
+const CustomerConfig_1 = require("./CustomerConfig");
+const logging_helper_1 = require("./logging-helper");
+async function createTemporalDir() {
+    try {
+        return fs.mkdtemp(path.join(os.tmpdir(), 'speed-kit-cli-'));
+    }
+    catch (error) {
+        console.error('Error creating temp folder', error);
+        return null;
+    }
+}
+exports.createTemporalDir = createTemporalDir;
+async function createEmptyFile() {
+    const tempDir = await createTemporalDir();
+    const filePath = path.join(tempDir, '/empty_FilePath.js');
+    const writeFilePromise = new Promise((resolve, reject) => {
+        fs.writeFile(filePath, 'No file was found', err => {
+            if (err) {
+                return reject(err);
+            }
+            resolve(null);
+        });
+    });
+    await writeFilePromise;
+    return path.resolve(filePath);
+}
+exports.createEmptyFile = createEmptyFile;
+function trimFileExtension(str) {
+    return str.replace('.js', '').replace('.es6', '');
+}
+exports.trimFileExtension = trimFileExtension;
+async function readLocalFile(basePath, fileName) {
+    try {
+        const file = await CustomerConfig_1.ConfigFile.loadFile(basePath, fileName);
+        return await file.readContent();
+    }
+    catch (error) {
+        return null;
+    }
+}
+exports.readLocalFile = readLocalFile;
+/**
+ * Returns the local path to the sk-onboarding project.
+ */
+function getLocalPath(path) {
+    const fullCustomerPath = path_1.default.resolve(path, '');
+    // Check if path is a valid path or not
+    if (!fs.existsSync(fullCustomerPath)) {
+        (0, logging_helper_1.logError)(`The given path: ${fullCustomerPath} is not a valid path`);
+        core_1.ux.exit(1);
+    }
+    return fullCustomerPath;
+}
+exports.getLocalPath = getLocalPath;

package/dist/helpers/get-parsed-config.d.ts

@@ -0,0 +1,11 @@
+import { ConfigFile } from "./CustomerConfig";
+interface SpeedKitConfig {
+    ruleSetConfig?: {
+        version?: string;
+    };
+    [key: string]: any;
+}
+export declare function parseSpeedKitConfig(config: string): SpeedKitConfig;
+export declare function getParsedConfig(configFile: ConfigFile): Promise<SpeedKitConfig>;
+export declare function getSpeedKitConfigVersion(config: SpeedKitConfig): number;
+export {};

package/dist/helpers/get-parsed-config.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSpeedKitConfigVersion = exports.getParsedConfig = exports.parseSpeedKitConfig = void 0;
+const tslib_1 = require("tslib");
+const vm = tslib_1.__importStar(require("vm"));
+function parseSpeedKitConfig(config) {
+    // Replace all properties that use function calls or that are related to other objects like window
+    const window = {};
+    window.top = window;
+    const storage = {
+        length: 0,
+        clear: () => undefined,
+        getItem: () => undefined,
+        key: () => null,
+        removeItem: () => undefined,
+        setItem: () => undefined,
+    };
+    const node = {
+        querySelector: () => node,
+        querySelectorAll: () => [],
+        classList: { contains: () => false }
+    };
+    const context = {
+        window,
+        APP: '',
+        document: Object.assign(Object.create(node), {
+            cookie: '',
+            documentElement: Object.create(node),
+            head: Object.create(node),
+            body: Object.create(node),
+        }),
+        speedKit: window.speedKit,
+        navigator: { userAgent: 'test-agent' },
+        location: new URL('https://www.example.com'),
+        localStorage: storage,
+        sessionStorage: storage,
+    };
+    vm.runInNewContext(config, context);
+    return window.speedKit;
+}
+exports.parseSpeedKitConfig = parseSpeedKitConfig;
+async function getParsedConfig(configFile) {
+    const configString = configFile ? await configFile.readContent() : undefined;
+    if (!configString) {
+        throw new Error('Speed Kit config could not be found in directory');
+    }
+    let parsedConfig;
+    try {
+        parsedConfig = parseSpeedKitConfig(configString);
+    }
+    catch (e) {
+        throw new Error(`Speed Kit config string could not be parsed.\n${e.stack}`);
+    }
+    if (!parsedConfig) {
+        throw new Error('Speed Kit config was not correctly exposed on the global speedKit variable.');
+    }
+    return parsedConfig;
+}
+exports.getParsedConfig = getParsedConfig;
+function getSpeedKitConfigVersion(config) {
+    return Number(config.ruleSetConfig?.version) || 1;
+}
+exports.getSpeedKitConfigVersion = getSpeedKitConfigVersion;

package/dist/helpers/getChromePath.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Gets chrome-path of .env file in skonboarding project.
+ * If path is not set or falsy, uses default chrome-path.
+ *
+ * @param customerPath - Path to customer in skonboarding-project.
+ */
+export declare function getChromePath(customerPath: string): Promise<string>;

package/dist/helpers/getChromePath.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChromePath = void 0;
+const CustomerConfig_1 = require("./CustomerConfig");
+const isFile_1 = require("./isFile");
+const CHROME_PATHS = {
+    "darwin": "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "win32": "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+    "linux": "/usr/bin/google-chrome",
+};
+const ENV_CHROME_REGEX = new RegExp(/^\s*CHROME_PATH=(.*)$/um);
+/**
+ * Gets chrome-path of .env file in skonboarding project.
+ * If path is not set or falsy, uses default chrome-path.
+ *
+ * @param customerPath - Path to customer in skonboarding-project.
+ */
+async function getChromePath(customerPath) {
+    const envFile = await CustomerConfig_1.ConfigFile.loadFile(customerPath, '../../.env');
+    if (!envFile) {
+        return CHROME_PATHS[process.platform];
+    }
+    const envContent = await envFile.readContent();
+    const chromePath = ENV_CHROME_REGEX.test(envContent) ? envContent.match(ENV_CHROME_REGEX)[1] : '';
+    return await (0, isFile_1.isFile)(chromePath) ? chromePath : CHROME_PATHS[process.platform];
+}
+exports.getChromePath = getChromePath;

package/dist/helpers/isDirectory.d.ts

@@ -0,0 +1 @@
+export declare function isDirectory(dir: string): Promise<boolean>;

package/dist/helpers/isDirectory.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDirectory = void 0;
+const promises_1 = require("fs/promises");
+async function isDirectory(dir) {
+    try {
+        const stats = await (0, promises_1.stat)(dir);
+        return stats.isDirectory();
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            return false;
+        }
+        throw e;
+    }
+}
+exports.isDirectory = isDirectory;

package/dist/helpers/isExecutable.d.ts

@@ -0,0 +1 @@
+export declare function isExecutable(filename: string): Promise<boolean>;

package/dist/helpers/isExecutable.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExecutable = void 0;
+const promises_1 = require("fs/promises");
+const fs_1 = require("fs");
+async function isExecutable(filename) {
+    try {
+        await (0, promises_1.access)(filename, fs_1.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+exports.isExecutable = isExecutable;

package/dist/helpers/isFile.d.ts

@@ -0,0 +1 @@
+export declare function isFile(filename: string): Promise<boolean>;

package/dist/helpers/isFile.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFile = void 0;
+const promises_1 = require("fs/promises");
+async function isFile(filename) {
+    try {
+        const stats = await (0, promises_1.stat)(filename);
+        return stats.isFile();
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            return false;
+        }
+        throw e;
+    }
+}
+exports.isFile = isFile;

package/dist/helpers/logging-helper.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Logs the given message 'green' in the console.
+ */
+export declare function logInfo(message: string, ...optionalParams: any[]): void;
+/**
+ * Logs the given message 'red' in the console.
+ */
+export declare function logError(message: string, ...optionalParams: any[]): void;
+/**
+ * Logs the given message 'yellow' in the console.
+ */
+export declare function logWarning(message: string, ...optionalParams: any[]): void;

package/dist/helpers/logging-helper.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logWarning = exports.logError = exports.logInfo = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+// TODO: use CliService instead
+/**
+ * Logs the given message 'green' in the console.
+ */
+function logInfo(message, ...optionalParams) {
+    console.log(chalk_1.default.green(message), ...optionalParams);
+}
+exports.logInfo = logInfo;
+/**
+ * Logs the given message 'red' in the console.
+ */
+function logError(message, ...optionalParams) {
+    console.log(chalk_1.default.red(message), ...optionalParams);
+}
+exports.logError = logError;
+/**
+ * Logs the given message 'yellow' in the console.
+ */
+function logWarning(message, ...optionalParams) {
+    console.log(chalk_1.default.yellow(message), ...optionalParams);
+}
+exports.logWarning = logWarning;

package/dist/helpers/normalize.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Sorts all urls params manually.
+ *
+ * @param searchParams - Params to sort.
+ */
+export declare function sortParams(searchParams: URLSearchParams): void;
+/**
+ * Converts parameters back to origin form.
+ *
+ * When adding parameters to the original URL the encoding of the parameters can change.
+ * This is because adding parameters to an URL object triggers a decode before adding
+ * and an encode after adding. Therefore the encoding of parameters can differ from the origin
+ * (e.g. if a whitespace is encoded like '%20' in the original URL, adding a parameter by calling
+ * searchParams.append() encodes the whitespace to '+').
+ *
+ * The root cause for this is because the encoding when appending search params to an URL object
+ * is different than the encoding of encodeURIComponent().
+ *
+ * @param url - The original Url.
+ * @param manipulatedUrl - The computed URL.
+ */
+export declare function convertNotEncodedParameters(url: URL, manipulatedUrl: URL): void;
+/**
+ * Removes the "=" char of query parameters that do not have a value.
+ *
+ * Hint: This is needed because calling the append or delete method of {@link URL}
+ * adds a "=" to all parameter without value. This results in different resource URLs.
+ *
+ * @param url - The original URL.
+ * @param manipulatedUrl - The manipulated URL to remove the "=" from.
+ */
+export declare function transformNoValueParams(url: URL, manipulatedUrl: URL): void;
+/**
+ * Normalizes a given URL.
+ *
+ * @param urlString - The URL to be normalized.
+ * @param sortParameters - Activates alphabetical sorting of the URL parameters.
+ * @returns The normalized URL.
+ */
+export declare function normalize(urlString: string, sortParameters: boolean): string;