@jakubmazanec/carson 0.1.0-a500263

package/dist/workspace/ProjectConfig.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const projectConfigSchema: z.ZodObject<{
+    template: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodUnknown, z.objectOutputType<{
+    template: z.ZodOptional<z.ZodString>;
+}, z.ZodUnknown, "strip">, z.objectInputType<{
+    template: z.ZodOptional<z.ZodString>;
+}, z.ZodUnknown, "strip">>;
+export type ProjectConfig = z.infer<typeof projectConfigSchema>;

package/dist/workspace/ProjectConfig.js

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export const projectConfigSchema = z.object({
+    template: z.string().optional()
+}).catchall(z.unknown());
+
+//# sourceMappingURL=ProjectConfig.js.map

package/dist/workspace/ProjectConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/workspace/ProjectConfig.ts"],"sourcesContent":["import {z} from 'zod';\n\nexport const projectConfigSchema = z\n  .object({\n    template: z.string().optional(),\n  })\n  .catchall(z.unknown());\n\nexport type ProjectConfig = z.infer<typeof projectConfigSchema>;\n"],"names":["z","projectConfigSchema","object","template","string","optional","catchall","unknown"],"mappings":"AAAA,SAAQA,CAAC,QAAO,MAAM;AAEtB,OAAO,MAAMC,sBAAsBD,EAChCE,OAAO;IACNC,UAAUH,EAAEI,SAASC;AACvB,GACCC,SAASN,EAAEO,WAAW"}

package/dist/workspace/ProjectCreateOptions.d.ts

@@ -0,0 +1,8 @@
+import { type Workspace } from './Workspace.js';
+export type ProjectCreateOptions<M extends boolean> = {
+    templateId: string;
+    workspace: Workspace<M>;
+    projectPath: string;
+    projectName: string;
+    args: Record<string, unknown>;
+};

package/dist/workspace/ProjectCreateOptions.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=ProjectCreateOptions.js.map

package/dist/workspace/ProjectCreateOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/workspace/ProjectCreateOptions.ts"],"sourcesContent":["import {type Workspace} from './Workspace.js';\n\nexport type ProjectCreateOptions<M extends boolean> = {\n  templateId: string;\n  workspace: Workspace<M>;\n  projectPath: string;\n  projectName: string;\n  args: Record<string, unknown>;\n};\n"],"names":[],"mappings":"AAAA,WAQE"}

package/dist/workspace/ProjectError.d.ts

@@ -0,0 +1,8 @@
+import { type ZodIssue } from 'zod';
+export declare const ProjectError: new (code: "INVALID_PACKAGE_JSON" | "INVALID_PROJECT_CONFIG" | "NO_SUCH_PROJECT_PATH", options?: import("@jakubmazanec/error").CustomErrorWithDataOptions<{
+    path?: string;
+    zodIssues?: ZodIssue[];
+}> | undefined) => import("@jakubmazanec/error").CustomErrorWithData<"INVALID_PACKAGE_JSON" | "INVALID_PROJECT_CONFIG" | "NO_SUCH_PROJECT_PATH" | "UNKNOWN_ERROR", {
+    path?: string;
+    zodIssues?: ZodIssue[];
+}>;

package/dist/workspace/ProjectError.js

@@ -0,0 +1,11 @@
+import { createCustomErrorWithData } from '@jakubmazanec/error';
+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.'
+}, class ProjectErrorData {
+    path;
+    zodIssues;
+});
+
+//# sourceMappingURL=ProjectError.js.map

package/dist/workspace/ProjectError.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/workspace/ProjectError.ts"],"sourcesContent":["import {createCustomErrorWithData} from '@jakubmazanec/error';\nimport {type ZodIssue} from 'zod';\n\nexport const ProjectError = createCustomErrorWithData(\n  'ProjectError',\n  {\n    INVALID_PACKAGE_JSON: 'Invalid package.json file \"{0}\".',\n    INVALID_PROJECT_CONFIG: 'Invalid project config file \"{0}\".',\n    NO_SUCH_PROJECT_PATH: 'Project path \"{0}\" doesn\\'t exist.',\n  },\n  class ProjectErrorData {\n    path?: string;\n    zodIssues?: ZodIssue[];\n  },\n);\n"],"names":["createCustomErrorWithData","ProjectError","INVALID_PACKAGE_JSON","INVALID_PROJECT_CONFIG","NO_SUCH_PROJECT_PATH","ProjectErrorData","path","zodIssues"],"mappings":"AAAA,SAAQA,yBAAyB,QAAO,sBAAsB;AAG9D,OAAO,MAAMC,eAAeD,0BAC1B,gBACA;IACEE,sBAAsB;IACtBC,wBAAwB;IACxBC,sBAAsB;AACxB,GACA,MAAMC;IACJC,KAAc;IACdC,UAAuB;AACzB,GACA"}

package/dist/workspace/ProjectOptions.d.ts

@@ -0,0 +1,15 @@
+import { type PackageJson } from '@jakubmazanec/zod-utils';
+import { type ProjectConfig } from './ProjectConfig.js';
+import { type ProjectError } from './ProjectError.js';
+import { type Workspace } from './Workspace.js';
+/**
+ * New project options.
+ */
+export type ProjectOptions<M extends boolean> = {
+    path: string;
+    name?: string;
+    config?: ProjectConfig;
+    packageJson?: PackageJson;
+    workspace: Workspace<M>;
+    errors?: Array<InstanceType<typeof ProjectError>>;
+};

package/dist/workspace/ProjectOptions.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=ProjectOptions.js.map

package/dist/workspace/ProjectOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/workspace/ProjectOptions.ts"],"sourcesContent":["import {type PackageJson} from '@jakubmazanec/zod-utils';\n\nimport {type ProjectConfig} from './ProjectConfig.js';\nimport {type ProjectError} from './ProjectError.js';\nimport {type Workspace} from './Workspace.js';\n\n/**\n * New project options.\n */\nexport type ProjectOptions<M extends boolean> = {\n  path: string;\n  name?: string;\n  config?: ProjectConfig;\n  packageJson?: PackageJson;\n  workspace: Workspace<M>;\n  errors?: Array<InstanceType<typeof ProjectError>>;\n};\n"],"names":[],"mappings":"AAAA,WAgBE"}

package/dist/workspace/ProjectUpdateOptions.d.ts

@@ -0,0 +1,3 @@
+export type ProjectUpdateOptions = {
+    args: Record<string, unknown>;
+};

package/dist/workspace/ProjectUpdateOptions.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=ProjectUpdateOptions.js.map

package/dist/workspace/ProjectUpdateOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/workspace/ProjectUpdateOptions.ts"],"sourcesContent":["export type ProjectUpdateOptions = {\n  args: Record<string, unknown>;\n};\n"],"names":[],"mappings":"AAAA,WAEE"}

package/dist/workspace/Workspace.d.ts

@@ -0,0 +1,68 @@
+import { Project } from './Project.js';
+import { type WorkspaceConfig } from './WorkspaceConfig.js';
+import { type WorkspaceCreateOptions } from './WorkspaceCreateOptions.js';
+import { type WorkspaceCreateProjectOptions } from './WorkspaceCreateProjectOptions.js';
+import { WorkspaceDependencies } from './WorkspaceDependencies.js';
+import { WorkspaceError } from './WorkspaceError.js';
+import type { WorkspaceOptions } from './WorkspaceOptions.js';
+import { type WorkspacePackageJson } from './WorkspacePackageJson.js';
+import type { WorkspaceProjectGlobs } from './WorkspaceProjectGlobs.js';
+import { type WorkspaceProjects } from './WorkspaceProjects.js';
+import { type WorkspaceRepository } from './WorkspaceRepository.js';
+import { type WorkspaceUpdateOptions } from './WorkspaceUpdateOptions.js';
+/**
+ * Workspace represent a directory, usually a git repository, that contains {@linkcode Project} instances.
+ *
+ * @typeParam M If true, the workspace is multi-project workspace (so-called "monorepo").
+ */
+export declare class Workspace<M extends boolean = true> {
+    /** Workspace path. */
+    readonly path: string;
+    /** Does the workspace contain a multiple projects? */
+    readonly isMultiProject: M;
+    /** Globs used to find projects. */
+    projectGlobs: WorkspaceProjectGlobs<M>;
+    /** Workspace projects. */
+    projects: WorkspaceProjects<M>;
+    /** Workspace configuration; if it's not found, the default is an empty object. */
+    config: WorkspaceConfig;
+    /** Parsed workspace `package.json` file (if the workspace contains multiple projects); if it's not found, the default is an empty object. */
+    packageJson: WorkspacePackageJson<M>;
+    /** Workspace git repository. */
+    repository?: WorkspaceRepository;
+    /** Dependencies of all projects. */
+    dependencies: WorkspaceDependencies<M>;
+    /** Development dependencies of all projects. */
+    devDependencies: WorkspaceDependencies<M>;
+    /** All dependencies of all projects and workspace dependencies. */
+    allDependencies: WorkspaceDependencies<M>;
+    /** Versions of each dependency. */
+    dependencyVersions: Record<string, string[]>;
+    /** Errors found during reading from the file system. */
+    errors: Array<InstanceType<typeof WorkspaceError>>;
+    constructor(options: WorkspaceOptions<M>);
+    /**
+     * Creates new workspace within the file system.
+     *
+     * @param options Options.
+     * @returns The new workspace
+     */
+    static create({ args, path: workspacePath, templateId }: WorkspaceCreateOptions): Promise<Workspace<true> | Workspace<false>>;
+    static read(workspacePath: string): Promise<Workspace | Workspace<false>>;
+    /**
+     * Traverses file system up from the search path and tries to find a directory that is a root of a workspace.
+     */
+    static find(searchPath: string): Promise<string | undefined>;
+    /**
+     * Traverses file system up from the search path and tries to find and read a workspace.
+     */
+    static findAndRead(searchPath: string): Promise<Workspace | Workspace<false> | undefined>;
+    read(): Promise<this>;
+    update({ args }: WorkspaceUpdateOptions): Promise<this>;
+    getProject(projectName: Project<M> | string): Project<M> | undefined;
+    createProject({ templateId, projectPath, projectName, args, }: WorkspaceCreateProjectOptions): Promise<Project<M>>;
+    addProject(newProject: Project<M>): Project<M>;
+    readProjects(): Promise<Array<Project<M>>>;
+    private sortProjects;
+    private updateDependencies;
+}

package/dist/workspace/Workspace.js

@@ -0,0 +1,426 @@
+import { ensureEmptyDirectory, findExistingDirectory, isRootPath } from '@jakubmazanec/fs-utils';
+import { readFile, packageJsonSchema } from '@jakubmazanec/zod-utils';
+import glob from 'fast-glob';
+import fs from 'fs-extra';
+import json5 from 'json5';
+import path from 'node:path';
+import { z } from 'zod';
+import { getPackageJsonWorkspaces, getRepositoryBranches, getRepositoryUrl } from './internals.js';
+import { Project } from './Project.js';
+import { saveWorkspaceConfig } from './saveWorkspaceConfig.js';
+import { workspaceConfigSchema } from './WorkspaceConfig.js';
+import { WorkspaceDependencies } from './WorkspaceDependencies.js';
+import { WorkspaceError } from './WorkspaceError.js';
+import { CARSON_CONFIG_DIRECTORY, WORKSPACE_CONFIG_FILENAME } from '../constants.js';
+import { applyTemplateRenders } from '../template/applyTemplateRenders.js';
+import { renderTemplate } from '../template/renderTemplate.js';
+/**
+ * Workspace represent a directory, usually a git repository, that contains {@linkcode Project} instances.
+ *
+ * @typeParam M If true, the workspace is multi-project workspace (so-called "monorepo").
+ */ export class Workspace {
+    /** Workspace path. */ path;
+    /** Does the workspace contain a multiple projects? */ isMultiProject;
+    /** Globs used to find projects. */ projectGlobs;
+    /** Workspace projects. */ projects;
+    /** Workspace configuration; if it's not found, the default is an empty object. */ config;
+    /** Parsed workspace `package.json` file (if the workspace contains multiple projects); if it's not found, the default is an empty object. */ packageJson;
+    /** Workspace git repository. */ repository;
+    /** Dependencies of all projects. */ dependencies = [];
+    /** Development dependencies of all projects. */ devDependencies = [];
+    /** All dependencies of all projects and workspace dependencies. */ allDependencies = [];
+    /** Versions of each dependency. */ dependencyVersions = {};
+    /** Errors found during reading from the file system. */ errors = [];
+    constructor(options){
+        this.path = options.path;
+        if (typeof options.isMultiProject === 'undefined' || options.isMultiProject) {
+            this.isMultiProject = true;
+            let projectGlobOption = options.projectGlobs;
+            if (projectGlobOption) {
+                this.projectGlobs = projectGlobOption;
+            } else {
+                this.projectGlobs = [];
+            }
+            let { projects  } = options;
+            if (projects) {
+                this.projects = projects.map((project)=>new Project({
+                        ...project,
+                        workspace: this
+                    }));
+            } else {
+                this.projects = [];
+            }
+            let packageJsonOption = options.packageJson;
+            if (packageJsonOption) {
+                this.packageJson = packageJsonOption;
+            } else {
+                let emptyPackageJson = {};
+                this.packageJson = emptyPackageJson;
+            }
+        } else {
+            this.isMultiProject = false;
+            this.projectGlobs = null;
+            this.packageJson = null;
+            let { projects  } = options;
+            if (projects) {
+                this.projects = projects.map((project)=>new Project({
+                        ...project,
+                        workspace: this
+                    }));
+                if (this.projects[0].path !== this.path) {
+                    throw new WorkspaceError('PATH_MISMATCH');
+                }
+            } else {
+                this.projects = [];
+            }
+        }
+        let configOption = options.config;
+        if (configOption) {
+            this.config = configOption;
+        } else {
+            let emptyWorkspaceConfig = {};
+            this.config = emptyWorkspaceConfig;
+        }
+        if (options.repository) {
+            this.repository = options.repository;
+        }
+        if (options.errors) {
+            this.errors = options.errors;
+        }
+        // add missing project globs
+        if (this.isMultiProject && !this.projectGlobs.length) {
+            let packageJsonWorkspaces = getPackageJsonWorkspaces(this.packageJson);
+            if (packageJsonWorkspaces) {
+                this.projectGlobs = [
+                    ...packageJsonWorkspaces
+                ];
+            }
+        }
+        this.updateDependencies();
+    }
+    /**
+   * Creates new workspace within the file system.
+   *
+   * @param options Options.
+   * @returns The new workspace
+   */ static async create({ args , path: workspacePath , templateId  }) {
+        // 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()
+        let workspace = new this({
+            path: workspacePath,
+            config: {
+                template: templateId
+            }
+        });
+        await ensureEmptyDirectory(workspace.path);
+        await saveWorkspaceConfig({
+            workspacePath: workspace.path,
+            workspaceConfig: {
+                template: templateId
+            }
+        });
+        let templateRenders = await renderTemplate({
+            templateId,
+            templateData: {
+                workspace,
+                args
+            }
+        });
+        await applyTemplateRenders({
+            templateRenders,
+            path: workspace.path,
+            ignoreCreateStrategies: false,
+            ignoreCheckStrategies: true
+        });
+        return Workspace.read(workspace.path);
+    }
+    static async read(workspacePath) {
+        let resolvedWorkspacePath = path.resolve(workspacePath);
+        if (!await fs.pathExists(resolvedWorkspacePath)) {
+            throw new WorkspaceError('NO_SUCH_WORKSPACE_PATH', {
+                messageParameters: [
+                    resolvedWorkspacePath
+                ],
+                data: {
+                    path: resolvedWorkspacePath
+                }
+            });
+        }
+        // load root package.json
+        let rootPackageJsonPath = path.join(resolvedWorkspacePath, 'package.json');
+        let doesRootPackageJsonExist = await fs.pathExists(rootPackageJsonPath);
+        let rootPackageJson;
+        if (doesRootPackageJsonExist) {
+            rootPackageJson = await readFile(rootPackageJsonPath, packageJsonSchema, {
+                parser: (rawString)=>json5.parse(rawString)
+            });
+        } else {
+            rootPackageJson = {};
+        }
+        if (rootPackageJson instanceof z.ZodError) {
+            rootPackageJson = {};
+        }
+        // add projects
+        let projectGlobs = getPackageJsonWorkspaces(rootPackageJson);
+        // we're dealing with single-project workspace
+        if (!projectGlobs) {
+            let workspace = new this({
+                path: resolvedWorkspacePath,
+                isMultiProject: false
+            });
+            await workspace.read();
+            await workspace.readProjects();
+            return workspace;
+        }
+        // assemble workspace options
+        let workspace = new this({
+            path: resolvedWorkspacePath,
+            isMultiProject: true,
+            projectGlobs,
+            packageJson: rootPackageJson
+        });
+        await workspace.read();
+        await workspace.readProjects();
+        return workspace;
+    }
+    /**
+   * Traverses file system up from the search path and tries to find a directory that is a root of a workspace.
+   */ static async find(searchPath) {
+        let startingPath = await findExistingDirectory(path.resolve(searchPath));
+        let currentPath = startingPath;
+        let singlePackageWorkspacePath;
+        let multiPackageWorkspacePath;
+        while(!(isRootPath(currentPath) || singlePackageWorkspacePath && multiPackageWorkspacePath)){
+            let packageJsonPath = path.join(currentPath, 'package.json');
+            let doesPackageJsonExist = await fs.pathExists(packageJsonPath);
+            if (doesPackageJsonExist) {
+                let packageJson = await readFile(packageJsonPath, packageJsonSchema, {
+                    parser: (rawString)=>json5.parse(rawString)
+                });
+                if (!(packageJson instanceof Error)) {
+                    let projectGlobs = getPackageJsonWorkspaces(packageJson);
+                    if (projectGlobs === null || projectGlobs === void 0 ? void 0 : projectGlobs.length) {
+                        multiPackageWorkspacePath ??= currentPath;
+                    } else {
+                        singlePackageWorkspacePath ??= currentPath;
+                    }
+                }
+            }
+            currentPath = path.dirname(currentPath);
+        }
+        if (multiPackageWorkspacePath) {
+            return multiPackageWorkspacePath;
+        } else if (singlePackageWorkspacePath) {
+            return singlePackageWorkspacePath;
+        }
+        return undefined;
+    }
+    /**
+   * Traverses file system up from the search path and tries to find and read a workspace.
+   */ static async findAndRead(searchPath) {
+        let workspacePath = await Workspace.find(searchPath);
+        if (workspacePath) {
+            return Workspace.read(workspacePath);
+        }
+        return undefined;
+    }
+    async read() {
+        if (!await fs.pathExists(this.path)) {
+            throw new WorkspaceError('NO_SUCH_WORKSPACE_PATH', {
+                messageParameters: [
+                    this.path
+                ],
+                data: {
+                    path: this.path
+                }
+            });
+        }
+        let errors = [];
+        let repositoryUrl = await getRepositoryUrl(this.path);
+        let repositoryBranches = await getRepositoryBranches(this.path);
+        // load workspace config
+        let workspaceConfigPath = path.join(this.path, CARSON_CONFIG_DIRECTORY, WORKSPACE_CONFIG_FILENAME);
+        let doesWorkspaceConfigExist = await fs.pathExists(workspaceConfigPath);
+        let workspaceConfig;
+        if (doesWorkspaceConfigExist) {
+            workspaceConfig = await readFile(workspaceConfigPath, workspaceConfigSchema, {
+                parser: (rawString)=>json5.parse(rawString)
+            });
+        } else {
+            workspaceConfig = {};
+        }
+        if (workspaceConfig instanceof z.ZodError) {
+            let zodError = workspaceConfig;
+            let workspaceError = new WorkspaceError('INVALID_WORKSPACE_CONFIG', {
+                messageParameters: [
+                    workspaceConfigPath
+                ],
+                data: {
+                    path: workspaceConfigPath,
+                    zodIssues: zodError.issues
+                }
+            });
+            errors.push(workspaceError);
+            workspaceConfig = {};
+        }
+        if (this.isMultiProject) {
+            // load root package.json
+            let rootPackageJsonPath = path.join(this.path, 'package.json');
+            let doesRootPackageJsonExist = await fs.pathExists(rootPackageJsonPath);
+            let rootPackageJson;
+            if (doesRootPackageJsonExist) {
+                rootPackageJson = await readFile(rootPackageJsonPath, packageJsonSchema, {
+                    parser: (rawString)=>json5.parse(rawString)
+                });
+            } else {
+                rootPackageJson = {};
+            }
+            if (rootPackageJson instanceof z.ZodError) {
+                let zodError = rootPackageJson;
+                let workspaceError = new WorkspaceError('INVALID_PACKAGE_JSON', {
+                    messageParameters: [
+                        rootPackageJsonPath
+                    ],
+                    data: {
+                        path: rootPackageJsonPath,
+                        zodIssues: zodError.issues
+                    }
+                });
+                errors.push(workspaceError);
+                rootPackageJson = {};
+            }
+            let projectGlobs = getPackageJsonWorkspaces(rootPackageJson);
+            this.projectGlobs = projectGlobs ?? [];
+            this.packageJson = rootPackageJson;
+            this.config = workspaceConfig;
+            this.errors = errors;
+            if (repositoryUrl) {
+                this.repository = {
+                    url: repositoryUrl,
+                    branches: repositoryBranches ?? []
+                };
+            }
+            await this.readProjects();
+            return this;
+        }
+        // we're dealing with single-project workspace
+        this.config = workspaceConfig;
+        this.errors = errors;
+        if (repositoryUrl) {
+            this.repository = {
+                url: repositoryUrl,
+                branches: repositoryBranches ?? []
+            };
+        }
+        await this.readProjects();
+        return this;
+    }
+    async update({ args  }) {
+        if (!this.config.template) {
+            throw new Error('Templat ID is missing in the workspace config!');
+        }
+        let templateRenders = await renderTemplate({
+            templateId: this.config.template,
+            templateData: {
+                workspace: this,
+                args
+            }
+        });
+        await applyTemplateRenders({
+            templateRenders,
+            path: this.path,
+            ignoreCreateStrategies: true,
+            ignoreCheckStrategies: false
+        });
+        await this.read();
+        return this;
+    }
+    getProject(projectName) {
+        for (let project of this.projects){
+            if (project.name === projectName || project === projectName) {
+                return project;
+            }
+        }
+        return undefined;
+    }
+    async createProject({ templateId , projectPath , projectName , args  }) {
+        if (this.projects.some((project)=>projectPath === project.path)) {
+            throw new Error('Project with same path already exists!');
+        }
+        if (this.projects.some((project)=>projectName === project.name)) {
+            throw new Error('Project with same name already exists!');
+        }
+        if (!this.isMultiProject && this.projects.length >= 1) {
+            throw new Error('Only multi-project Workspace can have more than 1 project!');
+        }
+        let newProject = await Project.create({
+            templateId,
+            projectPath,
+            projectName,
+            args,
+            workspace: this
+        });
+        this.addProject(newProject);
+        return newProject;
+    }
+    addProject(newProject) {
+        if (this.projects.some((project)=>newProject.path === project.path)) {
+            throw new Error('Project with same path already exists!');
+        }
+        if (this.projects.some((project)=>newProject.name === project.name)) {
+            throw new Error('Project with same name already exists!');
+        }
+        if (!this.isMultiProject && this.projects.length >= 1) {
+            throw new Error('Only multi-project Workspace can have more than 1 project!');
+        }
+        this.projects.push(newProject);
+        this.sortProjects();
+        this.updateDependencies();
+        return newProject;
+    }
+    async readProjects() {
+        if (this.projectGlobs) {
+            let projects = [];
+            let packagePaths = await glob(this.projectGlobs, {
+                cwd: this.path,
+                onlyDirectories: true
+            });
+            for (let packagePath of packagePaths){
+                let project = await Project.read(path.join(this.path, packagePath), this);
+                projects.push(project);
+            }
+            this.projects = projects;
+        } else {
+            this.projects = [
+                await Project.read(this.path, this)
+            ];
+        }
+        this.sortProjects();
+        this.updateDependencies();
+        return this.projects;
+    }
+    sortProjects() {
+        this.projects.sort((projectA, projectB)=>{
+            if (projectA.path < projectB.path) {
+                return -1;
+            } else if (projectA.path > projectB.path) {
+                return 1;
+            }
+            return 0;
+        });
+    }
+    updateDependencies() {
+        this.dependencies = WorkspaceDependencies.fromWorkspace(this);
+        this.devDependencies = WorkspaceDependencies.fromWorkspace(this, {
+            includeOnlyDevDependencies: true
+        });
+        this.allDependencies = WorkspaceDependencies.fromWorkspace(this, {
+            includeDevDependencies: true,
+            includeWorkspaceDependencies: true
+        });
+        this.dependencyVersions = this.allDependencies.getVersions({
+            useExactVersions: true
+        });
+    }
+}
+
+//# sourceMappingURL=Workspace.js.map