# Delon, the module layer behind every ng-alain scaffold

> ng-alain/delon is the MIT-licensed collection of Angular modules that completes an ng-alain scaffold. It ships as a pnpm workspace of packages, schematics and documentation tooling, and it is far more tightly coupled to the ng-alain stack than its name suggests.

**ng-alain/delon** — Delon is a set of essential modules for ng-alain. https://github.com/ng-alain/ng-alain/issues

- Repository: https://github.com/ng-alain/delon
- Website: https://ng-alain.com
- Stars: 682 · Forks: 669
- Language: TypeScript
- License: MIT
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/ng-alain-delon

## Delon fills the gap left by the ng-alain scaffold itself

The repository describes itself in one line: "Delon is a set of essential modules for NG-ALAIN". That framing matters, because it puts the project in the same category as the scaffold rather than beside it. A scaffold generates the initial shape of an application: routing, layout, a base project file, a few folders. It does not ship the reusable widget and helper modules an application ends up needing once real screens exist. Delon is that layer, and it is consumed by applications that were generated from the ng-alain templates.

The audience is therefore narrower than the npm keyword list implies. The keywords in package.json are delon, ng-alain, alain, antd, ng-zorro-antd and angular, which puts the project in the Ant Design flavoured Angular ecosystem rather than in the general Angular community. If your team is on Angular but has no ng-alain in its history, Delon gives you modules without the scaffold conventions they were designed to slot into. The README points readers to the documentation at ng-alain.com and to a mirror of it, so the intended learning path is documentation first, code second.

## A pnpm workspace of packages, schematics and a documentation site

The repository root shows how the work is split. There is a packages directory, a schematics directory, a docs directory, an angular.json, a pnpm-workspace.yaml and a pnpm-lock.yaml, alongside a src directory that serves the documentation site. The package.json name and version fields identify the workspace root itself:

```json
  "name": "delon",
  "version": "22.1.1",
```

That version number is also the repository version, and it moves in step with the published releases listed for the project: 21.3.0 on 2026-06-16, then 22.0.0 on 2026-09-11, then 22.1.1 on 2026-09-26. A major bump in September means the workspace carries breaking changes that the accompanying patch release does not.

The schematics directory is worth noting separately. Schematics are the generators that create and modify project files, so a project that ships them can also offer project level templates rather than only runtime modules. The presence of a schematics directory alongside packages means a consumer can meet Delon in two different places: as imported code, and as generated scaffolding. The root also carries ngsw-config.json for service worker configuration, a .nvmrc, and nginx and mock directories, which belong to hosting the documentation site rather than to the shipped modules.

## The scripts show how the workspace is built and checked

The root package.json exposes the daily commands of the repository. Installing dependencies is followed by a husky hook through the prepare script, and the site generator runs before the development server starts:

```json
  "prepare": "husky",
  "start": "npm run site:gen && ng s -o --hmr",
  "lint": "npm run lint:ts && npm run lint:style",
  "lint:ts": "eslint --cache",
  "lint:style": "npx stylelint 'packages/**/*.less'",
```

The lint setup treats TypeScript and Less as two separate quality gates, and the styling check targets only the packages directory. The development command regenerates site content first, which tells you the documentation is generated rather than hand written in place.

Testing is split into two scripts. One runs the Angular test target for the delon package with coverage and no watch mode, and the other exercises the schematics through a dedicated shell script:

```json
  "test": "ng test delon --no-progress --no-watch --coverage",
  "test:cli": "bash scripts/ci/build-schematics.sh -t -clone",
  "build": "bash scripts/ci/build.sh",
  "build_artifacts": "bash scripts/ci/build-artifacts.sh",
```

The build is also script driven, with a separate artifact step for producing the distributable packages. Release notes are generated from commit history with a conventional changelog command that reads the package.json version:

```json
  "changelog": "npx conventional-changelog -p angular -i CHANGELOG.md --pkg package.json -s",
```

Commit conventions are enforced in the repository through commitlint.config.js, and formatting follows prettier, so the project expects a fixed contribution style rather than ad hoc patches.

## The declared Node range is narrower than a casual reading suggests

The engines field is the clearest constraint in the whole manifest:

```json
  "engines": {
    "node": "^22.22.3 || ^24.15.0 || >=26.0.0"
  },
```

Three ranges are accepted, and all three exclude the 23.x and 25.x lines that odd numbered Node releases belong to. The lower bound of the first range is a patch level, 22.22.3, not a bare 22. A CI machine or a container image running 22.0.0 satisfies the caret syntax but fails the engine check. Teams that pin Node in a Dockerfile need to match a patch release, not just a major version.

A .nvmrc file sits in the repository root, so the intended development runtime is also recorded outside the manifest, and the CI scripts live under scripts/ci. The build itself is a shell script rather than a JavaScript entry point, which means the release path assumes a Unix style shell environment and the bash scripts referenced in the npm scripts have to be present where they are called. Nothing in the manifest suggests a Windows friendly build, so contributor setup on Windows is likely to be a separate manual effort.

The README does not describe how the documented site is built or hosted, and the repository carries a Dockerfile.docs plus an _nginx directory, which points to a containerised publishing pipeline for the documentation rather than for the library itself.

## What the README leaves open about upgrading

Upgrading cost is where this project is least documented. The README points to the documentation site, links to the source, a demo and a surge mirror, and states the licence. It does not describe a migration guide, a compatibility matrix between Delon versions and Angular versions, or a procedure for moving an application from 21.x to 22.x. The generated changelog is the only upgrade reference named anywhere in the repository, and it is produced from commit messages rather than written as a migration narrative.

Two release facts frame that gap. The 22.0.0 release landed on 2026-09-11 and 22.1.1 followed on 2026-09-26, so the current line is only a few weeks old at the time of writing, and the major number has already turned over once during 2026. A team running an older scaffold is therefore looking at at least one major version of change rather than a patch.

Maintenance itself looks current. The repository is not archived, and the last push was on 2026-10-07, which is after the 22.1.1 release date of 2026-09-26, so work continued after the tag was cut. Nothing in the README suggests a deprecated state, and the donation and backers sections show an ongoing community around the wider ng-alain project rather than a frozen snapshot.

## Where Delon is the wrong choice

The clearest failure case is a team that wants Angular modules without ng-alain. The dependency keywords tie the package to antd and ng-zorro-antd, and the documentation lives at ng-alain.com rather than on a general module catalogue, so adopting the packages alone means carrying conventions whose usual documentation path you have deliberately skipped. If your application is not generated from the ng-alain templates, the usual reason to take Delon, saving time on shared widgets, is not being met.

The second failure case is a runtime constraint. The engines range excludes odd numbered Node lines and demands a specific patch level on the 22 line. A team on a managed platform that pins Node to an excluded release cannot simply install the package and expect the engine check to be advisory, since it is declared at the root of a published package.

The realistic alternative is to assemble your own small module layer from the generic Angular component ecosystem and keep the ng-alain scaffold only for project generation. The difference in approach is real: Delon ships pre-decided UI and layout conventions that you inherit wholesale and then fight when they do not match your design, while a hand built layer costs setup time but keeps every decision inside your own codebase. Neither route is free, and the choice depends on how much of your product is administration style screens, which is the case Delon was assembled for in the first place.

On licensing, the project is MIT, and the repository states it directly: "ng-alain is an MIT-licensed open source project". That permits use and modification in commercial products, though the README also points to paid business themes and to donation channels such as patreon, opencollective and paypal, which is a funding model detail rather than a restriction on use.

## Conclusion

Adopt Delon when you have already chosen ng-alain and want its component and module layer rather than assembling your own. Do not reach for it as a generic Angular module collection, because the package keywords tie it to antd and ng-zorro-antd and the repository layout is a pnpm workspace rather than a standalone library. Before upgrading, check that your Node runtime satisfies the declared engine range and read the changelog entry for the major version you are crossing, since the README does not document a migration path.

## FAQ

### What is Delon and how does it relate to ng-alain?

Delon is described as a set of essential modules for NG-ALAIN, a collection of Angular modules that complete the ng-alain scaffold. It is published under the MIT licence and maintained as part of the ng-alain project.

### Which Node versions does ng-alain/delon support?

The package.json engines field allows "^22.22.3 || ^24.15.0 || >=26.0.0". Odd numbered Node lines are not in range, and the 22 line requires at least patch 22.22.3.

### How is the Delon repository built and tested?

The build runs bash scripts/ci/build.sh and tests run through "ng test delon --no-progress --no-watch --coverage", with a separate schematics check via bash scripts/ci/build-schematics.sh -t -clone.

### Is Delon actively maintained and what is the latest version?

The repository is not archived and the last push was on 2026-10-07. The latest listed release is 22.1.1, published on 2026-09-26, following 22.0.0 on 2026-09-11.

## Sources

- [License: MIT](https://github.com/ng-alain/delon/blob/master/LICENSE)
- [ng-alain/delon on GitHub](https://github.com/ng-alain/delon)
- [Project website](https://ng-alain.com)
- [README](https://github.com/ng-alain/delon/blob/master/README.md)
- [Releases](https://github.com/ng-alain/delon/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ng-alain-delon