Dependencies for Each Package in Makeplane Plane: Complete Monorepo Guide

The makeplane/plane repository organizes its codebase into a TypeScript-first monorepo where every package under packages/ maintains its own package.json declaring runtime dependencies and development devDependencies, using workspace:* for internal monorepo links and catalog: for external library versions.

Understanding the dependency structure of the makeplane/plane monorepo is essential for contributing features, debugging build issues, or extending the open-source project. Each package publishes its own dependency manifest, following strict PNPM workspace conventions that separate local cross-package references from third-party library requirements.

Dependency Management Conventions

The monorepo uses two specific version specifiers to manage its dependency graph efficiently.

workspace:* – Refers to another package inside the same repository. This creates local monorepo dependencies that resolve to the current source code rather than npm registry versions.

catalog: – Refers to an external package whose exact version is resolved from the repository-wide pnpm-lock.yaml. This "catalog" feature ensures consistent versions across all packages.

Package-by-Package Dependencies

Each package in the packages/ directory serves a distinct architectural purpose with carefully declared dependencies.

@plane/utils – Shared Utility Functions

The @plane/utils package provides helper functions used across applications. In packages/utils/package.json, it declares:

• Runtime dependencies – Internal references to @plane/constants and @plane/types using workspace:*, plus external libraries including chroma-js, clsx, date-fns, lodash-es, lucide-react, sanitize-html, uuid, and markdown processing utilities (hast, rehype-parse, remark-gfm, etc.) via catalog:
• Dev dependencies – @plane/typescript-config, TypeScript definitions, and build tools (tsdown, typescript) via catalog:

@plane/ui – UI Component Library

The @plane/ui package contains the core UI component library. According to packages/ui/package.json, it depends on:

• Internal runtime – @plane/constants, @plane/hooks, @plane/propel, @plane/types, and @plane/utils via workspace:*
• External runtime – Drag-and-drop utilities (@atlaskit/pragmatic-drag-and-drop), blueprint components (@blueprintjs/core), Headless UI (@headlessui/react), Radix UI (@radix-ui/react-scroll-area), clsx, lodash-es, lucide-react, and styling utilities via catalog:
• Peer dependencies – react and react-dom via catalog:
• Dev dependencies – @plane/tailwind-config, @plane/typescript-config, Storybook packages, and PostCSS tooling via catalog:

@plane/propel – Rich UI Components

The @plane/propel package provides advanced UI components like buttons, dialogs, and tables. In packages/propel/package.json:

• Runtime dependencies – Internal packages (@plane/constants, @plane/hooks, @plane/types, @plane/utils) via workspace:*, plus @base-ui-components/react, @tanstack/react-table, class-variance-authority, framer-motion, recharts, and tailwind-merge via catalog:
• Dev dependencies – @plane/tailwind-config, @plane/typescript-config, Storybook addons, and Vite tooling via catalog:

@plane/services – HTTP Client Utilities

The @plane/services package wraps Axios for API communication. According to packages/services/package.json:

• Runtime dependencies – @plane/constants and @plane/types via workspace:*, plus axios and file-type via catalog:
• Dev dependencies – @plane/typescript-config, tsdown, and typescript via catalog:

@plane/shared-state – Global State Management

The @plane/shared-state package implements MobX-based stores. In packages/shared-state/package.json:

• Runtime dependencies – Internal references (@plane/constants, @plane/types, @plane/utils) via workspace:*, plus lodash-es, mobx, mobx-utils, uuid, and zod via catalog:
• Dev dependencies – TypeScript tooling and @plane/typescript-config via catalog:

@plane/types – TypeScript Definitions

The @plane/types package contains shared type definitions. According to packages/types/package.json:

• Runtime dependencies – @plane/constants and @plane/types (self-reference for circular usage) via workspace:*
• Peer dependencies – react and react-dom via catalog:
• Dev dependencies – @plane/typescript-config, @types/* packages, tsdown, and typescript via catalog:

@plane/hooks – React Hooks

The @plane/hooks package provides shared React hooks. In packages/hooks/package.json:

• Runtime dependency – react via catalog:
• Dev dependencies – @plane/typescript-config, @types/*, tsdown, and typescript via catalog:

@plane/i18n – Internationalization

The @plane/i18n package handles translation utilities. According to packages/i18n/package.json:

• Runtime dependencies – i18next, i18next-icu, i18next-resources-to-backend, react, and react-i18next via catalog:
• Dev dependencies – @plane/typescript-config, @types/*, tsdown, tsx, and typescript via catalog:

@plane/logger – Logging Infrastructure

The @plane/logger package provides Express-compatible Winston logging. In packages/logger/package.json:

• Runtime dependencies – express-winston and winston via catalog:
• Dev dependencies – @plane/typescript-config, @types/express, @types/node, tsdown, and typescript via catalog:

Configuration Packages

Several packages provide shared configuration without external runtime dependencies:

• @plane/typescript-config – Contains base.json, nextjs.json, react-library.json, and node-library.json configuration files with no runtime dependencies.
• @plane/tailwind-config – Declares @tailwindcss/postcss and postcss as runtime dependencies, with tailwindcss as a dev dependency, all via catalog:.
• @plane/constants – Pure constant definitions with no external dependencies.
• @plane/editor – Rich-text editor component with dependencies similar to @plane/ui and @plane/propel (see packages/editor/package.json for specifics).

Working with Package Dependencies

When importing packages within the monorepo, PNPM automatically resolves workspace:* dependencies to the local source. The following examples demonstrate how these dependency relationships work in practice.

Importing UI components that rely on internal utilities:

// Consumes @plane/constants and @plane/utils internally
import { Button } from '@plane/ui';
import { APP_NAME } from '@plane/constants';

export const MyButton = () => (
  <Button variant="primary">{APP_NAME}</Button>
);

Making typed API calls using the services layer:

// Uses axios internally, types from @plane/types
import { apiClient } from '@plane/services';

async function fetchProjects() {
  const { data } = await apiClient.get('/api/projects');
  return data; // Type inferred from @plane/types definitions
}

Using table components with their required peer dependencies:

// Relies on @tanstack/react-table and @plane/utils
import { Table } from '@plane/propel/table';
import { columns, rows } from './my-data';

export const ProjectTable = () => <Table columns={columns} data={rows} />;

Summary

• The makeplane/plane monorepo structures dependencies through packages/<name>/package.json files, separating runtime requirements from build-time tooling.
• Internal dependencies use the workspace:* protocol to link local packages, ensuring changes propagate immediately across the codebase.
• External dependencies use the catalog: protocol to maintain consistent versions across all packages via the central pnpm-lock.yaml.
• Peer dependencies are explicitly declared in UI packages like @plane/ui, @plane/types, and @plane/propel to ensure compatible React versions.
• Zero-dependency packages like @plane/constants provide pure data without external version constraints.

Frequently Asked Questions

What is the difference between workspace:* and catalog: dependencies?

workspace:* links to other packages within the same monorepo, resolving to the local file system rather than the npm registry. catalog: references external npm packages but pulls their exact version from the repository-wide catalog defined in pnpm-lock.yaml, ensuring version consistency across all packages without duplicating version strings in every package.json.

How do I add a new dependency to a specific package?

Add the dependency to the specific package's package.json using workspace:* for internal monorepo packages or catalog: for external libraries. Run pnpm install from the repository root to update the lockfile and propagate changes through the workspace dependency graph.

Which packages have peer dependencies?

The UI-focused packages declare peer dependencies to ensure compatibility with the consuming application's React version. Specifically, @plane/ui, @plane/types, and @plane/propel all list react and react-dom as peer dependencies via catalog:, preventing version mismatches in the component tree.

How are external library versions managed across the monorepo?

External versions are centralized using PNPM's catalog feature. When a package specifies "lodash-es": "catalog:", PNPM resolves this to the version defined in the root pnpm-lock.yaml or catalog configuration. This ensures that packages like @plane/utils, @plane/shared-state, and @plane/ui all use identical versions of shared libraries like lodash-es without manual synchronization.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}