@ohos-ports/nx 23.2.1-beta.0 → 23.3.0-beta.0

package/dist/src/utils/path.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Coverts an os specific path to a unix style path. Use this when writing paths to config files.
+ * This should not be used to read files on disk because of the removal of Windows drive letters.
+ */
+export declare function normalizePath(osSpecificPath: string): string;
+/**
+ * Normalized path fragments and joins them. Use this when writing paths to config files.
+ * This should not be used to read files on disk because of the removal of Windows drive letters.
+ */
+export declare function joinPathFragments(...fragments: string[]): string;
+/**
+ * True when `relativePath` stays inside the directory it is resolved against.
+ * Absolute paths are rejected because `path.join` silently treats them as
+ * relative, so they would otherwise slip past a `..` check.
+ */
+export declare function isContainedRelativePath(relativePath: string): boolean;
+/**
+ * When running a script with the package manager (e.g. `npm run`), the package manager will
+ * traverse the directory tree upwards until it finds a `package.json` and will set `process.cwd()`
+ * to the folder where it found it. The actual working directory is stored in the INIT_CWD
+ * environment variable (see here: https://docs.npmjs.com/cli/v9/commands/npm-run-script#description).
+ *
+ * @returns The path to the current working directory.
+ */
+export declare function getCwd(): string;

package/dist/src/utils/path.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePath = normalizePath;
+exports.joinPathFragments = joinPathFragments;
+exports.isContainedRelativePath = isContainedRelativePath;
+exports.getCwd = getCwd;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const workspace_root_1 = require("./workspace-root");
+function removeWindowsDriveLetter(osSpecificPath) {
+    return osSpecificPath.replace(/^[a-zA-Z]:/, '');
+}
+/**
+ * Coverts an os specific path to a unix style path. Use this when writing paths to config files.
+ * This should not be used to read files on disk because of the removal of Windows drive letters.
+ */
+function normalizePath(osSpecificPath) {
+    return removeWindowsDriveLetter(osSpecificPath).split('\\').join('/');
+}
+/**
+ * Normalized path fragments and joins them. Use this when writing paths to config files.
+ * This should not be used to read files on disk because of the removal of Windows drive letters.
+ */
+function joinPathFragments(...fragments) {
+    return normalizePath(path.join(...fragments));
+}
+/**
+ * True when `relativePath` stays inside the directory it is resolved against.
+ * Absolute paths are rejected because `path.join` silently treats them as
+ * relative, so they would otherwise slip past a `..` check.
+ */
+function isContainedRelativePath(relativePath) {
+    if (path.isAbsolute(relativePath)) {
+        return false;
+    }
+    const normalized = path.normalize(relativePath);
+    return !(normalized === '..' ||
+        normalized.startsWith(`..${path.sep}`) ||
+        normalized.startsWith(`..${path.posix.sep}`));
+}
+/**
+ * When running a script with the package manager (e.g. `npm run`), the package manager will
+ * traverse the directory tree upwards until it finds a `package.json` and will set `process.cwd()`
+ * to the folder where it found it. The actual working directory is stored in the INIT_CWD
+ * environment variable (see here: https://docs.npmjs.com/cli/v9/commands/npm-run-script#description).
+ *
+ * @returns The path to the current working directory.
+ */
+function getCwd() {
+    return process.env.INIT_CWD?.startsWith(workspace_root_1.workspaceRoot)
+        ? process.env.INIT_CWD
+        : process.cwd();
+}

package/dist/src/utils/perf-hooks.d.ts

@@ -0,0 +1,19 @@
+import type { EventParameters } from '../analytics/analytics';
+
+export interface TrackedDetail extends EventParameters {
+  track: true;
+  [key: string]: string | number | boolean;
+}
+
+interface TrackedMeasureOptions {
+  start?: string | number;
+  end?: string | number;
+  duration?: number;
+  detail: TrackedDetail;
+}
+
+declare module 'perf_hooks' {
+  interface Performance {
+    measure(name: string, options: TrackedMeasureOptions): PerformanceMeasure;
+  }
+}

package/dist/src/utils/perf-logging.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/utils/perf-logging.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const perf_hooks_1 = require("perf_hooks");
+function isTrackedDetail(detail) {
+    return (typeof detail === 'object' &&
+        detail !== null &&
+        detail.track === true);
+}
+new perf_hooks_1.PerformanceObserver((list) => {
+    // observer is configured for 'measure' entries only (see .observe call below)
+    const entries = list.getEntries();
+    const logEnabled = process.env.NX_PERF_LOGGING === 'true';
+    const tracked = entries.filter((e) => isTrackedDetail(e.detail));
+    // Short-circuit before loading analytics / daemon logger (~60ms of native
+    // binding + module init) when there's nothing to do.
+    if (!logEnabled && tracked.length === 0)
+        return;
+    if (logEnabled) {
+        const { isOnDaemon } = require('../daemon/is-on-daemon');
+        const { serverLogger } = require('../daemon/logger');
+        const { logger } = require('./logger');
+        const log = isOnDaemon()
+            ? (msg) => serverLogger.log(msg)
+            : (msg) => logger.warn(msg);
+        for (const entry of entries) {
+            log(`Time taken for '${entry.name}' ${entry.duration}ms`);
+        }
+    }
+    if (tracked.length === 0)
+        return;
+    const { customDimensions, reportEvent } = require('../analytics');
+    if (!customDimensions)
+        return;
+    const dimensionValues = new Set(Object.values(customDimensions));
+    for (const entry of tracked) {
+        const { track, ...rest } = entry.detail;
+        const params = {
+            [customDimensions.duration]: entry.duration,
+        };
+        for (const [key, value] of Object.entries(rest)) {
+            if (dimensionValues.has(key))
+                params[key] = value;
+        }
+        reportEvent(entry.name, params);
+    }
+}).observe({ entryTypes: ['measure'] });

package/dist/src/utils/permission-errors.d.ts

@@ -0,0 +1,11 @@
+/**
+ * EACCES and EPERM are the two errnos that mean the operating system refused
+ * us, rather than that nothing was there or nothing was listening. What they
+ * call for differs by what was being opened -- a socket owned by another user,
+ * a sandbox denying a bind, a settings file the agent harness protects -- but
+ * they share the property that retrying cannot change the answer.
+ *
+ * Deliberately import-free: the plugin worker entry point and the daemon client
+ * both reach this, and neither can afford to pull a module graph in for it.
+ */
+export declare function isPermissionDenied(error: unknown): boolean;

package/dist/src/utils/permission-errors.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPermissionDenied = isPermissionDenied;
+/**
+ * EACCES and EPERM are the two errnos that mean the operating system refused
+ * us, rather than that nothing was there or nothing was listening. What they
+ * call for differs by what was being opened -- a socket owned by another user,
+ * a sandbox denying a bind, a settings file the agent harness protects -- but
+ * they share the property that retrying cannot change the answer.
+ *
+ * Deliberately import-free: the plugin worker entry point and the daemon client
+ * both reach this, and neither can afford to pull a module graph in for it.
+ */
+function isPermissionDenied(error) {
+    const code = error?.code;
+    return code === 'EACCES' || code === 'EPERM';
+}

package/dist/src/utils/plugin-cache-utils.d.ts

@@ -0,0 +1,82 @@
+/**
+ * On-disk format for plugin caches with LRU metadata.
+ */
+interface PluginCacheData<T> {
+    entries: Record<string, T>;
+    accessOrder: string[];
+}
+/**
+ * A plugin cache that tracks access order for LRU eviction.
+ *
+ * Uses explicit `get()` / `set()` / `has()` methods instead of a Proxy
+ * for easier debugging and predictable behavior.
+ *
+ * Access order is tracked via an append-only session log. Deduplication
+ * happens once at serialization time (`toSerializable()`), keeping per-access
+ * cost at O(1).
+ *
+ * Eviction splices the first half of the deduped access-order queue — the
+ * least recently used keys.
+ */
+export declare class PluginCache<T> {
+    private entries;
+    private accessOrder;
+    private cachePath;
+    /**
+     * Constructs a `PluginCache`. The `cachePath` is the single source of truth
+     * for both reading and writing — `writeToDisk()` writes to it.
+     *
+     * If `entries` is omitted, the cache is loaded from `cachePath` on disk.
+     * If `entries` is provided, those entries are used as the in-memory state
+     * and the on-disk file is not read (useful for tests or for seeding the
+     * cache with known state).
+     */
+    constructor(cachePath: string, entries?: Record<string, T>, accessOrder?: string[] | Set<string>);
+    private touch;
+    /**
+     * Returns the value for `key`, or `undefined` if not present.
+     * Tracks the access in the session log for LRU ordering.
+     */
+    get(key: string): T | undefined;
+    /**
+     * Sets `key` to `value` and tracks the access in the session log.
+     */
+    set(key: string, value: T): void;
+    /**
+     * Returns `true` if `key` exists in the cache.
+     * Does NOT track access — use this for existence checks that
+     * should not affect eviction order.
+     */
+    has(key: string): boolean;
+    /**
+     * Returns the serializable cache data (entries + accessOrder).
+     */
+    toSerializable(): PluginCacheData<T>;
+    /**
+     * Safely writes this cache to the path it was constructed with.
+     *
+     * Strategy:
+     * 1. Serialize to JSON
+     *    - RangeError (string too large): evict oldest 50% and retry
+     *    - Other errors (e.g. circular refs): skip straight to empty cache
+     * 2. Write the serialized string to disk — if this fails (fs error),
+     *    wipe the cache file so a corrupted file doesn't persist
+     * 3. On total serialization failure (even after eviction),
+     *    write an empty cache so the file is valid
+     */
+    writeToDisk(): void;
+    /**
+     * Evicts the oldest 50% of entries (front of the access-order queue)
+     * and returns the remaining entries + accessOrder as a plain object.
+     */
+    private evictOldestHalf;
+}
+/**
+ * Safely writes already-stringified content to a cache file on disk.
+ *
+ * Strategy:
+ * 1. Attempt mkdirSync + writeFileSync
+ * 2. On failure: remove existing cache file, log warning, return without throwing
+ */
+export declare function safeWriteFileCache(cachePath: string, content: string): void;
+export {};

package/dist/src/utils/plugin-cache-utils.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginCache = void 0;
+exports.safeWriteFileCache = safeWriteFileCache;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const fileutils_1 = require("./fileutils");
+const logger_1 = require("./logger");
+/**
+ * A plugin cache that tracks access order for LRU eviction.
+ *
+ * Uses explicit `get()` / `set()` / `has()` methods instead of a Proxy
+ * for easier debugging and predictable behavior.
+ *
+ * Access order is tracked via an append-only session log. Deduplication
+ * happens once at serialization time (`toSerializable()`), keeping per-access
+ * cost at O(1).
+ *
+ * Eviction splices the first half of the deduped access-order queue — the
+ * least recently used keys.
+ */
+class PluginCache {
+    /**
+     * Constructs a `PluginCache`. The `cachePath` is the single source of truth
+     * for both reading and writing — `writeToDisk()` writes to it.
+     *
+     * If `entries` is omitted, the cache is loaded from `cachePath` on disk.
+     * If `entries` is provided, those entries are used as the in-memory state
+     * and the on-disk file is not read (useful for tests or for seeding the
+     * cache with known state).
+     */
+    constructor(cachePath, entries, accessOrder) {
+        this.cachePath = cachePath;
+        if (entries !== undefined) {
+            this.entries = entries;
+            this.accessOrder =
+                accessOrder instanceof Set ? accessOrder : new Set(accessOrder ?? []);
+        }
+        else {
+            const loaded = loadFromDisk(cachePath);
+            this.entries = loaded.entries;
+            this.accessOrder = loaded.accessOrder;
+        }
+    }
+    touch(key) {
+        // Sets are guaranteed to maintain insertion order, so we can delete and re-add to move it to the end.
+        this.accessOrder.delete(key); // remove from current position in access order
+        this.accessOrder.add(key); // add to end of access order (most recently accessed)
+    }
+    /**
+     * Returns the value for `key`, or `undefined` if not present.
+     * Tracks the access in the session log for LRU ordering.
+     */
+    get(key) {
+        if (key in this.entries) {
+            this.touch(key);
+            return this.entries[key];
+        }
+        return undefined;
+    }
+    /**
+     * Sets `key` to `value` and tracks the access in the session log.
+     */
+    set(key, value) {
+        this.entries[key] = value;
+        this.touch(key);
+    }
+    /**
+     * Returns `true` if `key` exists in the cache.
+     * Does NOT track access — use this for existence checks that
+     * should not affect eviction order.
+     */
+    has(key) {
+        return key in this.entries;
+    }
+    /**
+     * Returns the serializable cache data (entries + accessOrder).
+     */
+    toSerializable() {
+        return {
+            entries: this.entries,
+            accessOrder: [...this.accessOrder],
+        };
+    }
+    /**
+     * Safely writes this cache to the path it was constructed with.
+     *
+     * Strategy:
+     * 1. Serialize to JSON
+     *    - RangeError (string too large): evict oldest 50% and retry
+     *    - Other errors (e.g. circular refs): skip straight to empty cache
+     * 2. Write the serialized string to disk — if this fails (fs error),
+     *    wipe the cache file so a corrupted file doesn't persist
+     * 3. On total serialization failure (even after eviction),
+     *    write an empty cache so the file is valid
+     */
+    writeToDisk() {
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(this.cachePath), { recursive: true });
+        let content;
+        try {
+            content = JSON.stringify({
+                entries: this.entries,
+                accessOrder: [...this.accessOrder],
+            });
+        }
+        catch (e) {
+            // RangeError → string too large, recoverable via eviction
+            if (e instanceof RangeError) {
+                const reduced = this.evictOldestHalf();
+                // Update in-memory state
+                this.entries = reduced.entries;
+                this.accessOrder = new Set(reduced.accessOrder);
+                try {
+                    content = JSON.stringify(reduced);
+                }
+                catch {
+                    // Still fails after eviction — fall through to empty cache
+                }
+            }
+            // Other errors (TypeError for circular refs, etc.) fall through to empty cache
+        }
+        // If serialization still fails, fall back to an empty cache
+        if (content === undefined) {
+            content = JSON.stringify({ entries: {}, accessOrder: [] });
+        }
+        // Attempt to write the serialized content to disk
+        try {
+            (0, node_fs_1.writeFileSync)(this.cachePath, content);
+        }
+        catch {
+            // Filesystem error — wipe cache so a corrupted file doesn't persist
+            tryRemoveFile(this.cachePath);
+        }
+    }
+    /**
+     * Evicts the oldest 50% of entries (front of the access-order queue)
+     * and returns the remaining entries + accessOrder as a plain object.
+     */
+    evictOldestHalf() {
+        const accessOrderArr = [...this.accessOrder];
+        if (accessOrderArr.length === 0)
+            return { entries: {}, accessOrder: [] };
+        const cutoff = Math.ceil(accessOrderArr.length / 2);
+        const remaining = accessOrderArr.slice(cutoff);
+        const entries = {};
+        for (const key of remaining) {
+            if (key in this.entries) {
+                entries[key] = this.entries[key];
+            }
+        }
+        return { entries, accessOrder: remaining };
+    }
+}
+exports.PluginCache = PluginCache;
+/**
+ * Loads plugin cache data from disk.
+ *
+ * Returns the current format `{ entries, accessOrder }` if it matches,
+ * otherwise returns an empty cache (no backward compat — stale caches
+ * are simply discarded).
+ */
+function loadFromDisk(cachePath) {
+    const empty = {
+        entries: {},
+        accessOrder: new Set(),
+    };
+    try {
+        if (process.env.NX_CACHE_PROJECT_GRAPH === 'false' ||
+            !(0, node_fs_1.existsSync)(cachePath)) {
+            return empty;
+        }
+        const raw = (0, fileutils_1.readJsonFile)(cachePath);
+        // Current format: { entries, accessOrder }
+        if (raw &&
+            typeof raw === 'object' &&
+            'entries' in raw &&
+            'accessOrder' in raw &&
+            Array.isArray(raw.accessOrder)) {
+            return { entries: raw.entries, accessOrder: new Set(raw.accessOrder) };
+        }
+        return empty;
+    }
+    catch {
+        return empty;
+    }
+}
+/**
+ * Safely writes already-stringified content to a cache file on disk.
+ *
+ * Strategy:
+ * 1. Attempt mkdirSync + writeFileSync
+ * 2. On failure: remove existing cache file, log warning, return without throwing
+ */
+function safeWriteFileCache(cachePath, content) {
+    try {
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(cachePath), { recursive: true });
+        (0, node_fs_1.writeFileSync)(cachePath, content);
+    }
+    catch (e) {
+        logger_1.logger.warn(`Failed to write cache at ${cachePath}: ${e instanceof Error ? e.message : 'unknown error'}. Removing existing cache file.`);
+        tryRemoveFile(cachePath);
+    }
+}
+// --- Internal helpers ---
+function tryRemoveFile(path) {
+    try {
+        (0, node_fs_1.unlinkSync)(path);
+    }
+    catch {
+        // Intentionally ignored — best effort
+    }
+}

package/dist/src/utils/plugin-progress-text.d.ts

@@ -0,0 +1 @@
+export declare function formatPluginProgressText(action: string, inProgressPlugins: ReadonlySet<string>): string;

package/dist/src/utils/plugin-progress-text.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatPluginProgressText = formatPluginProgressText;
+function formatPluginProgressText(action, inProgressPlugins) {
+    if (inProgressPlugins.size === 0) {
+        return '';
+    }
+    if (inProgressPlugins.size === 1) {
+        return `${action} with ${inProgressPlugins.values().next().value}`;
+    }
+    return [
+        `${action} with ${inProgressPlugins.size} plugins`,
+        ...Array.from(inProgressPlugins, (p) => `  - ${p}`),
+    ].join('\n');
+}

package/dist/src/utils/plugins/atomizer-utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Helper that tries to derive the name of the CI group, based on the related target name.
+ *
+ * This will work well when the CI target name follows the documented naming convention or similar (for e.g `test-ci`, `e2e-ci`, `ny-e2e-ci`, etc).
+ *
+ * For example, `test-ci` => `TEST (CI)`,  `e2e-ci` => `E2E (CI)`,  `my-e2e-ci` => `MY E2E (CI)`
+ *
+ * @param ciTargetName name of the CI target
+ * @returns the derived group name or `${ciTargetName.toUpperCase()} (CI)` if cannot be derived automatically
+ */
+export declare function deriveGroupNameFromTarget(ciTargetName: string | undefined): string;

package/dist/src/utils/plugins/atomizer-utils.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveGroupNameFromTarget = deriveGroupNameFromTarget;
+/**
+ * Helper that tries to derive the name of the CI group, based on the related target name.
+ *
+ * This will work well when the CI target name follows the documented naming convention or similar (for e.g `test-ci`, `e2e-ci`, `ny-e2e-ci`, etc).
+ *
+ * For example, `test-ci` => `TEST (CI)`,  `e2e-ci` => `E2E (CI)`,  `my-e2e-ci` => `MY E2E (CI)`
+ *
+ * @param ciTargetName name of the CI target
+ * @returns the derived group name or `${ciTargetName.toUpperCase()} (CI)` if cannot be derived automatically
+ */
+function deriveGroupNameFromTarget(ciTargetName) {
+    if (!ciTargetName) {
+        return null;
+    }
+    const parts = ciTargetName.split('-').map((v) => v.toUpperCase());
+    if (parts.length > 1) {
+        return `${parts.slice(0, -1).join(' ')} (${parts[parts.length - 1]})`;
+    }
+    return `${parts[0]} (CI)`; // default group name when there is a single segment
+}

package/dist/src/utils/plugins/core-plugins.d.ts

@@ -0,0 +1,6 @@
+export interface CorePlugin {
+    name: string;
+    capabilities: 'executors' | 'generators' | 'executors,generators' | 'graph';
+    link?: string;
+}
+export declare const CORE_PLUGINS: CorePlugin[];

package/dist/src/utils/plugins/core-plugins.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CORE_PLUGINS = void 0;
+exports.CORE_PLUGINS = [
+    {
+        name: '@nx/angular',
+        capabilities: 'executors,generators',
+    },
+    {
+        name: '@nx/cypress',
+        capabilities: 'executors,generators',
+    },
+    {
+        name: '@nx/detox',
+        capabilities: 'executors,generators',
+    },
+    {
+        name: '@nx/esbuild',
+        capabilities: 'executors,generators',
+    },
+    {
+        name: '@nx/expo',
+        capabilities: 'executors,generators',
+    },
+    {
+        name: '@nx/express',
+        capabilities: 'generators',
+    },
+    {
+        name: '@nx/gradle',
+        capabilities: 'graph',
+    },
+    {
+        name: '@nx/jest',
+        capabilities: 'executors,generators',
+    },
+    {
+        name: '@nx/js',
+        capabilities: 'executors,generators',
+    },
+    {
+        name: '@nx/eslint',
+        capabilities: 'executors,generators',
+    },
+    {
+        name: '@nx/oxlint',
+        capabilities: 'generators',
+    },
+    {
+        name: '@nx/nest',
+        capabilities: 'generators',
+    },
+    {
+        name: '@nx/next',
+        capabilities: 'executors,generators',
+    },
+    {
+        name: '@nx/node',
+        capabilities: 'executors,generators',
+    },
+    {
+        name: '@nx/nuxt',
+        capabilities: 'generators',
+    },
+    {
+        name: 'nx',
+        capabilities: 'executors',
+    },
+    {
+        name: '@nx/plugin',
+        capabilities: 'executors,generators',
+    },
+    {
+        name: '@nx/react',
+        capabilities: 'executors,generators',
+    },
+    {
+        name: '@nx/react-native',
+        capabilities: 'executors,generators',
+    },
+    {
+        name: '@nx/remix',
+        capabilities: 'executors,generators',
+    },
+    {
+        name: '@nx/rollup',
+        capabilities: 'executors,generators',
+    },
+    {
+        name: '@nx/rspack',
+        capabilities: 'executors,generators',
+    },
+    {
+        name: '@nx/storybook',
+        capabilities: 'executors,generators',
+    },
+    {
+        name: '@nx/vite',
+        capabilities: 'executors,generators',
+    },
+    {
+        name: '@nx/vue',
+        capabilities: 'generators',
+    },
+    {
+        name: '@nx/web',
+        capabilities: 'executors,generators',
+    },
+    {
+        name: '@nx/webpack',
+        capabilities: 'executors,generators',
+    },
+    {
+        name: '@nx/workspace',
+        capabilities: 'executors,generators',
+    },
+];

package/dist/src/utils/plugins/index.d.ts

@@ -0,0 +1,5 @@
+export { getInstalledPluginsAndCapabilities } from './installed-plugins';
+export { getLocalWorkspacePlugins } from './local-plugins';
+export { listPlugins, listAlsoAvailableCorePlugins, listPluginCapabilities, } from './output';
+export { getPluginCapabilities } from './plugin-capabilities';
+export { deriveGroupNameFromTarget } from './atomizer-utils';

package/dist/src/utils/plugins/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveGroupNameFromTarget = exports.getPluginCapabilities = exports.listPluginCapabilities = exports.listAlsoAvailableCorePlugins = exports.listPlugins = exports.getLocalWorkspacePlugins = exports.getInstalledPluginsAndCapabilities = void 0;
+var installed_plugins_1 = require("./installed-plugins");
+Object.defineProperty(exports, "getInstalledPluginsAndCapabilities", { enumerable: true, get: function () { return installed_plugins_1.getInstalledPluginsAndCapabilities; } });
+var local_plugins_1 = require("./local-plugins");
+Object.defineProperty(exports, "getLocalWorkspacePlugins", { enumerable: true, get: function () { return local_plugins_1.getLocalWorkspacePlugins; } });
+var output_1 = require("./output");
+Object.defineProperty(exports, "listPlugins", { enumerable: true, get: function () { return output_1.listPlugins; } });
+Object.defineProperty(exports, "listAlsoAvailableCorePlugins", { enumerable: true, get: function () { return output_1.listAlsoAvailableCorePlugins; } });
+Object.defineProperty(exports, "listPluginCapabilities", { enumerable: true, get: function () { return output_1.listPluginCapabilities; } });
+var plugin_capabilities_1 = require("./plugin-capabilities");
+Object.defineProperty(exports, "getPluginCapabilities", { enumerable: true, get: function () { return plugin_capabilities_1.getPluginCapabilities; } });
+var atomizer_utils_1 = require("./atomizer-utils");
+Object.defineProperty(exports, "deriveGroupNameFromTarget", { enumerable: true, get: function () { return atomizer_utils_1.deriveGroupNameFromTarget; } });