@ohos-ports/nx 19.8.4-beta.0 → 23.2.0-beta.1

package/dist/plugins/package-json.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPackageJsonConfigurationCache = readPackageJsonConfigurationCache;
+const plugins_1 = require("../src/project-graph/plugins");
+const workspace_root_1 = require("../src/utils/workspace-root");
+const package_json_1 = require("../src/plugins/package-json");
+const cache_directory_1 = require("../src/utils/cache-directory");
+const path_1 = require("path");
+const fileutils_1 = require("../src/utils/fileutils");
+const plugin_cache_utils_1 = require("../src/utils/plugin-cache-utils");
+const package_manager_1 = require("../src/utils/package-manager");
+const cachePath = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'package-json.hash');
+let packageJsonPluginCache = null;
+function readPackageJsonConfigurationCache() {
+    packageJsonPluginCache = new plugin_cache_utils_1.PluginCache(cachePath);
+    return packageJsonPluginCache;
+}
+function writeCache() {
+    if (packageJsonPluginCache) {
+        packageJsonPluginCache.writeToDisk();
+    }
+}
+const plugin = {
+    name: 'nx-all-package-jsons-plugin',
+    createNodes: [
+        '*/**/package.json',
+        (configFiles, options, context) => {
+            const cache = readPackageJsonConfigurationCache();
+            const patterns = (0, package_json_1.buildPackageJsonPatterns)(context.workspaceRoot, (f) => (0, fileutils_1.readJsonFile)((0, path_1.join)(context.workspaceRoot, f)));
+            const isInPackageJsonWorkspaces = (0, package_json_1.buildPackageJsonWorkspacesMatcher)(patterns);
+            const packageManagerCommand = (0, package_manager_1.getPackageManagerCommand)((0, package_manager_1.detectPackageManager)(context.workspaceRoot), context.workspaceRoot);
+            const result = (0, plugins_1.createNodesFromFiles)((packageJsonPath) => (0, package_json_1.createNodeFromPackageJson)(packageJsonPath, workspace_root_1.workspaceRoot, cache, isInPackageJsonWorkspaces(packageJsonPath), packageManagerCommand), configFiles, options, context);
+            writeCache();
+            return result;
+        },
+    ],
+};
+module.exports = plugin;
+module.exports.readPackageJsonConfigurationCache =
+    readPackageJsonConfigurationCache;

package/dist/release/changelog-renderer/index.d.ts

@@ -0,0 +1,110 @@
+import type { ChangelogChange } from '../../src/command-line/release/changelog';
+import type { NxReleaseConfig } from '../../src/command-line/release/config/config';
+import type { RemoteReleaseClient } from '../../src/command-line/release/utils/remote-release-clients/remote-release-client';
+/**
+ * Re-export for ease of use in custom changelog renderers.
+ */
+export type { ChangelogChange };
+/**
+ * The ChangelogRenderOptions are specific to each ChangelogRenderer implementation, and are taken
+ * from the user's nx.json configuration and passed as is into the ChangelogRenderer function.
+ */
+export type ChangelogRenderOptions = Record<string, unknown>;
+/**
+ * When versioning projects independently and enabling `"updateDependents": "auto"`, there could
+ * be additional dependency bump information that is not captured in the commit data, but that nevertheless
+ * should be included in the rendered changelog.
+ */
+export type DependencyBump = {
+    dependencyName: string;
+    newVersion: string;
+};
+/**
+ * The specific options available to the default implementation of the ChangelogRenderer that nx exports
+ * for the common case.
+ */
+export interface DefaultChangelogRenderOptions extends ChangelogRenderOptions {
+    /**
+     * Whether or not the commit authors should be added to the bottom of the changelog in a "Thank You"
+     * section. Defaults to true.
+     */
+    authors?: boolean;
+    /**
+     * If authors is enabled, controls whether or not to try to map the authors to their GitHub usernames
+     * using https://ungh.cc (from https://github.com/unjs/ungh) and, if needed, the GitHub search API via
+     * the gh CLI and the email addresses found in the commits.
+     * Defaults to true.
+     */
+    applyUsernameToAuthors?: boolean;
+    /**
+     * Whether or not the commit references (such as commit and/or PR links) should be included in the changelog.
+     * Defaults to true.
+     */
+    commitReferences?: boolean;
+    /**
+     * Whether or not to include the date in the version title. It can be set to false to disable it, or true to enable
+     * with the default of (YYYY-MM-DD). Defaults to true.
+     */
+    versionTitleDate?: boolean;
+}
+export default class DefaultChangelogRenderer {
+    protected changes: ChangelogChange[];
+    protected changelogEntryVersion: string;
+    protected project: string | null;
+    protected entryWhenNoChanges: string | false;
+    protected changelogRenderOptions: DefaultChangelogRenderOptions;
+    protected isVersionPlans: boolean;
+    protected dependencyBumps?: DependencyBump[];
+    protected conventionalCommitsConfig: NxReleaseConfig['conventionalCommits'];
+    protected relevantChanges: ChangelogChange[];
+    protected breakingChanges: string[];
+    protected additionalChangesForAuthorsSection: ChangelogChange[];
+    protected remoteReleaseClient: RemoteReleaseClient<unknown>;
+    /**
+     * A ChangelogRenderer class takes in the determined changes and other relevant metadata
+     * and returns a string, or a Promise of a string of changelog contents (usually markdown).
+     *
+     * @param {Object} config The configuration object for the ChangelogRenderer
+     * @param {ChangelogChange[]} config.changes The collection of changes to show in the changelog
+     * @param {string} config.changelogEntryVersion The version for which we are rendering the current changelog entry
+     * @param {string | null} config.project The name of specific project to generate a changelog entry for, or `null` if the overall workspace changelog
+     * @param {string | false} config.entryWhenNoChanges The (already interpolated) string to use as the changelog entry when there are no changes, or `false` if no entry should be generated
+     * @param {boolean} config.isVersionPlans Whether or not Nx release version plans are the source of truth for the changelog entry
+     * @param {ChangelogRenderOptions} config.changelogRenderOptions The options specific to the ChangelogRenderer implementation
+     * @param {DependencyBump[]} config.dependencyBumps Optional list of additional dependency bumps that occurred as part of the release, outside of the change data
+     * @param {NxReleaseConfig['conventionalCommits']} config.conventionalCommitsConfig The configuration for conventional commits
+     * @param {RemoteReleaseClient} config.remoteReleaseClient The remote release client to use for formatting references
+     */
+    constructor(config: {
+        changes: ChangelogChange[];
+        changelogEntryVersion: string;
+        project: string | null;
+        entryWhenNoChanges: string | false;
+        isVersionPlans: boolean;
+        changelogRenderOptions: DefaultChangelogRenderOptions;
+        dependencyBumps?: DependencyBump[];
+        conventionalCommitsConfig: NxReleaseConfig['conventionalCommits'];
+        remoteReleaseClient: RemoteReleaseClient<unknown>;
+    });
+    protected filterChanges(changes: ChangelogChange[], project: string | null): ChangelogChange[];
+    render(): Promise<string>;
+    protected preprocessChanges(): void;
+    protected shouldRenderEmptyEntry(): boolean;
+    protected renderEmptyEntry(): string;
+    protected renderVersionTitle(): string;
+    protected renderChangesByType(): string[];
+    protected hasBreakingChanges(): boolean;
+    protected renderBreakingChanges(): string[];
+    protected hasDependencyBumps(): boolean;
+    protected renderDependencyBumps(): string[];
+    protected shouldRenderAuthors(): boolean;
+    protected renderAuthors(): Promise<string[]>;
+    protected formatChange(change: ChangelogChange): string;
+    protected formatBreakingChangeBase(change: ChangelogChange): string;
+    protected formatBreakingChange(change: ChangelogChange): string;
+    protected groupChangesByType(): Record<string, ChangelogChange[]>;
+    protected groupChangesByScope(changes: ChangelogChange[]): Record<string, ChangelogChange[]>;
+    protected extractBreakingChangeExplanation(message: string): string | null;
+    private isBreakingChangeBoundary;
+    protected formatName(name?: string): string;
+}

package/dist/release/changelog-renderer/index.js

@@ -0,0 +1,381 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const semver_1 = require("semver");
+// Stripped from breaking change explanations (e.g. bot/session markers).
+const HtmlCommentRegex = /<!--[\s\S]*?-->/g;
+class DefaultChangelogRenderer {
+    /**
+     * A ChangelogRenderer class takes in the determined changes and other relevant metadata
+     * and returns a string, or a Promise of a string of changelog contents (usually markdown).
+     *
+     * @param {Object} config The configuration object for the ChangelogRenderer
+     * @param {ChangelogChange[]} config.changes The collection of changes to show in the changelog
+     * @param {string} config.changelogEntryVersion The version for which we are rendering the current changelog entry
+     * @param {string | null} config.project The name of specific project to generate a changelog entry for, or `null` if the overall workspace changelog
+     * @param {string | false} config.entryWhenNoChanges The (already interpolated) string to use as the changelog entry when there are no changes, or `false` if no entry should be generated
+     * @param {boolean} config.isVersionPlans Whether or not Nx release version plans are the source of truth for the changelog entry
+     * @param {ChangelogRenderOptions} config.changelogRenderOptions The options specific to the ChangelogRenderer implementation
+     * @param {DependencyBump[]} config.dependencyBumps Optional list of additional dependency bumps that occurred as part of the release, outside of the change data
+     * @param {NxReleaseConfig['conventionalCommits']} config.conventionalCommitsConfig The configuration for conventional commits
+     * @param {RemoteReleaseClient} config.remoteReleaseClient The remote release client to use for formatting references
+     */
+    constructor(config) {
+        this.changes = this.filterChanges(config.changes, config.project);
+        this.changelogEntryVersion = config.changelogEntryVersion;
+        this.project = config.project;
+        this.entryWhenNoChanges = config.entryWhenNoChanges;
+        this.isVersionPlans = config.isVersionPlans;
+        this.changelogRenderOptions = config.changelogRenderOptions;
+        this.dependencyBumps = config.dependencyBumps;
+        this.conventionalCommitsConfig = config.conventionalCommitsConfig;
+        this.remoteReleaseClient = config.remoteReleaseClient;
+        this.relevantChanges = [];
+        this.breakingChanges = [];
+        this.additionalChangesForAuthorsSection = [];
+    }
+    filterChanges(changes, project) {
+        if (project === null) {
+            return changes;
+        }
+        return changes.filter((c) => c.affectedProjects &&
+            (c.affectedProjects === '*' || c.affectedProjects.includes(project)));
+    }
+    async render() {
+        const sections = [];
+        this.preprocessChanges();
+        if (this.shouldRenderEmptyEntry()) {
+            return this.renderEmptyEntry();
+        }
+        sections.push([this.renderVersionTitle()]);
+        const changesByType = this.renderChangesByType();
+        if (changesByType.length > 0) {
+            sections.push(changesByType);
+        }
+        if (this.hasBreakingChanges()) {
+            sections.push(this.renderBreakingChanges());
+        }
+        if (this.hasDependencyBumps()) {
+            sections.push(this.renderDependencyBumps());
+        }
+        if (this.shouldRenderAuthors()) {
+            sections.push(await this.renderAuthors());
+        }
+        // Join sections with double newlines, and trim any extra whitespace
+        return sections
+            .filter((section) => section.length > 0)
+            .map((section) => section.join('\n').trim())
+            .join('\n\n')
+            .trim();
+    }
+    preprocessChanges() {
+        this.relevantChanges = [...this.changes];
+        this.breakingChanges = [];
+        this.additionalChangesForAuthorsSection = [];
+        // Filter out reverted changes
+        for (let i = this.relevantChanges.length - 1; i >= 0; i--) {
+            const change = this.relevantChanges[i];
+            if (change.type === 'revert' && change.revertedHashes) {
+                for (const revertedHash of change.revertedHashes) {
+                    const revertedCommitIndex = this.relevantChanges.findIndex((c) => c.shortHash && revertedHash.startsWith(c.shortHash));
+                    if (revertedCommitIndex !== -1) {
+                        this.relevantChanges.splice(revertedCommitIndex, 1);
+                        this.relevantChanges.splice(i, 1);
+                        i--;
+                        break;
+                    }
+                }
+            }
+        }
+        if (this.isVersionPlans) {
+            for (let i = this.relevantChanges.length - 1; i >= 0; i--) {
+                if (this.relevantChanges[i].isBreaking) {
+                    const change = this.relevantChanges[i];
+                    this.additionalChangesForAuthorsSection.push(change);
+                    const line = this.formatChange(change);
+                    this.breakingChanges.push(line);
+                    this.relevantChanges.splice(i, 1);
+                }
+            }
+        }
+        else {
+            for (const change of this.relevantChanges) {
+                if (change.isBreaking) {
+                    this.breakingChanges.push(this.formatBreakingChange(change));
+                }
+            }
+        }
+    }
+    shouldRenderEmptyEntry() {
+        return (this.relevantChanges.length === 0 &&
+            this.breakingChanges.length === 0 &&
+            !this.hasDependencyBumps());
+    }
+    renderEmptyEntry() {
+        if (this.hasDependencyBumps()) {
+            return [
+                this.renderVersionTitle(),
+                '',
+                ...this.renderDependencyBumps(),
+            ].join('\n');
+        }
+        else if (this.entryWhenNoChanges) {
+            return `${this.renderVersionTitle()}\n\n${this.entryWhenNoChanges}`;
+        }
+        return '';
+    }
+    renderVersionTitle() {
+        let isMajorVersion = true;
+        try {
+            isMajorVersion =
+                `${(0, semver_1.major)(this.changelogEntryVersion)}.0.0` ===
+                    this.changelogEntryVersion.replace(/^v/, '');
+        }
+        catch {
+            // Do nothing with the error
+            // Prevent non-semver versions from erroring out
+        }
+        let maybeDateStr = '';
+        if (this.changelogRenderOptions.versionTitleDate) {
+            const dateStr = new Date().toISOString().slice(0, 10);
+            maybeDateStr = ` (${dateStr})`;
+        }
+        return isMajorVersion
+            ? `# ${this.changelogEntryVersion}${maybeDateStr}`
+            : `## ${this.changelogEntryVersion}${maybeDateStr}`;
+    }
+    renderChangesByType() {
+        const markdownLines = [];
+        const typeGroups = this.groupChangesByType();
+        const changeTypes = this.conventionalCommitsConfig.types;
+        for (const type of Object.keys(changeTypes)) {
+            const group = typeGroups[type];
+            if (!group || group.length === 0) {
+                continue;
+            }
+            markdownLines.push('', `### ${changeTypes[type].changelog.title}`, '');
+            if (this.project === null) {
+                const changesGroupedByScope = this.groupChangesByScope(group);
+                const scopesSortedAlphabetically = Object.keys(changesGroupedByScope).sort();
+                for (const scope of scopesSortedAlphabetically) {
+                    const changes = changesGroupedByScope[scope];
+                    for (const change of changes.reverse()) {
+                        const line = this.formatChange(change);
+                        markdownLines.push(line);
+                        if (change.isBreaking && !this.isVersionPlans) {
+                            this.breakingChanges.push(this.formatBreakingChange(change));
+                        }
+                    }
+                }
+            }
+            else {
+                // For project-specific changelogs, maintain the original order
+                for (const change of group) {
+                    const line = this.formatChange(change);
+                    markdownLines.push(line);
+                    if (change.isBreaking && !this.isVersionPlans) {
+                        this.breakingChanges.push(this.formatBreakingChange(change));
+                    }
+                }
+            }
+        }
+        return markdownLines;
+    }
+    hasBreakingChanges() {
+        return this.breakingChanges.length > 0;
+    }
+    renderBreakingChanges() {
+        const uniqueBreakingChanges = Array.from(new Set(this.breakingChanges));
+        return ['### ⚠️  Breaking Changes', '', ...uniqueBreakingChanges];
+    }
+    hasDependencyBumps() {
+        return this.dependencyBumps && this.dependencyBumps.length > 0;
+    }
+    renderDependencyBumps() {
+        const markdownLines = ['', '### 🧱 Updated Dependencies', ''];
+        this.dependencyBumps.forEach(({ dependencyName, newVersion }) => {
+            markdownLines.push(`- Updated ${dependencyName} to ${newVersion}`);
+        });
+        return markdownLines;
+    }
+    shouldRenderAuthors() {
+        return this.changelogRenderOptions.authors;
+    }
+    async renderAuthors() {
+        const markdownLines = [];
+        const _authors = new Map();
+        for (const change of [
+            ...this.relevantChanges,
+            ...this.additionalChangesForAuthorsSection,
+        ]) {
+            if (!change.authors) {
+                continue;
+            }
+            for (const author of change.authors) {
+                const name = this.formatName(author.name);
+                if (!name || name.includes('[bot]')) {
+                    continue;
+                }
+                if (!_authors.has(name)) {
+                    _authors.set(name, { email: new Set() });
+                }
+                if (author.email) {
+                    _authors.get(name).email.add(author.email);
+                }
+            }
+        }
+        if (this.remoteReleaseClient.getRemoteRepoData() &&
+            this.changelogRenderOptions.applyUsernameToAuthors &&
+            // TODO: Explore if it is possible to support GitLab username resolution
+            this.remoteReleaseClient.remoteReleaseProviderName === 'GitHub') {
+            await this.remoteReleaseClient.applyUsernameToAuthors(_authors);
+        }
+        const authors = [..._authors.entries()].map((e) => ({
+            name: e[0],
+            ...e[1],
+        }));
+        if (authors.length > 0) {
+            markdownLines.push('', '### ' + '❤️ Thank You', '', ...authors
+                .sort((a, b) => a.name.localeCompare(b.name))
+                .map((i) => {
+                const username = i.username ? ` @${i.username}` : '';
+                return `- ${i.name}${username}`;
+            }));
+        }
+        return markdownLines;
+    }
+    formatChange(change) {
+        let description = change.description;
+        let extraLines = [];
+        let extraLinesStr = '';
+        if (description.includes('\n')) {
+            [description, ...extraLines] = description.split('\n');
+            const indentation = '  ';
+            extraLinesStr = (this.isVersionPlans
+                ? // Preserve newlines for version plan sources to allow author to maintain maximum control over final contents
+                    extraLines
+                : extraLines.filter((l) => l.trim().length > 0))
+                // Only add indentation to lines with content
+                .map((l) => (l.trim().length > 0 ? `${indentation}${l}` : ''))
+                .join('\n');
+        }
+        let changeLine = '- ' +
+            (!this.isVersionPlans && change.isBreaking ? '⚠️  ' : '') +
+            (!this.isVersionPlans && change.scope
+                ? `**${change.scope.trim()}:** `
+                : '') +
+            description;
+        if (this.remoteReleaseClient.getRemoteRepoData() &&
+            this.changelogRenderOptions.commitReferences &&
+            change.githubReferences) {
+            changeLine += this.remoteReleaseClient.formatReferences(change.githubReferences);
+        }
+        if (extraLinesStr) {
+            changeLine += (this.isVersionPlans ? '\n' : '\n\n') + extraLinesStr;
+        }
+        return changeLine;
+    }
+    formatBreakingChangeBase(change) {
+        let breakingLine = '- ';
+        if (change.scope) {
+            breakingLine += `**${change.scope.trim()}:** `;
+        }
+        if (change.description) {
+            breakingLine += `${change.description.trim()}`;
+        }
+        if (this.remoteReleaseClient.getRemoteRepoData() &&
+            this.changelogRenderOptions.commitReferences &&
+            change.githubReferences) {
+            breakingLine += ` ${this.remoteReleaseClient.formatReferences(change.githubReferences)}`;
+        }
+        return breakingLine;
+    }
+    formatBreakingChange(change) {
+        const explanation = this.extractBreakingChangeExplanation(change.body);
+        const baseLine = this.formatBreakingChangeBase(change);
+        if (!explanation) {
+            return baseLine;
+        }
+        const indentation = '  ';
+        let breakingLine = baseLine + `\n${indentation}`;
+        // Handle multi-line explanations
+        let explanationText = explanation;
+        let extraLines = [];
+        if (explanation.includes('\n')) {
+            [explanationText, ...extraLines] = explanation.split('\n');
+        }
+        breakingLine += explanationText;
+        // Add extra lines with indentation (matching formatChange behavior)
+        if (extraLines.length > 0) {
+            const extraLinesStr = extraLines
+                .filter((l) => l.trim().length > 0)
+                .map((l) => `${indentation}${l}`)
+                .join('\n');
+            if (extraLinesStr) {
+                breakingLine += '\n' + extraLinesStr;
+            }
+        }
+        return breakingLine;
+    }
+    groupChangesByType() {
+        const typeGroups = {};
+        for (const change of this.relevantChanges) {
+            typeGroups[change.type] = typeGroups[change.type] || [];
+            typeGroups[change.type].push(change);
+        }
+        return typeGroups;
+    }
+    groupChangesByScope(changes) {
+        const scopeGroups = {};
+        for (const change of changes) {
+            const scope = change.scope || '';
+            scopeGroups[scope] = scopeGroups[scope] || [];
+            scopeGroups[scope].push(change);
+        }
+        return scopeGroups;
+    }
+    extractBreakingChangeExplanation(message) {
+        if (!message) {
+            return null;
+        }
+        const breakingChangeIdentifier = 'BREAKING CHANGE:';
+        const startIndex = message.indexOf(breakingChangeIdentifier);
+        if (startIndex === -1) {
+            return null;
+        }
+        const startOfBreakingChange = startIndex + breakingChangeIdentifier.length;
+        // A squash-merged PR body can trail the note with template sections,
+        // trailers, and git metadata. Strip comments (they can appear anywhere),
+        // then keep lines until the first boundary.
+        const lines = message
+            .slice(startOfBreakingChange)
+            .replace(HtmlCommentRegex, '')
+            .split('\n');
+        // The rest of the "BREAKING CHANGE:" line is always kept; scan from the next.
+        const explanationLines = [lines[0]];
+        for (let i = 1; i < lines.length; i++) {
+            if (this.isBreakingChangeBoundary(lines[i])) {
+                break;
+            }
+            explanationLines.push(lines[i]);
+        }
+        return explanationLines.join('\n').trim();
+    }
+    isBreakingChangeBoundary(line) {
+        const trimmed = line.trim();
+        return (
+        // Markdown heading (e.g. "## Related issues")
+        /^#{1,6}\s/.test(trimmed) ||
+            // Horizontal rule / separator
+            /^-{3,}$/.test(trimmed) ||
+            /^Co-authored-by:/i.test(trimmed) ||
+            // Git metadata delimiter following the body
+            trimmed === '"');
+    }
+    formatName(name = '') {
+        return name
+            .split(' ')
+            .map((p) => p.trim())
+            .join(' ');
+    }
+}
+exports.default = DefaultChangelogRenderer;

package/dist/release/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @public Programmatic API for nx release
+ */
+export { ReleaseClient, release, releaseChangelog, releasePublish, releaseVersion, VersionActions, AfterAllProjectsVersioned, ResolveVersionForDependency, } from '../src/command-line/release';

package/dist/release/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionActions = exports.releaseVersion = exports.releasePublish = exports.releaseChangelog = exports.release = exports.ReleaseClient = void 0;
+/**
+ * @public Programmatic API for nx release
+ */
+var release_1 = require("../src/command-line/release");
+Object.defineProperty(exports, "ReleaseClient", { enumerable: true, get: function () { return release_1.ReleaseClient; } });
+Object.defineProperty(exports, "release", { enumerable: true, get: function () { return release_1.release; } });
+Object.defineProperty(exports, "releaseChangelog", { enumerable: true, get: function () { return release_1.releaseChangelog; } });
+Object.defineProperty(exports, "releasePublish", { enumerable: true, get: function () { return release_1.releasePublish; } });
+Object.defineProperty(exports, "releaseVersion", { enumerable: true, get: function () { return release_1.releaseVersion; } });
+Object.defineProperty(exports, "VersionActions", { enumerable: true, get: function () { return release_1.VersionActions; } });

package/dist/src/adapter/angular-json.d.ts

@@ -0,0 +1,10 @@
+import { ProjectsConfigurations } from '../config/workspace-json-project-json';
+import { NxPlugin } from '../project-graph/plugins';
+export declare const NX_ANGULAR_JSON_PLUGIN_NAME = "nx-angular-json-plugin";
+export declare const NxAngularJsonPlugin: NxPlugin;
+export default NxAngularJsonPlugin;
+export declare function shouldMergeAngularProjects(root: string, includeProjectsFromAngularJson: boolean): boolean;
+export declare function isAngularPluginInstalled(): boolean;
+export declare function toNewFormat(w: any): ProjectsConfigurations;
+export declare function toOldFormat(w: any): any;
+export declare function renamePropertyWithStableKeys(obj: any, from: string, to: string): void;