@teambit/config 0.0.0-0073f7d9944278e4b4a2f976f27cefc5909c8e11

package/dist/types.d.ts

@@ -0,0 +1,21 @@
+import { ExtensionDataEntry, ExtensionDataList } from '@teambit/legacy.extension-data';
+import { PathOsBased, PathOsBasedAbsolute } from '@teambit/toolbox.path.path';
+import { SetExtensionOptions } from './config.main.runtime';
+export type WriteOptions = {
+    dir?: PathOsBasedAbsolute;
+};
+/**
+ * An interface implemented by component host (workspace / scope) config file
+ * This used to be able to abstract the workspace/scope config.
+ */
+export interface HostConfig {
+    /**
+     * Path to the actual file
+     */
+    path: PathOsBased;
+    extensions: ExtensionDataList;
+    extension: (extensionId: string, ignoreVersion: boolean) => ExtensionDataEntry;
+    setExtension(extensionId: string, config: Record<string, any>, options: SetExtensionOptions): void;
+    write(opts: WriteOptions): Promise<void>;
+}
+export type ConfigType = 'workspace' | 'scope';

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import { ExtensionDataEntry, ExtensionDataList } from '@teambit/legacy.extension-data';\nimport { PathOsBased, PathOsBasedAbsolute } from '@teambit/toolbox.path.path';\n\nimport { SetExtensionOptions } from './config.main.runtime';\n\nexport type WriteOptions = {\n  dir?: PathOsBasedAbsolute;\n};\n\n/**\n * An interface implemented by component host (workspace / scope) config file\n * This used to be able to abstract the workspace/scope config.\n */\nexport interface HostConfig {\n  /**\n   * Path to the actual file\n   */\n  path: PathOsBased;\n\n  extensions: ExtensionDataList;\n\n  extension: (extensionId: string, ignoreVersion: boolean) => ExtensionDataEntry;\n\n  setExtension(extensionId: string, config: Record<string, any>, options: SetExtensionOptions): void;\n\n  write(opts: WriteOptions): Promise<void>;\n}\n\nexport type ConfigType = 'workspace' | 'scope';\n"],"mappings":"","ignoreList":[]}

package/dist/workspace-config.d.ts

@@ -0,0 +1,129 @@
+import { ComponentID } from '@teambit/component-id';
+import { AbstractVinyl } from '@teambit/component.sources';
+import { ILegacyWorkspaceConfig } from '@teambit/legacy.consumer-config';
+import { ExtensionDataList } from '@teambit/legacy.extension-data';
+import { PathOsBased, PathOsBasedAbsolute } from '@teambit/legacy.utils';
+import { SetExtensionOptions } from './config.main.runtime';
+import { HostConfig } from './types';
+export type LegacyInitProps = {
+    standAlone?: boolean;
+};
+export type WorkspaceConfigFileProps = {
+    $schema?: string;
+    $schemaVersion?: string;
+} & WorkspaceSettingsNewProps;
+export type ComponentScopeDirMapEntry = {
+    defaultScope?: string;
+    directory: string;
+};
+export type ComponentScopeDirMap = Array<ComponentScopeDirMapEntry>;
+export type WorkspaceExtensionProps = {
+    name?: string;
+    defaultScope?: string;
+    defaultDirectory?: string;
+    components?: ComponentScopeDirMap;
+};
+export type PackageManagerClients = 'npm' | 'yarn' | undefined;
+export interface DependencyResolverExtensionProps {
+    packageManager: PackageManagerClients;
+    strictPeerDependencies?: boolean;
+    extraArgs?: string[];
+    packageManagerProcessOptions?: any;
+    useWorkspaces?: boolean;
+    manageWorkspaces?: boolean;
+    externalPackageManager?: boolean;
+}
+export type WorkspaceSettingsNewProps = {
+    'teambit.workspace/workspace': WorkspaceExtensionProps;
+    'teambit.dependencies/dependency-resolver': DependencyResolverExtensionProps;
+};
+export declare class WorkspaceConfig implements HostConfig {
+    private data;
+    private _path;
+    private scopePath?;
+    raw?: any;
+    _extensions: ExtensionDataList;
+    isLegacy: boolean;
+    constructor(data: WorkspaceConfigFileProps, _path: PathOsBasedAbsolute, scopePath?: PathOsBasedAbsolute | undefined);
+    get path(): PathOsBased;
+    get extensions(): ExtensionDataList;
+    get extensionsIds(): string[];
+    private loadExtensions;
+    extension(extensionId: string, ignoreVersion: boolean): any;
+    setExtension(extensionId: string, config: Record<string, any>, options: SetExtensionOptions): any;
+    renameExtensionInRaw(oldExtId: string, newExtId: string): boolean;
+    removeExtension(extCompId: ComponentID): boolean;
+    getExistingKeyIgnoreVersion(id: ComponentID): string | undefined;
+    /**
+     * Create an instance of the WorkspaceConfig by data
+     *
+     * @static
+     * @param {WorkspaceConfigFileProps} data
+     * @returns
+     * @memberof WorkspaceConfig
+     */
+    static fromObject(data: WorkspaceConfigFileProps, workspaceJsoncPath: PathOsBased, scopePath?: PathOsBasedAbsolute): WorkspaceConfig;
+    /**
+     * Create an instance of the WorkspaceConfig by the workspace config template and override values
+     *
+     * @static
+     * @param {WorkspaceConfigFileProps} data values to override in the default template
+     * @returns
+     * @memberof WorkspaceConfig
+     */
+    static create(props: WorkspaceConfigFileProps, dirPath: PathOsBasedAbsolute, scopePath: PathOsBasedAbsolute, generator?: string): Promise<WorkspaceConfig>;
+    /**
+     * Ensure the given directory has a workspace config
+     * Load if existing and create new if not
+     *
+     * @static
+     * @param {PathOsBasedAbsolute} dirPath
+     * @param {WorkspaceConfigFileProps} [workspaceConfigProps={} as any]
+     * @returns {Promise<WorkspaceConfig>}
+     * @memberof WorkspaceConfig
+     */
+    static ensure(dirPath: PathOsBasedAbsolute, scopePath: PathOsBasedAbsolute, workspaceConfigProps?: WorkspaceConfigFileProps, generator?: string): Promise<WorkspaceConfig>;
+    static reset(dirPath: PathOsBasedAbsolute, resetHard: boolean): Promise<void>;
+    /**
+     * Get the path of the workspace.jsonc file by a containing folder
+     *
+     * @static
+     * @param {PathOsBased} dirPath containing dir of the workspace.jsonc file
+     * @returns {PathOsBased}
+     * @memberof WorkspaceConfig
+     */
+    static composeWorkspaceJsoncPath(dirPath: PathOsBased): PathOsBased;
+    static pathHasWorkspaceJsonc(dirPath: PathOsBased): Promise<boolean>;
+    /**
+     * Check if the given dir has workspace config (new or legacy)
+     * @param dirPath
+     */
+    static isExist(dirPath: PathOsBased): Promise<boolean | undefined>;
+    /**
+     * Load the workspace configuration if it's exist
+     *
+     * @static
+     * @param {PathOsBased} dirPath
+     * @returns {(Promise<WorkspaceConfig | undefined>)}
+     * @memberof WorkspaceConfig
+     */
+    static loadIfExist(dirPath: PathOsBased, scopePath?: PathOsBasedAbsolute): Promise<WorkspaceConfig | undefined>;
+    static _loadFromWorkspaceJsonc(workspaceJsoncPath: PathOsBased, scopePath?: string): Promise<WorkspaceConfig>;
+    write({ dir, reasonForChange }?: {
+        dir?: PathOsBasedAbsolute;
+        reasonForChange?: string;
+    }): Promise<void>;
+    backupConfigFile(reasonForChange?: string): Promise<void>;
+    private getBackupDir;
+    getBackupHistoryDir(): string;
+    getBackupMetadataFilePath(): string;
+    private getParsedHistoryMetadata;
+    toVinyl(workspaceDir: PathOsBasedAbsolute): Promise<AbstractVinyl[] | undefined>;
+    toLegacy(): ILegacyWorkspaceConfig;
+    /**
+     * Validates that external package manager configuration is compatible with other settings
+     */
+    validateExternalPackageManagerConfig(): void;
+}
+export declare function getWorkspaceConfigTemplateParsed(): Promise<Record<string, any>>;
+export declare function stringifyWorkspaceConfig(workspaceConfig: Record<string, any>): string;

package/dist/workspace-config.js

@@ -0,0 +1,464 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WorkspaceConfig = void 0;
+exports.getWorkspaceConfigTemplateParsed = getWorkspaceConfigTemplateParsed;
+exports.stringifyWorkspaceConfig = stringifyWorkspaceConfig;
+function _legacy() {
+  const data = require("@teambit/legacy.constants");
+  _legacy = function () {
+    return data;
+  };
+  return data;
+}
+function _component() {
+  const data = require("@teambit/component.sources");
+  _component = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy2() {
+  const data = require("@teambit/legacy.consumer-config");
+  _legacy2 = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy3() {
+  const data = require("@teambit/legacy.extension-data");
+  _legacy3 = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy4() {
+  const data = require("@teambit/legacy.logger");
+  _legacy4 = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy5() {
+  const data = require("@teambit/legacy.consumer");
+  _legacy5 = function () {
+    return data;
+  };
+  return data;
+}
+function _commentJson() {
+  const data = require("comment-json");
+  _commentJson = function () {
+    return data;
+  };
+  return data;
+}
+function fs() {
+  const data = _interopRequireWildcard(require("fs-extra"));
+  fs = function () {
+    return data;
+  };
+  return data;
+}
+function path() {
+  const data = _interopRequireWildcard(require("path"));
+  path = function () {
+    return data;
+  };
+  return data;
+}
+function _lodash() {
+  const data = require("lodash");
+  _lodash = function () {
+    return data;
+  };
+  return data;
+}
+function _workspace() {
+  const data = require("@teambit/workspace");
+  _workspace = function () {
+    return data;
+  };
+  return data;
+}
+function _exceptions() {
+  const data = require("./exceptions");
+  _exceptions = function () {
+    return data;
+  };
+  return data;
+}
+function _invalidConfigFile() {
+  const data = _interopRequireDefault(require("./exceptions/invalid-config-file"));
+  _invalidConfigFile = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+const INTERNAL_CONFIG_PROPS = ['$schema', '$schemaVersion', 'require'];
+class WorkspaceConfig {
+  constructor(data, _path, scopePath) {
+    this.data = data;
+    this._path = _path;
+    this.scopePath = scopePath;
+    _defineProperty(this, "raw", void 0);
+    _defineProperty(this, "_extensions", void 0);
+    _defineProperty(this, "isLegacy", void 0);
+    this.raw = data;
+    this.loadExtensions();
+  }
+  get path() {
+    return this._path;
+  }
+  get extensions() {
+    return this._extensions;
+  }
+  get extensionsIds() {
+    return Object.keys((0, _lodash().omit)(this.raw, INTERNAL_CONFIG_PROPS));
+  }
+  loadExtensions() {
+    const withoutInternalConfig = (0, _lodash().omit)(this.raw, INTERNAL_CONFIG_PROPS);
+    this._extensions = _legacy3().ExtensionDataList.fromConfigObject(withoutInternalConfig);
+  }
+  extension(extensionId, ignoreVersion) {
+    const existing = this.extensions.findExtension(extensionId, ignoreVersion);
+    return existing?.config;
+  }
+  setExtension(extensionId, config, options) {
+    const existing = this.extension(extensionId, options.ignoreVersion);
+    if (existing) {
+      if (options.mergeIntoExisting) {
+        // Use assign from comment-json to preserve comments when merging
+        (0, _commentJson().assign)(this.raw[extensionId], config);
+        this.loadExtensions();
+        return;
+      } else if (!options.overrideExisting) {
+        throw new (_exceptions().ExtensionAlreadyConfigured)(extensionId);
+      }
+    }
+    this.raw[extensionId] = config;
+    this.loadExtensions();
+  }
+  renameExtensionInRaw(oldExtId, newExtId) {
+    let isChanged = false;
+    if (this.raw[oldExtId]) {
+      this.raw[newExtId] = this.raw[oldExtId];
+      delete this.raw[oldExtId];
+      isChanged = true;
+    }
+    const generatorEnvs = this.raw?.['teambit.generator/generator']?.envs;
+    if (generatorEnvs && generatorEnvs.includes(oldExtId)) {
+      generatorEnvs.splice(generatorEnvs.indexOf(oldExtId), 1, newExtId);
+      isChanged = true;
+    }
+    return isChanged;
+  }
+  removeExtension(extCompId) {
+    const extId = extCompId.toStringWithoutVersion();
+    let isChanged = false;
+    const existingKey = this.getExistingKeyIgnoreVersion(extCompId);
+    if (existingKey) {
+      delete this.raw[existingKey];
+      isChanged = true;
+    }
+    const generatorEnvs = this.raw?.['teambit.generator/generator']?.envs;
+    if (generatorEnvs && generatorEnvs.includes(extId)) {
+      generatorEnvs.splice(generatorEnvs.indexOf(extId), 1);
+      isChanged = true;
+    }
+    if (isChanged) this.loadExtensions();
+    return isChanged;
+  }
+  getExistingKeyIgnoreVersion(id) {
+    const idStr = id.toStringWithoutVersion();
+    if (this.raw[idStr]) return idStr;
+    const keys = Object.keys(this.raw);
+    return keys.find(key => key.startsWith(`${idStr}@`));
+  }
+
+  /**
+   * Create an instance of the WorkspaceConfig by data
+   *
+   * @static
+   * @param {WorkspaceConfigFileProps} data
+   * @returns
+   * @memberof WorkspaceConfig
+   */
+  static fromObject(data, workspaceJsoncPath, scopePath) {
+    return new WorkspaceConfig(data, workspaceJsoncPath, scopePath);
+  }
+
+  /**
+   * Create an instance of the WorkspaceConfig by the workspace config template and override values
+   *
+   * @static
+   * @param {WorkspaceConfigFileProps} data values to override in the default template
+   * @returns
+   * @memberof WorkspaceConfig
+   */
+  static async create(props, dirPath, scopePath, generator) {
+    const template = await getWorkspaceConfigTemplateParsed();
+    // previously, we just did `assign(template, props)`, but it was replacing the entire workspace config with the "props".
+    // so for example, if the props only had defaultScope, it was removing the defaultDirectory.
+    const workspaceAspectConf = (0, _commentJson().assign)(template[_workspace().WorkspaceAspect.id], props[_workspace().WorkspaceAspect.id]);
+
+    // When external package manager mode is enabled, set conflicting properties to false in the template
+    const depResolverConf = (0, _commentJson().assign)(template['teambit.dependencies/dependency-resolver'], props['teambit.dependencies/dependency-resolver']);
+    if (depResolverConf.externalPackageManager) {
+      // Override template defaults to be compatible with external package manager mode
+      template['teambit.dependencies/dependency-resolver'] = template['teambit.dependencies/dependency-resolver'] || {};
+      template['teambit.dependencies/dependency-resolver'].rootComponent = false;
+    }
+    const merged = (0, _commentJson().assign)(template, {
+      [_workspace().WorkspaceAspect.id]: workspaceAspectConf,
+      'teambit.dependencies/dependency-resolver': depResolverConf
+    });
+    if (generator) {
+      const generators = generator.split(',').map(g => g.trim());
+      merged['teambit.generator/generator'] = {
+        envs: generators
+      };
+    }
+    const workspaceConfig = new WorkspaceConfig(merged, WorkspaceConfig.composeWorkspaceJsoncPath(dirPath), scopePath);
+
+    // Validate external package manager configuration
+    workspaceConfig.validateExternalPackageManagerConfig();
+    return workspaceConfig;
+  }
+
+  /**
+   * Ensure the given directory has a workspace config
+   * Load if existing and create new if not
+   *
+   * @static
+   * @param {PathOsBasedAbsolute} dirPath
+   * @param {WorkspaceConfigFileProps} [workspaceConfigProps={} as any]
+   * @returns {Promise<WorkspaceConfig>}
+   * @memberof WorkspaceConfig
+   */
+  static async ensure(dirPath, scopePath, workspaceConfigProps = {}, generator) {
+    try {
+      let workspaceConfig = await this.loadIfExist(dirPath, scopePath);
+      if (workspaceConfig) {
+        return workspaceConfig;
+      }
+      workspaceConfig = await this.create(workspaceConfigProps, dirPath, scopePath, generator);
+      return workspaceConfig;
+    } catch (err) {
+      if (err instanceof _invalidConfigFile().default) {
+        const workspaceConfig = this.create(workspaceConfigProps, dirPath, scopePath, generator);
+        return workspaceConfig;
+      }
+      throw err;
+    }
+  }
+  static async reset(dirPath, resetHard) {
+    const workspaceJsoncPath = WorkspaceConfig.composeWorkspaceJsoncPath(dirPath);
+    if (resetHard && workspaceJsoncPath) {
+      _legacy4().logger.info(`deleting the consumer workspace.jsonc file at ${workspaceJsoncPath}`);
+      await fs().remove(workspaceJsoncPath);
+    }
+  }
+
+  /**
+   * Get the path of the workspace.jsonc file by a containing folder
+   *
+   * @static
+   * @param {PathOsBased} dirPath containing dir of the workspace.jsonc file
+   * @returns {PathOsBased}
+   * @memberof WorkspaceConfig
+   */
+  static composeWorkspaceJsoncPath(dirPath) {
+    return path().join(dirPath, _legacy().WORKSPACE_JSONC);
+  }
+  static async pathHasWorkspaceJsonc(dirPath) {
+    const isExist = await fs().pathExists(WorkspaceConfig.composeWorkspaceJsoncPath(dirPath));
+    return isExist;
+  }
+
+  /**
+   * Check if the given dir has workspace config (new or legacy)
+   * @param dirPath
+   */
+  static async isExist(dirPath) {
+    const jsoncExist = await WorkspaceConfig.pathHasWorkspaceJsonc(dirPath);
+    if (jsoncExist) {
+      return true;
+    }
+    return _legacy2().LegacyWorkspaceConfig._isExist(dirPath);
+  }
+
+  /**
+   * Load the workspace configuration if it's exist
+   *
+   * @static
+   * @param {PathOsBased} dirPath
+   * @returns {(Promise<WorkspaceConfig | undefined>)}
+   * @memberof WorkspaceConfig
+   */
+  static async loadIfExist(dirPath, scopePath) {
+    const jsoncExist = await WorkspaceConfig.pathHasWorkspaceJsonc(dirPath);
+    if (jsoncExist) {
+      const jsoncPath = WorkspaceConfig.composeWorkspaceJsoncPath(dirPath);
+      const instance = await WorkspaceConfig._loadFromWorkspaceJsonc(jsoncPath, scopePath);
+      return instance;
+    }
+    return undefined;
+  }
+  static async _loadFromWorkspaceJsonc(workspaceJsoncPath, scopePath) {
+    const contentBuffer = await fs().readFile(workspaceJsoncPath);
+    let parsed;
+    try {
+      parsed = (0, _commentJson().parse)(contentBuffer.toString());
+    } catch {
+      throw new (_invalidConfigFile().default)(workspaceJsoncPath);
+    }
+    const workspaceConfig = WorkspaceConfig.fromObject(parsed, workspaceJsoncPath, scopePath);
+
+    // Validate external package manager configuration
+    workspaceConfig.validateExternalPackageManagerConfig();
+    return workspaceConfig;
+  }
+  async write({
+    dir,
+    reasonForChange
+  } = {}) {
+    const getCalculatedDir = () => {
+      if (dir) return dir;
+      return path().dirname(this._path);
+    };
+    const calculatedDir = getCalculatedDir();
+    const files = await this.toVinyl(calculatedDir);
+    const dataToPersist = new (_component().DataToPersist)();
+    if (files) {
+      dataToPersist.addManyFiles(files);
+      await this.backupConfigFile(reasonForChange);
+      await dataToPersist.persistAllToFS();
+    }
+  }
+  async backupConfigFile(reasonForChange) {
+    if (!this.scopePath) {
+      _legacy4().logger.error(`unable to backup workspace.jsonc file without scope path`);
+      return;
+    }
+    try {
+      const baseDir = this.getBackupHistoryDir();
+      await fs().ensureDir(baseDir);
+      const fileId = (0, _legacy5().currentDateAndTimeToFileName)();
+      const backupPath = path().join(baseDir, fileId);
+      await fs().copyFile(this._path, backupPath);
+      const metadataFile = this.getBackupMetadataFilePath();
+      await fs().appendFile(metadataFile, `${fileId} ${reasonForChange || ''}\n`);
+    } catch (err) {
+      if (err.code === 'ENOENT') return; // no such file or directory, meaning the .bitmap file doesn't exist (yet)
+      // it's a nice to have feature. don't kill the process if something goes wrong.
+      _legacy4().logger.error(`failed to backup workspace.jsonc`, err);
+    }
+  }
+  getBackupDir() {
+    if (!this.scopePath) throw new Error('unable to get backup dir without scope path');
+    return path().join(this.scopePath, 'workspace-config-history');
+  }
+  getBackupHistoryDir() {
+    return path().join(this.getBackupDir(), 'files');
+  }
+  getBackupMetadataFilePath() {
+    return path().join(this.getBackupDir(), 'metadata.txt');
+  }
+  async getParsedHistoryMetadata() {
+    let fileContent;
+    try {
+      fileContent = await fs().readFile(this.getBackupMetadataFilePath(), 'utf-8');
+    } catch (err) {
+      if (err.code === 'ENOENT') return {}; // no such file or directory, meaning the history-metadata file doesn't exist (yet)
+    }
+    const lines = fileContent?.split('\n') || [];
+    const metadata = {};
+    lines.forEach(line => {
+      const [fileId, ...reason] = line.split(' ');
+      if (!fileId) return;
+      metadata[fileId] = reason.join(' ');
+    });
+    return metadata;
+  }
+  async toVinyl(workspaceDir) {
+    const jsonStr = `${(0, _commentJson().stringify)(this.data, undefined, 2)}\n`;
+    const base = workspaceDir;
+    const fullPath = workspaceDir ? WorkspaceConfig.composeWorkspaceJsoncPath(workspaceDir) : this.path;
+    const jsonFile = new (_component().AbstractVinyl)({
+      base,
+      path: fullPath,
+      contents: Buffer.from(jsonStr)
+    });
+    return [jsonFile];
+  }
+  toLegacy() {
+    let componentsDefaultDirectory = this.extension('teambit.workspace/workspace', true)?.defaultDirectory;
+    if (componentsDefaultDirectory && !componentsDefaultDirectory.includes('{name}')) {
+      componentsDefaultDirectory = `${componentsDefaultDirectory}/{name}`;
+    }
+    return {
+      lang: _legacy().DEFAULT_LANGUAGE,
+      defaultScope: this.extension('teambit.workspace/workspace', true)?.defaultScope,
+      _useWorkspaces: this.extension('teambit.dependencies/dependency-resolver', true)?.useWorkspaces,
+      dependencyResolver: this.extension('teambit.dependencies/dependency-resolver', true),
+      packageManager: this.extension('teambit.dependencies/dependency-resolver', true)?.packageManager,
+      componentsDefaultDirectory,
+      _manageWorkspaces: this.extension('teambit.dependencies/dependency-resolver', true)?.manageWorkspaces,
+      extensions: this.extensions.toConfigObject(),
+      // @ts-ignore
+      path: this.path,
+      isLegacy: false,
+      write: ({
+        workspaceDir
+      }) => this.write.call(this, {
+        dir: workspaceDir
+      }),
+      toVinyl: this.toVinyl.bind(this),
+      _legacyPlainObject: () => undefined
+    };
+  }
+
+  /**
+   * Validates that external package manager configuration is compatible with other settings
+   */
+  validateExternalPackageManagerConfig() {
+    const depResolverExt = this.extension('teambit.dependencies/dependency-resolver', true);
+    if (!depResolverExt?.externalPackageManager) {
+      return; // No validation needed if external package manager is not enabled
+    }
+    const conflicts = [];
+
+    // Check dependency-resolver aspect conflicts
+    if (depResolverExt?.rootComponent === true) {
+      conflicts.push('rootComponent cannot be true when externalPackageManager is enabled');
+    }
+    if (conflicts.length > 0) {
+      throw new Error(`External package manager mode is incompatible with the following settings:\n${conflicts.map(c => `  - ${c}`).join('\n')}\n\nPlease set these properties to false or remove them from your workspace.jsonc`);
+    }
+  }
+}
+exports.WorkspaceConfig = WorkspaceConfig;
+async function getWorkspaceConfigTemplateParsed() {
+  let fileContent;
+  try {
+    fileContent = await fs().readFile(path().join(__dirname, 'workspace-template.jsonc'));
+  } catch (err) {
+    if (err.code !== 'ENOENT') throw err;
+    // when the extension is compiled by tsc, it doesn't copy .jsonc files into the dists, grab it from src
+    fileContent = await fs().readFile(path().join(__dirname, '..', 'workspace-template.jsonc'));
+  }
+  return (0, _commentJson().parse)(fileContent.toString());
+}
+function stringifyWorkspaceConfig(workspaceConfig) {
+  return (0, _commentJson().stringify)(workspaceConfig, undefined, 2);
+}
+
+//# sourceMappingURL=workspace-config.js.map