@ohos-ports/nx 19.8.4-beta.0

package/src/utils/git-utils.js

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitRepository = void 0;
+exports.cloneFromUpstream = cloneFromUpstream;
+exports.getGithubSlugOrNull = getGithubSlugOrNull;
+exports.extractUserAndRepoFromGitHubUrl = extractUserAndRepoFromGitHubUrl;
+exports.commitChanges = commitChanges;
+exports.getLatestCommitSha = getLatestCommitSha;
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const logger_1 = require("./logger");
+function execAsync(command, execOptions) {
+    return new Promise((res, rej) => {
+        (0, child_process_1.exec)(command, execOptions, (err, stdout, stderr) => {
+            if (err) {
+                return rej(err);
+            }
+            res(stdout);
+        });
+    });
+}
+async function cloneFromUpstream(url, destination, { originName, depth } = {
+    originName: 'origin',
+}) {
+    await execAsync(`git clone ${url} ${destination} ${depth ? `--depth ${depth}` : ''} --origin ${originName}`, {
+        cwd: (0, path_1.dirname)(destination),
+        maxBuffer: 10 * 1024 * 1024,
+    });
+    return new GitRepository(destination);
+}
+class GitRepository {
+    constructor(directory) {
+        this.directory = directory;
+        this.root = this.getGitRootPath(this.directory);
+    }
+    getGitRootPath(cwd) {
+        return (0, child_process_1.execSync)('git rev-parse --show-toplevel', {
+            cwd,
+            windowsHide: true,
+        })
+            .toString()
+            .trim();
+    }
+    async hasUncommittedChanges() {
+        const data = await this.execAsync(`git status --porcelain`);
+        return data.trim() !== '';
+    }
+    async addFetchRemote(remoteName, branch) {
+        return await this.execAsync(`git config --add remote.${remoteName}.fetch "+refs/heads/${branch}:refs/remotes/${remoteName}/${branch}"`);
+    }
+    async showStat() {
+        return await this.execAsync(`git show --stat`);
+    }
+    async listBranches() {
+        return (await this.execAsync(`git ls-remote --heads --quiet`))
+            .trim()
+            .split('\n')
+            .map((s) => s
+            .trim()
+            .substring(s.indexOf('\t') + 1)
+            .replace('refs/heads/', ''));
+    }
+    async getGitFiles(path) {
+        // Use -z to return file names exactly as they are stored in git, separated by NULL (\x00) character.
+        // This avoids problems with special characters in file names.
+        return (await this.execAsync(`git ls-files -z ${path}`))
+            .trim()
+            .split('\x00')
+            .map((s) => s.trim())
+            .filter(Boolean);
+    }
+    async reset(ref) {
+        return await this.execAsync(`git reset ${ref} --hard`);
+    }
+    async mergeUnrelatedHistories(ref, message) {
+        return await this.execAsync(`git merge ${ref} -X ours --allow-unrelated-histories -m "${message}"`);
+    }
+    async fetch(remote, ref) {
+        return await this.execAsync(`git fetch ${remote}${ref ? ` ${ref}` : ''}`);
+    }
+    async checkout(branch, opts) {
+        return await this.execAsync(`git checkout ${opts.new ? '-b ' : ' '}${branch}${opts.base ? ' ' + opts.base : ''}`);
+    }
+    async move(path, destination) {
+        return await this.execAsync(`git mv ${this.quotePath(path)} ${this.quotePath(destination)}`);
+    }
+    async push(ref, remoteName) {
+        return await this.execAsync(`git push -u -f ${remoteName} ${ref}`);
+    }
+    async commit(message) {
+        return await this.execAsync(`git commit -am "${message}"`);
+    }
+    async amendCommit() {
+        return await this.execAsync(`git commit --amend -a --no-edit`);
+    }
+    async deleteGitRemote(name) {
+        return await this.execAsync(`git remote rm ${name}`);
+    }
+    async addGitRemote(name, url) {
+        return await this.execAsync(`git remote add ${name} ${url}`);
+    }
+    async hasFilterRepoInstalled() {
+        try {
+            await this.execAsync(`git filter-repo --help`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // git-filter-repo is much faster than filter-branch, but needs to be installed by user
+    // Use `hasFilterRepoInstalled` to check if it's installed
+    async filterRepo(source, destination) {
+        // NOTE: filter-repo requires POSIX path to work
+        const sourcePosixPath = source.split(path_1.sep).join(path_1.posix.sep);
+        const destinationPosixPath = destination.split(path_1.sep).join(path_1.posix.sep);
+        await this.execAsync(`git filter-repo -f ${source !== '' ? `--path ${this.quotePath(sourcePosixPath)}` : ''} ${source !== destination
+            ? `--path-rename ${this.quotePath(sourcePosixPath, true)}:${this.quotePath(destinationPosixPath, true)}`
+            : ''}`);
+    }
+    async filterBranch(source, destination, branchName) {
+        // We need non-ASCII file names to not be quoted, or else filter-branch will exclude them.
+        await this.execAsync(`git config core.quotepath false`);
+        // NOTE: filter-repo requires POSIX path to work
+        const sourcePosixPath = source.split(path_1.sep).join(path_1.posix.sep);
+        const destinationPosixPath = destination.split(path_1.sep).join(path_1.posix.sep);
+        // First, if the source is not a root project, then only include commits relevant to the subdirectory.
+        if (source !== '') {
+            const indexFilterCommand = this.quoteArg(`node ${(0, path_1.join)(__dirname, 'git-utils.index-filter.js')}`);
+            await this.execAsync(`git filter-branch -f --index-filter ${indexFilterCommand} --prune-empty -- ${branchName}`, {
+                NX_IMPORT_SOURCE: sourcePosixPath,
+                NX_IMPORT_DESTINATION: destinationPosixPath,
+            });
+        }
+        // Then, move files to their new location if necessary.
+        if (source === '' || source !== destination) {
+            const treeFilterCommand = this.quoteArg(`node ${(0, path_1.join)(__dirname, 'git-utils.tree-filter.js')}`);
+            await this.execAsync(`git filter-branch -f --tree-filter ${treeFilterCommand} -- ${branchName}`, {
+                NX_IMPORT_SOURCE: sourcePosixPath,
+                NX_IMPORT_DESTINATION: destinationPosixPath,
+            });
+        }
+    }
+    execAsync(command, env) {
+        return execAsync(command, {
+            cwd: this.root,
+            maxBuffer: 10 * 1024 * 1024,
+            env: {
+                ...process.env,
+                ...env,
+            },
+        });
+    }
+    quotePath(path, ensureTrailingSlash) {
+        return this.quoteArg(ensureTrailingSlash && path !== '' && !path.endsWith('/')
+            ? `${path}/`
+            : path);
+    }
+    quoteArg(arg) {
+        return process.platform === 'win32'
+            ? // Windows/CMD only understands double-quotes, single-quotes are treated as part of the file name
+                // Bash and other shells will substitute `$` in file names with a variable value.
+                `"${arg
+                    // Need to keep two slashes for Windows or else the path will be invalid.
+                    // e.g. 'C:\Users\bob\projects\repo' is invalid, but 'C:\\Users\\bob\\projects\\repo' is valid
+                    .replaceAll('\\', '\\\\')}"`
+            : // e.g. `git mv "$$file.txt" "libs/a/$$file.txt"` will not work since `$$` is swapped with the PID of the last process.
+                // Using single-quotes prevents this substitution.
+                `'${arg}'`;
+    }
+}
+exports.GitRepository = GitRepository;
+/**
+ * This is currently duplicated in Nx Console. Please let @MaxKless know if you make changes here.
+ */
+function getGithubSlugOrNull() {
+    try {
+        const gitRemote = (0, child_process_1.execSync)('git remote -v', {
+            stdio: 'pipe',
+            windowsHide: true,
+        }).toString();
+        // If there are no remotes, we default to github
+        if (!gitRemote || gitRemote.length === 0) {
+            return 'github';
+        }
+        return extractUserAndRepoFromGitHubUrl(gitRemote);
+    }
+    catch (e) {
+        // Probably git is not set up, so we default to github
+        return 'github';
+    }
+}
+function extractUserAndRepoFromGitHubUrl(gitRemotes) {
+    const regex = /^\s*(\w+)\s+(git@github\.com:|https:\/\/github\.com\/)([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)\.git/gm;
+    const remotesPriority = ['origin', 'upstream', 'base'];
+    const foundRemotes = {};
+    let firstGitHubUrl = null;
+    let match;
+    while ((match = regex.exec(gitRemotes)) !== null) {
+        const remoteName = match[1];
+        const url = match[2] + match[3] + '/' + match[4] + '.git';
+        foundRemotes[remoteName] = url;
+        if (!firstGitHubUrl) {
+            firstGitHubUrl = url;
+        }
+    }
+    for (const remote of remotesPriority) {
+        if (foundRemotes[remote]) {
+            return parseGitHubUrl(foundRemotes[remote]);
+        }
+    }
+    return firstGitHubUrl ? parseGitHubUrl(firstGitHubUrl) : null;
+}
+function parseGitHubUrl(url) {
+    const sshPattern = /git@github\.com:([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)\.git/;
+    const httpsPattern = /https:\/\/github\.com\/([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)\.git/;
+    let match = url.match(sshPattern) || url.match(httpsPattern);
+    if (match) {
+        return `${match[1]}/${match[2]}`;
+    }
+    return null;
+}
+function commitChanges(commitMessage, directory) {
+    try {
+        (0, child_process_1.execSync)('git add -A', { encoding: 'utf8', stdio: 'pipe' });
+        (0, child_process_1.execSync)('git commit --no-verify -F -', {
+            encoding: 'utf8',
+            stdio: 'pipe',
+            input: commitMessage,
+            cwd: directory,
+            windowsHide: true,
+        });
+    }
+    catch (err) {
+        if (directory) {
+            // We don't want to throw during create-nx-workspace
+            // because maybe there was an error when setting up git
+            // initially.
+            logger_1.logger.verbose(`Git may not be set up correctly for this new workspace.
+        ${err}`);
+        }
+        else {
+            throw new Error(`Error committing changes:\n${err.stderr}`);
+        }
+    }
+    return getLatestCommitSha();
+}
+function getLatestCommitSha() {
+    try {
+        return (0, child_process_1.execSync)('git rev-parse HEAD', {
+            encoding: 'utf8',
+            stdio: 'pipe',
+            windowsHide: true,
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}

package/src/utils/git-utils.tree-filter.d.ts

@@ -0,0 +1,11 @@
+/**
+ * This is meant to be used with `git filter-branch --tree-filter` to rewrite
+ * history to only include commits related to the source project folder. If the
+ * destination folder is different, this script also moves the files over.
+ *
+ * Example:
+ * NX_IMPORT_SOURCE=<source> NX_IMPORT_DESTINATION=<destination> git filter-branch --tree-filter 'node git-utils.tree-filter.js' --prune-empty -- --all
+ */
+declare const execSync: any;
+declare const existsSync: any, mkdirSync: any, renameSync: any, rmSync: any;
+declare const posix: any;

package/src/utils/git-utils.tree-filter.js

@@ -0,0 +1,45 @@
+/**
+ * This is meant to be used with `git filter-branch --tree-filter` to rewrite
+ * history to only include commits related to the source project folder. If the
+ * destination folder is different, this script also moves the files over.
+ *
+ * Example:
+ * NX_IMPORT_SOURCE=<source> NX_IMPORT_DESTINATION=<destination> git filter-branch --tree-filter 'node git-utils.tree-filter.js' --prune-empty -- --all
+ */
+const { execSync } = require('child_process');
+const { existsSync, mkdirSync, renameSync, rmSync } = require('fs');
+// NOTE: The path passed to `git filter-branch` is POSIX, so we need to use the `posix` module.
+const { posix } = require('path');
+try {
+    // NOTE: Using env vars because Windows PowerShell has its own handling of quotes (") messes up quotes in args, even if escaped.
+    const src = process.env.NX_IMPORT_SOURCE;
+    const dest = process.env.NX_IMPORT_DESTINATION;
+    const files = execSync(`git ls-files -z ${src}`, {
+        windowsHide: true,
+    })
+        .toString()
+        .trim()
+        .split('\x00')
+        .map((s) => s.trim())
+        .filter(Boolean);
+    for (const file of files) {
+        if (src === '' || file.startsWith(src)) {
+            // If source and destination are the same, then keep the file as is.
+            if (src === dest)
+                continue;
+            const destFile = posix.join(dest, file.replace(src, ''));
+            const dir = posix.dirname(destFile);
+            if (!existsSync(dir))
+                mkdirSync(dir, { recursive: true });
+            renameSync(file, destFile);
+        }
+        else {
+            // If not matching the source we are filtering, remove it.
+            rmSync(file);
+        }
+    }
+}
+catch (error) {
+    console.error(`Error executing Git commands: ${error}`);
+    process.exit(1);
+}

package/src/utils/globs.d.ts

@@ -0,0 +1,3 @@
+export declare function combineGlobPatterns(...patterns: (string | string[])[]): string;
+export declare const GLOB_CHARACTERS: Set<string>;
+export declare function isGlobPattern(pattern: string): boolean;

package/src/utils/globs.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GLOB_CHARACTERS = void 0;
+exports.combineGlobPatterns = combineGlobPatterns;
+exports.isGlobPattern = isGlobPattern;
+function combineGlobPatterns(...patterns) {
+    const p = patterns.flat();
+    return p.length > 1 ? '{' + p.join(',') + '}' : p.length === 1 ? p[0] : '';
+}
+exports.GLOB_CHARACTERS = new Set(['*', '|', '{', '}', '(', ')', '[']);
+function isGlobPattern(pattern) {
+    for (const c of pattern) {
+        if (exports.GLOB_CHARACTERS.has(c)) {
+            return true;
+        }
+    }
+    return false;
+}

package/src/utils/handle-errors.d.ts

@@ -0,0 +1 @@
+export declare function handleErrors(isVerbose: boolean, fn: Function): Promise<number>;

package/src/utils/handle-errors.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleErrors = handleErrors;
+const client_1 = require("../daemon/client/client");
+const logger_1 = require("./logger");
+const output_1 = require("./output");
+async function handleErrors(isVerbose, fn) {
+    try {
+        const result = await fn();
+        if (typeof result === 'number') {
+            return result;
+        }
+        return 0;
+    }
+    catch (err) {
+        err ||= new Error('Unknown error caught');
+        if (err.constructor.name === 'UnsuccessfulWorkflowExecution') {
+            logger_1.logger.error('The generator workflow failed. See above.');
+        }
+        else if (err.name === 'ProjectGraphError') {
+            const projectGraphError = err;
+            let title = projectGraphError.message;
+            if (projectGraphError.cause &&
+                typeof projectGraphError.cause === 'object' &&
+                'message' in projectGraphError.cause) {
+                title += ' ' + projectGraphError.cause.message + '.';
+            }
+            if (isVerbose) {
+                title += ' See errors below.';
+            }
+            const bodyLines = isVerbose
+                ? formatErrorStackAndCause(projectGraphError)
+                : ['Pass --verbose to see the stacktraces.'];
+            output_1.output.error({
+                title,
+                bodyLines: bodyLines,
+            });
+        }
+        else {
+            const lines = (err.message ? err.message : err.toString()).split('\n');
+            const bodyLines = lines.slice(1);
+            if (isVerbose) {
+                bodyLines.push(...formatErrorStackAndCause(err));
+            }
+            else if (err.stack) {
+                bodyLines.push('Pass --verbose to see the stacktrace.');
+            }
+            output_1.output.error({
+                title: lines[0],
+                bodyLines,
+            });
+        }
+        if (client_1.daemonClient.enabled()) {
+            client_1.daemonClient.reset();
+        }
+        return 1;
+    }
+}
+function formatErrorStackAndCause(error) {
+    return [
+        error.stack || error.message,
+        ...(error.cause && typeof error.cause === 'object'
+            ? [
+                'Caused by:',
+                'stack' in error.cause
+                    ? error.cause.stack.toString()
+                    : error.cause.toString(),
+            ]
+            : []),
+    ];
+}

package/src/utils/ignore.d.ts

@@ -0,0 +1,8 @@
+import ignore from 'ignore';
+/**
+ * An array of glob patterns that should always be ignored.
+ */
+export declare const ALWAYS_IGNORE: string[];
+export declare function getIgnoredGlobs(root?: string, prependRoot?: boolean): string[];
+export declare function getAlwaysIgnore(root?: string): string[];
+export declare function getIgnoreObject(root?: string): ReturnType<typeof ignore>;

package/src/utils/ignore.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALWAYS_IGNORE = void 0;
+exports.getIgnoredGlobs = getIgnoredGlobs;
+exports.getAlwaysIgnore = getAlwaysIgnore;
+exports.getIgnoreObject = getIgnoreObject;
+const node_fs_1 = require("node:fs");
+const ignore_1 = require("ignore");
+const fileutils_1 = require("./fileutils");
+const path_1 = require("./path");
+const workspace_root_1 = require("./workspace-root");
+/**
+ * An array of glob patterns that should always be ignored.
+ */
+exports.ALWAYS_IGNORE = getAlwaysIgnore();
+function getIgnoredGlobs(root = workspace_root_1.workspaceRoot, prependRoot = true) {
+    const files = ['.gitignore', '.nxignore'];
+    if (prependRoot) {
+        return [
+            ...getAlwaysIgnore(root),
+            ...files.flatMap((f) => getIgnoredGlobsFromFile((0, path_1.joinPathFragments)(root, f), root)),
+        ];
+    }
+    else {
+        return [
+            ...getAlwaysIgnore(),
+            ...files.flatMap((f) => getIgnoredGlobsFromFile((0, path_1.joinPathFragments)(root, f))),
+        ];
+    }
+}
+function getAlwaysIgnore(root) {
+    const paths = [
+        'node_modules',
+        '**/node_modules',
+        '.git',
+        '.nx',
+        '.vscode',
+        '.yarn/cache',
+    ];
+    return root ? paths.map((x) => (0, path_1.joinPathFragments)(root, x)) : paths;
+}
+function getIgnoreObject(root = workspace_root_1.workspaceRoot) {
+    const ig = (0, ignore_1.default)();
+    ig.add((0, fileutils_1.readFileIfExisting)(`${root}/.gitignore`));
+    ig.add((0, fileutils_1.readFileIfExisting)(`${root}/.nxignore`));
+    return ig;
+}
+function getIgnoredGlobsFromFile(file, root) {
+    try {
+        const results = [];
+        const contents = (0, node_fs_1.readFileSync)(file, 'utf-8');
+        const lines = contents.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#')) {
+                continue;
+            }
+            else if (trimmed.startsWith('/')) {
+                if (root) {
+                    results.push((0, path_1.joinPathFragments)(root, trimmed));
+                }
+                else {
+                    results.push((0, path_1.joinPathFragments)('.', trimmed));
+                }
+            }
+            else {
+                results.push(trimmed);
+            }
+        }
+        return results;
+    }
+    catch (e) {
+        return [];
+    }
+}

package/src/utils/installation-directory.d.ts

@@ -0,0 +1,2 @@
+export declare function getNxInstallationPath(root?: string): string;
+export declare function getNxRequirePaths(root?: string): string[];

package/src/utils/installation-directory.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNxInstallationPath = getNxInstallationPath;
+exports.getNxRequirePaths = getNxRequirePaths;
+const path_1 = require("path");
+const workspace_root_1 = require("./workspace-root");
+function getNxInstallationPath(root = workspace_root_1.workspaceRoot) {
+    return (0, path_1.join)(root, '.nx', 'installation');
+}
+function getNxRequirePaths(root = workspace_root_1.workspaceRoot) {
+    return [root, getNxInstallationPath(root)];
+}

package/src/utils/is-ci.d.ts

@@ -0,0 +1 @@
+export declare function isCI(): boolean;

package/src/utils/is-ci.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCI = isCI;
+function isCI() {
+    return ((process.env.CI && process.env.CI !== 'false') ||
+        process.env.TF_BUILD === 'true' ||
+        process.env.GITHUB_ACTIONS === 'true' ||
+        process.env.BUILDKITE === 'true' ||
+        process.env.CIRCLECI === 'true' ||
+        process.env.CIRRUS_CI === 'true' ||
+        process.env.TRAVIS === 'true' ||
+        !!process.env['bamboo.buildKey'] ||
+        !!process.env['bamboo_buildKey'] ||
+        !!process.env.CODEBUILD_BUILD_ID ||
+        !!process.env.GITLAB_CI ||
+        !!process.env.HEROKU_TEST_RUN_ID ||
+        !!process.env.BUILD_ID ||
+        !!process.env.BUILD_BUILDID ||
+        !!process.env.TEAMCITY_VERSION);
+}

package/src/utils/json-diff.d.ts

@@ -0,0 +1,18 @@
+import { Change } from '../project-graph/file-utils';
+export declare enum JsonDiffType {
+    Deleted = "JsonPropertyDeleted",
+    Added = "JsonPropertyAdded",
+    Modified = "JsonPropertyModified"
+}
+export interface JsonChange extends Change {
+    type: JsonDiffType;
+    path: string[];
+    value: {
+        lhs: any;
+        rhs: any;
+    };
+}
+export declare function isJsonChange(change: Change): change is JsonChange;
+export declare function jsonDiff(lhs: any, rhs: any): JsonChange[];
+export declare function walkJsonTree(json: any, currPath: string[], visitor: (path: string[], value: any) => boolean): void;
+export declare function deepEquals(a: any, b: any): boolean;

package/src/utils/json-diff.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonDiffType = void 0;
+exports.isJsonChange = isJsonChange;
+exports.jsonDiff = jsonDiff;
+exports.walkJsonTree = walkJsonTree;
+exports.deepEquals = deepEquals;
+var JsonDiffType;
+(function (JsonDiffType) {
+    JsonDiffType["Deleted"] = "JsonPropertyDeleted";
+    JsonDiffType["Added"] = "JsonPropertyAdded";
+    JsonDiffType["Modified"] = "JsonPropertyModified";
+})(JsonDiffType || (exports.JsonDiffType = JsonDiffType = {}));
+function isJsonChange(change) {
+    return (change.type === JsonDiffType.Added ||
+        change.type === JsonDiffType.Deleted ||
+        change.type === JsonDiffType.Modified);
+}
+function jsonDiff(lhs, rhs) {
+    const result = [];
+    const seenInLhs = new Set();
+    walkJsonTree(lhs, [], (path, lhsValue) => {
+        seenInLhs.add(hashArray(path));
+        const rhsValue = getJsonValue(path, rhs);
+        if (rhsValue === undefined) {
+            result.push({
+                type: JsonDiffType.Deleted,
+                path,
+                value: {
+                    lhs: lhsValue,
+                    rhs: undefined,
+                },
+            });
+        }
+        else if (!deepEquals(lhsValue, rhsValue)) {
+            result.push({
+                type: JsonDiffType.Modified,
+                path,
+                value: {
+                    lhs: lhsValue,
+                    rhs: rhsValue,
+                },
+            });
+        }
+        return typeof lhsValue === 'object' || Array.isArray(lhsValue);
+    });
+    walkJsonTree(rhs, [], (path, rhsValue) => {
+        const addedInRhs = !seenInLhs.has(hashArray(path));
+        if (addedInRhs) {
+            result.push({
+                type: JsonDiffType.Added,
+                path,
+                value: {
+                    lhs: undefined,
+                    rhs: rhsValue,
+                },
+            });
+        }
+        return typeof rhsValue === 'object' || Array.isArray(rhsValue);
+    });
+    return result;
+}
+// Depth-first walk down JSON tree.
+function walkJsonTree(json, currPath, visitor) {
+    if (!json || typeof json !== 'object') {
+        return;
+    }
+    Object.keys(json).forEach((key) => {
+        const path = currPath.concat([key]);
+        const shouldContinue = visitor(path, json[key]);
+        if (shouldContinue) {
+            walkJsonTree(json[key], path, visitor);
+        }
+    });
+}
+function hashArray(ary) {
+    return JSON.stringify(ary);
+}
+function getJsonValue(path, json) {
+    let curr = json;
+    for (const k of path) {
+        curr = curr[k];
+        if (curr === undefined) {
+            break;
+        }
+    }
+    return curr;
+}
+function deepEquals(a, b) {
+    if (a === b) {
+        return true;
+    }
+    // Values do not need to be checked for deep equality and the above is false
+    if (
+    // Values are different types
+    typeof a !== typeof b ||
+        // Values are the same type but not an object or array
+        (typeof a !== 'object' && !Array.isArray(a)) ||
+        // Objects are the same type, objects or arrays, but do not have the same number of keys
+        Object.keys(a).length !== Object.keys(b).length) {
+        return false;
+    }
+    // Values need to be checked for deep equality
+    return Object.entries(a).reduce((equal, [key, aValue]) => {
+        // Skip other keys if it is already not equal.
+        if (!equal) {
+            return equal;
+        }
+        // Traverse the object
+        return deepEquals(aValue, b[key]);
+    }, true);
+}