@jakubmazanec/carson 0.1.0-c5ebb6f → 0.1.0-next.336fe21

package/src/template/internals/uninsertUsingTemplateRender.ts

@@ -4,6 +4,7 @@ import path from 'node:path';
 
 import {prettify} from './prettify.js';
 import {type TemplateRenderSnapshot} from './TemplateRenderSnapshot.js';
+import {CarsonTemplateError} from '../CarsonTemplateError.js';
 import {type TemplateRender} from '../TemplateRender.js';
 
 export async function uninsertUsingTemplateRender(
@@ -33,7 +34,16 @@ export async function uninsertUsingTemplateRender(
     }
 
     default: {
-      throw new Error(`File extension "${extension}" is not supported!`);
+      throw new CarsonTemplateError('STRATEGY_UNSUPPORTED_EXTENSION', {
+        messageParameters: [
+          templateRender.attributes.strategy,
+          templateRender.template.path,
+          extension,
+        ],
+        data: {
+          path: templateRender.template.path,
+        },
+      });
     }
   }
 }

package/src/template/internals/unmerge.ts

@@ -1,5 +1,5 @@
 /**
- * Reverts {@linkcode merge}.
+ * Reverts {@link merge}.
  */
 export function unmerge(a: unknown, b: unknown) {
   if (b === undefined || b == null) {

package/src/template/internals/unmergeUsingTemplateRender.ts

@@ -7,6 +7,7 @@ import yaml from 'yaml';
 import {prettify} from './prettify.js';
 import {type TemplateRenderSnapshot} from './TemplateRenderSnapshot.js';
 import {unmerge} from './unmerge.js';
+import {CarsonTemplateError} from '../CarsonTemplateError.js';
 import {type TemplateRender} from '../TemplateRender.js';
 
 export async function unmergeUsingTemplateRender(
@@ -38,7 +39,16 @@ export async function unmergeUsingTemplateRender(
     }
 
     default: {
-      throw new Error(`File extension "${extension}" is not supported!`);
+      throw new CarsonTemplateError('STRATEGY_UNSUPPORTED_EXTENSION', {
+        messageParameters: [
+          templateRender.attributes.strategy,
+          templateRender.template.path,
+          extension,
+        ],
+        data: {
+          path: templateRender.template.path,
+        },
+      });
     }
   }
 }

package/src/template/renderCarsonTemplate.ts

@@ -1,6 +1,13 @@
+import {pathToPosixPath} from '@jakubmazanec/fs-utils';
 import _ from 'lodash';
+import path from 'node:path';
 
-import {importCarsonTemplate, readCarsonTemplate} from './internals.js';
+import {
+  importCarsonTemplate,
+  parseCarsonTemplateId,
+  readCarsonTemplate,
+  resolveModule,
+} from './internals.js';
 import {type TemplateData} from './TemplateData.js';
 import {type TemplateRenders} from './TemplateRenders.js';
 
@@ -9,22 +16,36 @@ export type RenderCarsonTemplateOptions = {
   templateData: TemplateData;
 };
 
+/**
+ * Renders a Carson template with provided template data.
+ */
 export async function renderCarsonTemplate(
   options: RenderCarsonTemplateOptions,
 ): Promise<TemplateRenders> {
+  let [moduleId] = parseCarsonTemplateId(options.templateId);
+  let modulePath = await resolveModule(moduleId);
   let template = await readCarsonTemplate(options.templateId);
   let templateModule = await importCarsonTemplate(options.templateId);
   let templateRenders: TemplateRenders = [];
 
   for (let file of template.files) {
     templateRenders.push(
-      ...(await file.render(
-        {
-          ...templateModule,
-          ...options.templateData,
+      ...(
+        await file.render(
+          {
+            ...templateModule,
+            ...options.templateData,
+          },
+          {disablePrettier: true},
+        )
+      ).map((templateRender) => ({
+        ...templateRender,
+        template: {
+          path: pathToPosixPath(
+            `${moduleId}/${path.relative(modulePath, file.path ?? modulePath)}`,
+          ),
         },
-        {disablePrettier: true},
-      )),
+      })),
     );
   }
 

package/src/template.ts

@@ -1,6 +1,7 @@
 export * from './template/applyTemplateRenders.js';
 export * from './template/CarsonTemplate.js';
 export * from './template/CarsonTemplateConfig.js';
+export * from './template/CarsonTemplateError.js';
 export * from './template/renderCarsonTemplate.js';
 export * from './template/TemplateAttributes.js';
 export * from './template/TemplateData.js';

package/src/workspace/Project.ts

@@ -17,7 +17,7 @@ import {applyTemplateRenders} from '../template/applyTemplateRenders.js';
 import {renderCarsonTemplate} from '../template/renderCarsonTemplate.js';
 
 /**
- * Project represent a self-contained piece of software (e.g. a package, or an app) that is part of a {@linkcode Workspace}. Currently only Node.js projects are supported.
+ * Project represent a self-contained piece of software (e.g. a package, or an app) that is part of a {@link Workspace}. Currently only Node.js projects are supported.
  *
  * @typeParam M If true, the project belongs to a multi-project workspace.
  */
@@ -37,7 +37,7 @@ export class Project<M extends boolean = true> {
   /** Parsed project `package.json` file; if it's not found, the default is an empty object. */
   packageJson: PackageJson;
 
-  /** Parent {@linkcode Workspace} instance. */
+  /** Parent {@link Workspace} instance. */
   workspace: Workspace<M>;
 
   /** Errors found during reading from the file system. */
@@ -99,7 +99,17 @@ export class Project<M extends boolean = true> {
       workspace,
     });
 
-    await ensureEmptyDirectory(project.path);
+    try {
+      await ensureEmptyDirectory(project.path);
+    } catch {
+      throw new ProjectError('PROJECT_PATH_NOT_EMPTY', {
+        messageParameters: [project.path],
+        data: {
+          path: project.path,
+        },
+      });
+    }
+
     await saveProjectConfig({projectPath: project.path, projectConfig: {template: templateId}});
 
     let templateRenders = await renderCarsonTemplate({
@@ -219,7 +229,9 @@ export class Project<M extends boolean = true> {
 
   async update({args}: ProjectUpdateOptions): Promise<this> {
     if (!this.config.template) {
-      throw new Error('Template ID is missing in the project config!');
+      throw new ProjectError('MISSING_CARSON_TEMPLATE_ID', {
+        messageParameters: [path.join(this.path, CARSON_CONFIG_DIRECTORY, PROJECT_CONFIG_FILENAME)],
+      });
     }
 
     let templateRenders = await renderCarsonTemplate({

package/src/workspace/ProjectConfig.ts

@@ -6,4 +6,7 @@ export const projectConfigSchema = z
   })
   .catchall(z.unknown());
 
+/**
+ * A project configuration.
+ */
 export type ProjectConfig = z.infer<typeof projectConfigSchema>;

package/src/workspace/ProjectCreateOptions.ts

@@ -1,5 +1,8 @@
 import {type Workspace} from './Workspace.js';
 
+/**
+ * {@link Project.create | Project.create} options parameter.
+ */
 export type ProjectCreateOptions<M extends boolean> = {
   templateId: string;
   workspace: Workspace<M>;

package/src/workspace/ProjectError.ts

@@ -1,12 +1,17 @@
 import {createCustomErrorWithData} from '@jakubmazanec/error';
 import {type ZodIssue} from 'zod';
 
+/**
+ * A subclass of `Error` that indicates a project failure.
+ */
 export const ProjectError = createCustomErrorWithData(
   'ProjectError',
   {
     INVALID_PACKAGE_JSON: 'Invalid package.json file "{0}".',
     INVALID_PROJECT_CONFIG: 'Invalid project config file "{0}".',
     NO_SUCH_PROJECT_PATH: 'Project path "{0}" doesn\'t exist.',
+    PROJECT_PATH_NOT_EMPTY: 'Project path "{0}" must be an empty directory.',
+    MISSING_CARSON_TEMPLATE_ID: 'Project config "{0}" is missing the Carson template ID.',
   },
   class ProjectErrorData {
     path?: string;

package/src/workspace/ProjectOptions.ts

@@ -5,7 +5,7 @@ import {type ProjectError} from './ProjectError.js';
 import {type Workspace} from './Workspace.js';
 
 /**
- * New project options.
+ * {@link Project.constructor | Project constructor} options parameter.
  */
 export type ProjectOptions<M extends boolean> = {
   path: string;

package/src/workspace/ProjectUpdateOptions.ts

@@ -1,3 +1,6 @@
+/**
+ * {@link Project.update | Project.update} options parameter.
+ */
 export type ProjectUpdateOptions = {
   args: Record<string, unknown>;
 };

package/src/workspace/Workspace.ts

@@ -6,7 +6,12 @@ import json5 from 'json5';
 import path from 'node:path';
 import {z} from 'zod';
 
-import {getPackageJsonWorkspaces, getRepositoryBranches, getRepositoryUrl} from './internals.js';
+import {
+  compareProjectPath,
+  getPackageJsonWorkspaces,
+  getRepositoryBranches,
+  getRepositoryUrl,
+} from './internals.js';
 import {Project} from './Project.js';
 import {saveWorkspaceConfig} from './saveWorkspaceConfig.js';
 import {workspaceConfigSchema} from './WorkspaceConfig.js';
@@ -15,6 +20,7 @@ import {type WorkspaceCreateOptions} from './WorkspaceCreateOptions.js';
 import {type WorkspaceCreateProjectOptions} from './WorkspaceCreateProjectOptions.js';
 import {WorkspaceDependencies} from './WorkspaceDependencies.js';
 import {WorkspaceError} from './WorkspaceError.js';
+import {type WorkspaceFindAndReadOptions} from './WorkspaceFindAndReadOptions.js';
 import type {WorkspaceOptions} from './WorkspaceOptions.js';
 import {type WorkspacePackageJson} from './WorkspacePackageJson.js';
 import type {WorkspaceProjectGlobs} from './WorkspaceProjectGlobs.js';
@@ -26,7 +32,7 @@ import {applyTemplateRenders} from '../template/applyTemplateRenders.js';
 import {renderCarsonTemplate} from '../template/renderCarsonTemplate.js';
 
 /**
- * Workspace represent a directory, usually a git repository, that contains {@linkcode Project} instances.
+ * Workspace represent a directory, usually a git repository, that contains {@link Project} instances.
  *
  * @typeParam M If true, the workspace is multi-project workspace (so-called "monorepo").
  */
@@ -81,14 +87,12 @@ export class Workspace<M extends boolean = true> {
         this.projectGlobs = [] as string[] as WorkspaceProjectGlobs<M>;
       }
 
+      this.projects = [] as Array<Project<M>> as WorkspaceProjects<M>;
+
       let {projects} = options as WorkspaceOptions<true>;
 
       if (projects) {
-        this.projects = projects.map(
-          (project) => new Project({...project, workspace: this}),
-        ) as WorkspaceProjects<M>;
-      } else {
-        this.projects = [] as Array<Project<M>> as WorkspaceProjects<M>;
+        this.addProjects(projects.map((project) => new Project({...project, workspace: this})));
       }
 
       let packageJsonOption = (options as WorkspaceOptions<true>).packageJson;
@@ -104,19 +108,12 @@ export class Workspace<M extends boolean = true> {
       this.isMultiProject = false as M;
       this.projectGlobs = null as M extends true ? string[] : null;
       this.packageJson = null as M extends true ? PackageJson : null;
+      this.projects = [] as Array<Project<M>> as WorkspaceProjects<M>;
 
       let {projects} = options as WorkspaceOptions<false>;
 
       if (projects) {
-        this.projects = projects.map(
-          (project) => new Project({...project, workspace: this}),
-        ) as WorkspaceProjects<M>;
-
-        if ((this.projects[0] as Project<false>).path !== this.path) {
-          throw new WorkspaceError('PATH_MISMATCH');
-        }
-      } else {
-        this.projects = [] as Array<Project<M>> as WorkspaceProjects<M>;
+        this.addProjects(projects.map((project) => new Project({...project, workspace: this})));
       }
     }
 
@@ -147,6 +144,7 @@ export class Workspace<M extends boolean = true> {
       }
     }
 
+    this.sortProjects();
     this.updateDependencies();
   }
 
@@ -154,7 +152,7 @@ export class Workspace<M extends boolean = true> {
    * Creates new workspace within the file system.
    *
    * @param options Options.
-   * @returns The new workspace
+   * @returns The new workspace.
    */
   static async create({args, path: workspacePath, templateId}: WorkspaceCreateOptions) {
     // TODO: test that workspace returned by this method has the same value of isMultiProject when the same workspace is after its creation re-read with .read()
@@ -165,7 +163,17 @@ export class Workspace<M extends boolean = true> {
       },
     });
 
-    await ensureEmptyDirectory(workspace.path);
+    try {
+      await ensureEmptyDirectory(workspace.path);
+    } catch {
+      throw new WorkspaceError('WORKSPACE_PATH_NOT_EMPTY', {
+        messageParameters: [workspace.path],
+        data: {
+          path: workspace.path,
+        },
+      });
+    }
+
     await saveWorkspaceConfig({
       workspacePath: workspace.path,
       workspaceConfig: {template: templateId},
@@ -293,14 +301,42 @@ export class Workspace<M extends boolean = true> {
   /**
    * Traverses file system up from the search path and tries to find and read a workspace.
    */
-  static async findAndRead(searchPath: string): Promise<Workspace | Workspace<false> | undefined> {
+  static async findAndRead<O extends WorkspaceFindAndReadOptions | undefined = undefined>(
+    searchPath: string,
+    options?: O,
+  ): Promise<
+    O extends undefined
+      ? Workspace | Workspace<false> | undefined
+      : NonNullable<O>['throwIfNotFound'] extends true
+      ? Workspace | Workspace<false>
+      : Workspace | Workspace<false> | undefined
+  > {
     let workspacePath = await Workspace.find(searchPath);
 
     if (workspacePath) {
-      return Workspace.read(workspacePath);
+      return Workspace.read(workspacePath) as Promise<
+        O extends undefined
+          ? Workspace | Workspace<false> | undefined
+          : NonNullable<O>['throwIfNotFound'] extends true
+          ? Workspace | Workspace<false>
+          : Workspace | Workspace<false> | undefined
+      >;
+    } else if (options?.throwIfNotFound) {
+      throw new WorkspaceError('NO_WORKSPACE_FOUND', {
+        messageParameters: [searchPath],
+        data: {
+          path: searchPath,
+        },
+      });
     }
 
-    return undefined;
+    return undefined as unknown as Promise<
+      O extends undefined
+        ? Workspace | Workspace<false> | undefined
+        : NonNullable<O>['throwIfNotFound'] extends true
+        ? Workspace | Workspace<false>
+        : Workspace | Workspace<false> | undefined
+    >;
   }
 
   async read(): Promise<this> {
@@ -390,6 +426,10 @@ export class Workspace<M extends boolean = true> {
           url: repositoryUrl,
           branches: repositoryBranches ?? [],
         };
+      } else if (repositoryBranches) {
+        this.repository = {
+          branches: repositoryBranches,
+        };
       }
 
       await this.readProjects();
@@ -406,6 +446,10 @@ export class Workspace<M extends boolean = true> {
         url: repositoryUrl,
         branches: repositoryBranches ?? [],
       };
+    } else if (repositoryBranches) {
+      this.repository = {
+        branches: repositoryBranches,
+      };
     }
 
     await this.readProjects();
@@ -415,7 +459,11 @@ export class Workspace<M extends boolean = true> {
 
   async update({args}: WorkspaceUpdateOptions): Promise<this> {
     if (!this.config.template) {
-      throw new Error('Templat ID is missing in the workspace config!');
+      throw new WorkspaceError('MISSING_CARSON_TEMPLATE_ID', {
+        messageParameters: [
+          path.join(this.path, CARSON_CONFIG_DIRECTORY, WORKSPACE_CONFIG_FILENAME),
+        ],
+      });
     }
 
     let templateRenders = await renderCarsonTemplate({
@@ -453,16 +501,24 @@ export class Workspace<M extends boolean = true> {
     projectName,
     args,
   }: WorkspaceCreateProjectOptions): Promise<Project<M>> {
-    if (this.projects.some((project) => projectPath === project.path)) {
-      throw new Error('Project with same path already exists!');
+    let resolvedProjectPath = path.resolve(projectPath);
+
+    if (this.projects.some((project) => resolvedProjectPath === project.path)) {
+      throw new WorkspaceError('DUPLICATE_PROJECT_PATH', {
+        messageParameters: [resolvedProjectPath],
+      });
     }
 
     if (this.projects.some((project) => projectName === project.name)) {
-      throw new Error('Project with same name already exists!');
+      throw new WorkspaceError('DUPLICATE_PROJECT_NAME', {messageParameters: [projectName]});
     }
 
     if (!this.isMultiProject && this.projects.length >= 1) {
-      throw new Error('Only multi-project Workspace can have more than 1 project!');
+      throw new WorkspaceError('TOO_MANY_PROJECTS');
+    }
+
+    if (!this.isMultiProject && projectPath !== this.path) {
+      throw new WorkspaceError('PATH_MISMATCH');
     }
 
     let newProject = await Project.create({
@@ -478,24 +534,59 @@ export class Workspace<M extends boolean = true> {
     return newProject;
   }
 
-  addProject(newProject: Project<M>): Project<M> {
+  addProject(newProject: Project<M>): this {
     if (this.projects.some((project) => newProject.path === project.path)) {
-      throw new Error('Project with same path already exists!');
+      throw new WorkspaceError('DUPLICATE_PROJECT_PATH', {
+        messageParameters: [newProject.path],
+      });
     }
 
     if (this.projects.some((project) => newProject.name === project.name)) {
-      throw new Error('Project with same name already exists!');
+      throw new WorkspaceError('DUPLICATE_PROJECT_NAME', {messageParameters: [newProject.name]});
     }
 
     if (!this.isMultiProject && this.projects.length >= 1) {
-      throw new Error('Only multi-project Workspace can have more than 1 project!');
+      throw new WorkspaceError('TOO_MANY_PROJECTS');
+    }
+
+    if (!this.isMultiProject && newProject.path !== this.path) {
+      throw new WorkspaceError('PATH_MISMATCH');
     }
 
     this.projects.push(newProject);
     this.sortProjects();
     this.updateDependencies();
 
-    return newProject;
+    return this;
+  }
+
+  addProjects(newProjects: Array<Project<M>>): this {
+    for (let newProject of newProjects) {
+      if (this.projects.some((project) => newProject.path === project.path)) {
+        throw new WorkspaceError('DUPLICATE_PROJECT_PATH', {
+          messageParameters: [newProject.path],
+        });
+      }
+
+      if (this.projects.some((project) => newProject.name === project.name)) {
+        throw new WorkspaceError('DUPLICATE_PROJECT_NAME', {messageParameters: [newProject.name]});
+      }
+
+      if (!this.isMultiProject && this.projects.length >= 1) {
+        throw new WorkspaceError('TOO_MANY_PROJECTS');
+      }
+
+      if (!this.isMultiProject && newProject.path !== this.path) {
+        throw new WorkspaceError('PATH_MISMATCH');
+      }
+
+      this.projects.push(newProject);
+    }
+
+    this.sortProjects();
+    this.updateDependencies();
+
+    return this;
   }
 
   async readProjects(): Promise<Array<Project<M>>> {
@@ -523,19 +614,11 @@ export class Workspace<M extends boolean = true> {
     return this.projects;
   }
 
-  private sortProjects(): void {
-    this.projects.sort((projectA, projectB) => {
-      if (projectA.path < projectB.path) {
-        return -1;
-      } else if (projectA.path > projectB.path) {
-        return 1;
-      }
-
-      return 0;
-    });
+  protected sortProjects(): void {
+    this.projects.sort(compareProjectPath);
   }
 
-  private updateDependencies(): void {
+  protected updateDependencies(): void {
     this.dependencies = WorkspaceDependencies.fromWorkspace(this);
     this.devDependencies = WorkspaceDependencies.fromWorkspace(this, {
       includeOnlyDevDependencies: true,

package/src/workspace/WorkspaceConfig.ts

@@ -6,4 +6,7 @@ export const workspaceConfigSchema = z
   })
   .catchall(z.unknown());
 
+/**
+ * A workspace configuration.
+ */
 export type WorkspaceConfig = z.infer<typeof workspaceConfigSchema>;

package/src/workspace/WorkspaceCreateOptions.ts

@@ -1,3 +1,6 @@
+/**
+ * {@link Workspace.create} options parameter.
+ */
 export type WorkspaceCreateOptions = {
   path: string;
   templateId: string;

package/src/workspace/WorkspaceCreateProjectOptions.ts

@@ -1,3 +1,6 @@
+/**
+ * {@link Workspace.createProject | Workspace.createProject} options parameter.
+ */
 export type WorkspaceCreateProjectOptions = {
   templateId: string;
   projectPath: string;

package/src/workspace/WorkspaceDependencies.ts

@@ -1,34 +1,19 @@
+// TODO: try to fix
+/* eslint-disable complexity -- TODO */
 import _ from 'lodash';
 import semver from 'semver';
 
-import {compareSemver} from './internals.js';
+import {compareSemver, compareWorkspaceDependencyProjectName} from './internals.js';
 import {type Workspace} from './Workspace.js';
+import {type WorkspaceDependenciesFromWorkspaceOptions} from './WorkspaceDependenciesFromWorkspaceOptions.js';
+import {type WorkspaceDependenciesGetVersionsOptions} from './WorkspaceDependenciesGetVersionsOptions.js';
+import {type WorkspaceDependency} from './WorkspaceDependency.js';
 
-export interface WorkspaceDependencyProject {
-  name: string;
-  version: string;
-  exactVersion: string;
-}
-
-export interface WorkspaceDependency {
-  name: string;
-  versions: string[];
-  exactVersions: string[];
-
-  projects: WorkspaceDependencyProject[];
-}
-
-export interface WorkspaceDependenciesGetVersionsOptions {
-  useExactVersions?: boolean;
-}
-
-export interface WorkspaceDependenciesFromWorkspaceOptions {
-  includeDevDependencies?: boolean;
-  includeOnlyDevDependencies?: boolean;
-  includeWorkspaceDependencies?: boolean;
-}
-
+/**
+ * A collection of {@link WorkspaceDependency | workspace dependencies} that are installed in {@link Workspace | a workspace}.
+ */
 export class WorkspaceDependencies<M extends boolean = true> extends Array<WorkspaceDependency> {
+  /** The workspace the dependencies are installed in. */
   workspace: Workspace<M>;
 
   constructor(...args: [...WorkspaceDependency[], Workspace<M>]) {
@@ -46,6 +31,12 @@ export class WorkspaceDependencies<M extends boolean = true> extends Array<Works
     }
   }
 
+  /**
+   * Adds one or more new dependencies.
+   *
+   * @param newWorkspaceDependencies The dependencies to add.
+   * @returns The new length of the collection.
+   */
   override push(...newWorkspaceDependencies: WorkspaceDependency[]): number {
     for (let newWorkspaceDependency of newWorkspaceDependencies) {
       let doesExist = false;
@@ -70,6 +61,7 @@ export class WorkspaceDependencies<M extends boolean = true> extends Array<Works
 
           workspaceDependency.versions.sort(compareSemver);
           workspaceDependency.exactVersions.sort(compareSemver);
+          workspaceDependency.projects.sort(compareWorkspaceDependencyProjectName);
         }
       }
 
@@ -81,8 +73,13 @@ export class WorkspaceDependencies<M extends boolean = true> extends Array<Works
     return this.length;
   }
 
-  // TODO: fix
-  // eslint-disable-next-line complexity -- TODO
+  /**
+   * Creates new {@link WorkspaceDependencies} instance from a {@link Workspace} instance and its dependencies.
+   *
+   * @param workspace The workspace from which the dependnecies are taken.
+   * @param options Options.
+   * @returns The new {@link WorkspaceDependencies} instance.
+   */
   static fromWorkspace<M extends boolean = true>(
     workspace: Workspace<M>,
     options?: WorkspaceDependenciesFromWorkspaceOptions,
@@ -178,6 +175,12 @@ export class WorkspaceDependencies<M extends boolean = true> extends Array<Works
     return new this(...workspaceDependencies, workspace);
   }
 
+  /**
+   * Creates map of all dependnecies and their installed version.
+   *
+   * @param options Options.
+   * @returns Object whose keys are dependency names and values are sorted versions.
+   */
   getVersions(options?: WorkspaceDependenciesGetVersionsOptions) {
     let versions: Record<string, string[]> = {};
 

package/src/workspace/WorkspaceDependenciesFromWorkspaceOptions.ts

@@ -0,0 +1,8 @@
+/**
+ * {@link WorkspaceDependencies.fromWorkspace | WorkspaceDependencies.fromWorkspace} options parameter.
+ */
+export type WorkspaceDependenciesFromWorkspaceOptions = {
+  includeDevDependencies?: boolean;
+  includeOnlyDevDependencies?: boolean;
+  includeWorkspaceDependencies?: boolean;
+};

package/src/workspace/WorkspaceDependenciesGetVersionsOptions.ts

@@ -0,0 +1,6 @@
+/**
+ * {@link WorkspaceDependencies.getVersions | WorkspaceDependencies.getVersions} options parameter.
+ */
+export type WorkspaceDependenciesGetVersionsOptions = {
+  useExactVersions?: boolean;
+};