@ohos-ports/nx 19.8.4-beta.0

package/src/utils/fileutils.d.ts

@@ -0,0 +1,75 @@
+import type { JsonParseOptions, JsonSerializeOptions } from './json';
+import { PathLike } from 'node:fs';
+export interface JsonReadOptions extends JsonParseOptions {
+    /**
+     * mutable field recording whether JSON ends with new line
+     * @default false
+     */
+    endsWithNewline?: boolean;
+}
+export interface JsonWriteOptions extends JsonSerializeOptions {
+    /**
+     * whether to append new line at the end of JSON file
+     * @default false
+     */
+    appendNewLine?: boolean;
+}
+/**
+ * Reads a JSON file and returns the object the JSON content represents.
+ *
+ * @param path A path to a file.
+ * @param options JSON parse options
+ * @returns Object the JSON content of the file represents
+ */
+export declare function readJsonFile<T extends object = any>(path: string, options?: JsonReadOptions): T;
+interface YamlReadOptions {
+    /**
+     * Compatibility with JSON.parse behaviour. If true, then duplicate keys in a mapping will override values rather than throwing an error.
+     */
+    json?: boolean;
+}
+/**
+ * Reads a YAML file and returns the object the YAML content represents.
+ *
+ * @param path A path to a file.
+ * @returns
+ */
+export declare function readYamlFile<T extends object = any>(path: string, options?: YamlReadOptions): T;
+/**
+ * Serializes the given data to JSON and writes it to a file.
+ *
+ * @param path A path to a file.
+ * @param data data which should be serialized to JSON and written to the file
+ * @param options JSON serialize options
+ */
+export declare function writeJsonFile<T extends object = object>(path: string, data: T, options?: JsonWriteOptions): void;
+/**
+ * Serializes the given data to JSON and writes it to a file asynchronously.
+ *
+ * @param path A path to a file.
+ * @param data data which should be serialized to JSON and written to the file
+ * @param options JSON serialize options
+ */
+export declare function writeJsonFileAsync<T extends object = object>(path: string, data: T, options?: JsonWriteOptions): Promise<void>;
+/**
+ * Check if a directory exists
+ * @param path Path to directory
+ */
+export declare function directoryExists(path: PathLike): boolean;
+/**
+ * Check if a file exists.
+ * @param path Path to file
+ */
+export declare function fileExists(path: PathLike): boolean;
+export declare function createDirectory(path: PathLike): void;
+export declare function isRelativePath(path: string): boolean;
+/**
+ * Extracts a file from a given tarball to the specified destination.
+ * @param tarballPath The path to the tarball from where the file should be extracted.
+ * @param file The path to the file inside the tarball.
+ * @param destinationFilePath The destination file path.
+ * @returns True if the file was extracted successfully, false otherwise.
+ */
+export declare function extractFileFromTarball(tarballPath: string, file: string, destinationFilePath: string): Promise<string>;
+export declare function readFileIfExisting(path: string): string;
+export {};

package/src/utils/fileutils.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readJsonFile = readJsonFile;
+exports.readYamlFile = readYamlFile;
+exports.writeJsonFile = writeJsonFile;
+exports.writeJsonFileAsync = writeJsonFileAsync;
+exports.directoryExists = directoryExists;
+exports.fileExists = fileExists;
+exports.createDirectory = createDirectory;
+exports.isRelativePath = isRelativePath;
+exports.extractFileFromTarball = extractFileFromTarball;
+exports.readFileIfExisting = readFileIfExisting;
+const json_1 = require("./json");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const path_1 = require("path");
+const tar = require("tar-stream");
+const zlib_1 = require("zlib");
+/**
+ * Reads a JSON file and returns the object the JSON content represents.
+ *
+ * @param path A path to a file.
+ * @param options JSON parse options
+ * @returns Object the JSON content of the file represents
+ */
+function readJsonFile(path, options) {
+    const content = (0, node_fs_1.readFileSync)(path, 'utf-8');
+    if (options) {
+        options.endsWithNewline = content.charCodeAt(content.length - 1) === 10;
+    }
+    try {
+        return (0, json_1.parseJson)(content, options);
+    }
+    catch (e) {
+        e.message = e.message.replace('JSON', path);
+        throw e;
+    }
+}
+/**
+ * Reads a YAML file and returns the object the YAML content represents.
+ *
+ * @param path A path to a file.
+ * @returns
+ */
+function readYamlFile(path, options) {
+    const content = (0, node_fs_1.readFileSync)(path, 'utf-8');
+    const { load } = require('@zkochan/js-yaml');
+    return load(content, { ...options, filename: path });
+}
+/**
+ * Serializes the given data to JSON and writes it to a file.
+ *
+ * @param path A path to a file.
+ * @param data data which should be serialized to JSON and written to the file
+ * @param options JSON serialize options
+ */
+function writeJsonFile(path, data, options) {
+    (0, node_fs_1.mkdirSync)((0, path_1.dirname)(path), { recursive: true });
+    const serializedJson = (0, json_1.serializeJson)(data, options);
+    const content = options?.appendNewLine
+        ? `${serializedJson}\n`
+        : serializedJson;
+    (0, node_fs_1.writeFileSync)(path, content, { encoding: 'utf-8' });
+}
+/**
+ * Serializes the given data to JSON and writes it to a file asynchronously.
+ *
+ * @param path A path to a file.
+ * @param data data which should be serialized to JSON and written to the file
+ * @param options JSON serialize options
+ */
+async function writeJsonFileAsync(path, data, options) {
+    await (0, promises_1.mkdir)((0, path_1.dirname)(path), { recursive: true });
+    const serializedJson = (0, json_1.serializeJson)(data, options);
+    const content = options?.appendNewLine
+        ? `${serializedJson}\n`
+        : serializedJson;
+    await (0, promises_1.writeFile)(path, content, { encoding: 'utf-8' });
+}
+/**
+ * Check if a directory exists
+ * @param path Path to directory
+ */
+function directoryExists(path) {
+    try {
+        return (0, node_fs_1.statSync)(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if a file exists.
+ * @param path Path to file
+ */
+function fileExists(path) {
+    try {
+        return (0, node_fs_1.statSync)(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function createDirectory(path) {
+    (0, node_fs_1.mkdirSync)(path, { recursive: true });
+}
+function isRelativePath(path) {
+    return (path === '.' ||
+        path === '..' ||
+        path.startsWith('./') ||
+        path.startsWith('../'));
+}
+/**
+ * Extracts a file from a given tarball to the specified destination.
+ * @param tarballPath The path to the tarball from where the file should be extracted.
+ * @param file The path to the file inside the tarball.
+ * @param destinationFilePath The destination file path.
+ * @returns True if the file was extracted successfully, false otherwise.
+ */
+async function extractFileFromTarball(tarballPath, file, destinationFilePath) {
+    return new Promise((resolve, reject) => {
+        (0, node_fs_1.mkdirSync)((0, path_1.dirname)(destinationFilePath), { recursive: true });
+        var tarExtractStream = tar.extract();
+        const destinationFileStream = (0, node_fs_1.createWriteStream)(destinationFilePath);
+        let isFileExtracted = false;
+        tarExtractStream.on('entry', function (header, stream, next) {
+            if (header.name === file) {
+                stream.pipe(destinationFileStream);
+                stream.on('end', () => {
+                    isFileExtracted = true;
+                });
+                destinationFileStream.on('close', () => {
+                    resolve(destinationFilePath);
+                });
+            }
+            stream.on('end', function () {
+                next();
+            });
+            stream.resume();
+        });
+        tarExtractStream.on('finish', function () {
+            if (!isFileExtracted) {
+                reject();
+            }
+        });
+        (0, node_fs_1.createReadStream)(tarballPath).pipe((0, zlib_1.createGunzip)()).pipe(tarExtractStream);
+    });
+}
+function readFileIfExisting(path) {
+    return (0, node_fs_1.existsSync)(path) ? (0, node_fs_1.readFileSync)(path, 'utf-8') : '';
+}

package/src/utils/find-matching-projects.d.ts

@@ -0,0 +1,10 @@
+import type { ProjectGraphProjectNode } from '../config/project-graph';
+/**
+ * Find matching project names given a list of potential project names or globs.
+ *
+ * @param patterns A list of project names or globs to match against.
+ * @param projects A map of {@link ProjectGraphProjectNode} by project name.
+ * @returns
+ */
+export declare function findMatchingProjects(patterns: string[], projects: Record<string, ProjectGraphProjectNode>): string[];
+export declare const getMatchingStringsWithCache: (pattern: string, items: string[]) => string[];

package/src/utils/find-matching-projects.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMatchingStringsWithCache = void 0;
+exports.findMatchingProjects = findMatchingProjects;
+const minimatch_1 = require("minimatch");
+const globs_1 = require("./globs");
+const validPatternTypes = [
+    'name', // Pattern is based on the project's name
+    'tag', // Pattern is based on the project's tags
+    'directory', // Pattern is based on the project's root directory
+    'unlabeled', // Pattern was passed without specifying a type
+];
+/**
+ * Find matching project names given a list of potential project names or globs.
+ *
+ * @param patterns A list of project names or globs to match against.
+ * @param projects A map of {@link ProjectGraphProjectNode} by project name.
+ * @returns
+ */
+function findMatchingProjects(patterns = [], projects) {
+    if (!patterns.length || patterns.filter((p) => p.length).length === 0) {
+        return []; // Short circuit if called with no patterns
+    }
+    const projectNames = Object.keys(projects);
+    const matchedProjects = new Set();
+    // If the first pattern is an exclude pattern,
+    // we add a wildcard pattern at the first to select
+    // all projects, except the ones that match the exclude pattern.
+    // e.g. ['!tag:someTag', 'project2'] will match all projects except
+    // the ones with the tag 'someTag', and also match the project 'project2',
+    // regardless of its tags.
+    if (isExcludePattern(patterns[0])) {
+        patterns.unshift('*');
+    }
+    for (const stringPattern of patterns) {
+        if (!stringPattern.length) {
+            continue;
+        }
+        const pattern = parseStringPattern(stringPattern, projects);
+        // Handle wildcard with short-circuit, as its a common case with potentially
+        // large project sets and we can avoid the more expensive glob matching.
+        if (pattern.value === '*') {
+            for (const projectName of projectNames) {
+                if (pattern.exclude) {
+                    matchedProjects.delete(projectName);
+                }
+                else {
+                    matchedProjects.add(projectName);
+                }
+            }
+            continue;
+        }
+        switch (pattern.type) {
+            case 'tag': {
+                addMatchingProjectsByTag(projectNames, projects, pattern, matchedProjects);
+                continue;
+            }
+            case 'name': {
+                addMatchingProjectsByName(projectNames, projects, pattern, matchedProjects);
+                continue;
+            }
+            case 'directory': {
+                addMatchingProjectsByDirectory(projectNames, projects, pattern, matchedProjects);
+                continue;
+            }
+            // Same thing as `type:unlabeled`. If no specific type is set,
+            // we can waterfall through the different types until we find a match
+            default: {
+                // The size of the selected and excluded projects set, before we
+                // start updating it with this pattern. If the size changes, we
+                // know we found a match and can skip the other types.
+                const originalSize = matchedProjects.size;
+                addMatchingProjectsByName(projectNames, projects, pattern, matchedProjects);
+                if (matchedProjects.size !== originalSize) {
+                    // There was some match by name, don't check other types
+                    continue;
+                }
+                addMatchingProjectsByDirectory(projectNames, projects, pattern, matchedProjects);
+                if (matchedProjects.size !== originalSize) {
+                    // There was some match by directory, don't check other types
+                    // Note - this doesn't do anything currently, but preps for future
+                    // types
+                    continue;
+                }
+            }
+        }
+    }
+    return Array.from(matchedProjects);
+}
+function addMatchingProjectsByDirectory(projectNames, projects, pattern, matchedProjects) {
+    for (const projectName of projectNames) {
+        const root = projects[projectName].data.root;
+        if ((0, exports.getMatchingStringsWithCache)(pattern.value, [root]).length > 0) {
+            if (pattern.exclude) {
+                matchedProjects.delete(projectName);
+            }
+            else {
+                matchedProjects.add(projectName);
+            }
+        }
+    }
+}
+function addMatchingProjectsByName(projectNames, projects, pattern, matchedProjects) {
+    if (projects[pattern.value]) {
+        if (pattern.exclude) {
+            matchedProjects.delete(pattern.value);
+        }
+        else {
+            matchedProjects.add(pattern.value);
+        }
+        return;
+    }
+    if (!(0, globs_1.isGlobPattern)(pattern.value)) {
+        return;
+    }
+    const matchedProjectNames = (0, exports.getMatchingStringsWithCache)(pattern.value, projectNames);
+    for (const projectName of matchedProjectNames) {
+        if (pattern.exclude) {
+            matchedProjects.delete(projectName);
+        }
+        else {
+            matchedProjects.add(projectName);
+        }
+    }
+}
+function addMatchingProjectsByTag(projectNames, projects, pattern, matchedProjects) {
+    for (const projectName of projectNames) {
+        const tags = projects[projectName].data.tags || [];
+        if (tags.includes(pattern.value)) {
+            if (pattern.exclude) {
+                matchedProjects.delete(projectName);
+            }
+            else {
+                matchedProjects.add(projectName);
+            }
+            continue;
+        }
+        if (!(0, globs_1.isGlobPattern)(pattern.value)) {
+            continue;
+        }
+        if ((0, exports.getMatchingStringsWithCache)(pattern.value, tags).length) {
+            if (pattern.exclude) {
+                matchedProjects.delete(projectName);
+            }
+            else {
+                matchedProjects.add(projectName);
+            }
+        }
+    }
+}
+function isExcludePattern(pattern) {
+    return pattern.startsWith('!');
+}
+function parseStringPattern(pattern, projects) {
+    const isExclude = isExcludePattern(pattern);
+    // Support for things like: `!{type}:value`
+    if (isExclude) {
+        pattern = pattern.substring(1);
+    }
+    const indexOfFirstPotentialSeparator = pattern.indexOf(':');
+    // There is a project that matches directly
+    if (projects[pattern]) {
+        return { type: 'name', value: pattern, exclude: isExclude };
+        // The pattern does not contain a label
+    }
+    else if (indexOfFirstPotentialSeparator === -1) {
+        return { type: 'unlabeled', value: pattern, exclude: isExclude };
+        // The pattern may contain a label
+    }
+    else {
+        const potentialType = pattern.substring(0, indexOfFirstPotentialSeparator);
+        return {
+            type: isValidPatternType(potentialType) ? potentialType : 'unlabeled',
+            value: pattern.substring(indexOfFirstPotentialSeparator + 1),
+            exclude: isExclude,
+        };
+    }
+}
+function isValidPatternType(type) {
+    return validPatternTypes.includes(type);
+}
+exports.getMatchingStringsWithCache = (() => {
+    // Map< Pattern, Map< Item, Result >>
+    const minimatchCache = new Map();
+    const regexCache = new Map();
+    return (pattern, items) => {
+        if (!minimatchCache.has(pattern)) {
+            minimatchCache.set(pattern, new Map());
+        }
+        const patternCache = minimatchCache.get(pattern);
+        if (!regexCache.has(pattern)) {
+            const regex = minimatch_1.minimatch.makeRe(pattern, { dot: true });
+            if (regex) {
+                regexCache.set(pattern, regex);
+            }
+            else {
+                throw new Error('Invalid glob pattern ' + pattern);
+            }
+        }
+        const matcher = regexCache.get(pattern);
+        return items.filter((item) => {
+            let entry = patternCache.get(item);
+            if (entry === undefined || entry === null) {
+                entry = item === pattern ? true : matcher.test(item);
+                patternCache.set(item, entry);
+            }
+            return entry;
+        });
+    };
+})();

package/src/utils/find-workspace-root.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Recursive function that walks back up the directory
+ * tree to try and find a workspace file.
+ *
+ * @param dir Directory to start searching with
+ */
+export declare function findWorkspaceRoot(dir: string): WorkspaceTypeAndRoot | null;
+export interface WorkspaceTypeAndRoot {
+    type: 'nx' | 'angular';
+    dir: string;
+}

package/src/utils/find-workspace-root.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findWorkspaceRoot = findWorkspaceRoot;
+const workspace_root_1 = require("./workspace-root");
+/**
+ * Recursive function that walks back up the directory
+ * tree to try and find a workspace file.
+ *
+ * @param dir Directory to start searching with
+ */
+function findWorkspaceRoot(dir) {
+    const r = (0, workspace_root_1.workspaceRootInner)(dir, null);
+    if (r === null)
+        return null;
+    if (isAngularCliInstalled(r)) {
+        return { type: 'angular', dir: r };
+    }
+    else {
+        return { type: 'nx', dir: r };
+    }
+}
+function isAngularCliInstalled(root) {
+    try {
+        // nx-ignore-next-line
+        require.resolve('@angular/cli', {
+            paths: [root],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/src/utils/get-package-name-from-import-path.d.ts

@@ -0,0 +1 @@
+export declare function getPackageNameFromImportPath(importExpression: string): string;

package/src/utils/get-package-name-from-import-path.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageNameFromImportPath = getPackageNameFromImportPath;
+//# Converts import paths to package names.
+//# e.g. - `@nx/workspace`        -> `@nx/workspace`
+//#      - `@nx/workspace/plugin` -> `@nx/workspace`
+//#      - `@nx/workspace/other`  -> `@nx/workspace`
+//#      - `nx/plugin`            -> `nx`
+function getPackageNameFromImportPath(importExpression) {
+    // Check if the package is scoped
+    if (importExpression.startsWith('@')) {
+        // For scoped packages, the package name is up to the second '/'
+        return importExpression.split('/').slice(0, 2).join('/');
+    }
+    // For unscoped packages, the package name is up to the first '/'
+    return importExpression.split('/')[0];
+}

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

@@ -0,0 +1,41 @@
+export declare function cloneFromUpstream(url: string, destination: string, { originName, depth }?: {
+    originName: string;
+    depth?: number;
+}): Promise<GitRepository>;
+export declare class GitRepository {
+    private directory;
+    root: string;
+    constructor(directory: string);
+    getGitRootPath(cwd: string): string;
+    hasUncommittedChanges(): Promise<boolean>;
+    addFetchRemote(remoteName: string, branch: string): Promise<string>;
+    showStat(): Promise<string>;
+    listBranches(): Promise<string[]>;
+    getGitFiles(path: string): Promise<string[]>;
+    reset(ref: string): Promise<string>;
+    mergeUnrelatedHistories(ref: string, message: string): Promise<string>;
+    fetch(remote: string, ref?: string): Promise<string>;
+    checkout(branch: string, opts: {
+        new: boolean;
+        base: string;
+    }): Promise<string>;
+    move(path: string, destination: string): Promise<string>;
+    push(ref: string, remoteName: string): Promise<string>;
+    commit(message: string): Promise<string>;
+    amendCommit(): Promise<string>;
+    deleteGitRemote(name: string): Promise<string>;
+    addGitRemote(name: string, url: string): Promise<string>;
+    hasFilterRepoInstalled(): Promise<boolean>;
+    filterRepo(source: string, destination: string): Promise<void>;
+    filterBranch(source: string, destination: string, branchName: string): Promise<void>;
+    private execAsync;
+    private quotePath;
+    private quoteArg;
+}
+/**
+ * This is currently duplicated in Nx Console. Please let @MaxKless know if you make changes here.
+ */
+export declare function getGithubSlugOrNull(): string | null;
+export declare function extractUserAndRepoFromGitHubUrl(gitRemotes: string): string | null;
+export declare function commitChanges(commitMessage: string, directory?: string): string | null;
+export declare function getLatestCommitSha(): string | null;

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

@@ -0,0 +1,21 @@
+/**
+ * This is meant to be used with `git filter-branch --index-filter` to rewrite
+ * history such that only commits related to the subdirectory is kept.
+ *
+ * Example:
+ * NX_IMPORT_SOURCE=<source> git filter-branch --index-filter 'node git-utils.index-filter.js' --prune-empty -- --all
+ */
+try {
+    const { execSync } = require('child_process');
+    // 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;
+    execSync('git read-tree --empty', { stdio: 'inherit', windowsHide: true });
+    execSync(`git reset ${process.env.GIT_COMMIT} -- "${src}"`, {
+        stdio: 'inherit',
+        windowsHide: true,
+    });
+}
+catch (error) {
+    console.error(`Error executing Git commands: ${error}`);
+    process.exit(1);
+}