Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/ertgl/holypack

[WIP] Backend-agnostic build system for scalable web projects.
https://github.com/ertgl/holypack

Last synced: about 1 year ago
JSON representation

[WIP] Backend-agnostic build system for scalable web projects.

Awesome Lists containing this project

README 

          


  


    holypack

  


  

    holycat, the mascot of holypack

  

  


    

      A holycat, has some business with your boxes.

    

  





> [!CAUTION]

> **This project is in early development.**

>

> The content in this README is more of a plan and might not reflect the final

> product.

>

> Development is ongoing very actively.

>

> If you are interested, I would like to hear your thoughts. Contact

> information is available on my profile.



## Table of Contents



- [Overview](#overview)

  - [Scope](#scope)

  - [Principles](#principles)

  - [Features](#features)

- [Integrations](#integrations)

- [Packages](#packages)

- [Installation](#installation)

- [Usage](#usage)

- [Name](#name)

- [License](#license)



## Overview



Holypack is a backend-agnostic build system designed for accessible and

scalable web projects. It focuses on transforming, optimizing, and bundling

frontend assets with minimal setup and maximum flexibility. Built with modern

tooling and enterprise-readiness in mind, it supports a wide range of project

types (from progressive-enhancement-first architectures to single-page

applications) without enforcing backend constraints. Holypack provides reliable

defaults, thoughtful integrations for linting, testing, security and a modular

plugin system for unrestricted extensibility.



### Scope



Many modern tools either make strong assumptions about the backend environment

(typically JavaScript or TypeScript) or overlook the needs of progressive

enhancement, which is vital for accessibility and long-term scalability.

Holypack is crafted to fill this gap by offering a backend-agnostic approach

that prioritizes portability, flexibility, and production-readiness from the

start. It supports diverse project types, including SPAs, PWAs, SSR setups, and

CLI tools without dictating architectural choices.



### Principles



Holypack is designed to help achieve long-term maintainability, modern

developer workflows, and a clear separation of concerns. It uses proven

technologies to keep things simple but flexible enough to handle different use

cases. The configuration approach strikes a balance, avoiding unnecessary

complexity while still allowing customization when needed.



The core principles behind holypack include:



  - **Production-ready**: A straightforward setup by default.

  - **Guided flexibility**: A mix of "**convention over configuration**" and

    "**configuration over convention**."

  - **Optimized for modern workflows**: Integrates with fast,

    developer-friendly tools that improve productivity.

  - **Built on proven technologies**: Combined with the best practices to

    ensure sustainable efficiency.

  - **Adaptable and non-restrictive**: Works with any project structure,

    without being restrictive.



### Features



Holypack offers a set of enterprise-friendly features that balance performance,

security, and developer experience. All designed to adapt to projects of any

scale.



#### Foundation



- **Modular plugin system**, uses [tapable](https://github.com/webpack/tapable)

  under the hood

- **Backend-agnostic architecture**, supports any backend in any language

- **Project templates** for:

  - Frontend-only (assets)

  - Single Page Applications (SPA)

  - Progressive Web Applications (PWA, service workers, navigation preloading)

  - Server-Side Rendering (SSR) with progressive enhancement



#### Build & Transform



- Code and asset bundling via [webpack](https://webpack.js.org/)

- JavaScript/TypeScript transpilation with [Babel](https://babeljs.io/) and

  [SWC](https://swc.rs/)

- CSS processing with [PostCSS](https://postcss.org/) and

  [Lightning CSS](https://lightningcss.dev/)

- Superpowered CSS, with [Sass](https://sass-lang.com/) and

  [SCSS](https://sass-lang.com/documentation/syntax/#scss)

- First-class [CSS modules](https://github.com/css-modules/css-modules) support



#### Security & Integrity



- [Subresource Integrity (SRI)](https://developer.mozilla.org/en-US/docs/Web/Security/Subresource_Integrity)

- [Content Security Policy (CSP)](https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/CSP)

- [Trusted Types](https://developer.mozilla.org/en-US/docs/Web/API/Trusted_Types_API)

- Dual builds for **modern** and **legacy** environments

- Built-in support for **graceful degradation**



#### CLI & Distribution



- Build CLI applications targeting Node.js (including SSR use cases)

- Optional JavaScript **obfuscation** for closed-source projects

- Support for bundling into **single-file** executables



> [!WARNING]

> Code obfuscation is **not a security mechanism** for intellectual properties.

> It serves as a deterrent and may support legal standing by demonstrating that

> violations were deliberate rather than accidental.



## Integrations



  

    Name

    Package

    Status

  

  

    ​

  

  

    Linters

  

  

    ESLint

    @holypack/integration-eslint

    Completed

  

  

    axe-core

    

    Planned

  

  

    Stylelint

    

    Planned

  

  

    commitlint

    

    Planned

  

  

    Husky

    

    Planned

  

  

    ​

  

  

    Build Tools

  

  

    TypeScript

    @holypack/integration-typescript

    Completed

  

  

    Babel

    @holypack/integration-babel

    Completed

  

  

    SWC

    

    Planned

  

  

    JavaScript Obfuscator

    

    Planned

  

  

    PostCSS

    

    Planned

  

  

    Lightning CSS

    

    Planned

  

  

    Sass

    

    Planned

  

  

    SCSS

    

    Planned

  

  

    Browserslist

    

    Planned

  

  

    webpack

    @holypack/integration-webpack

    

      Work in progress

    

  

  

    ​

  

  

    Testing Tools

  

  

    Jest

    @holypack/integration-jest

    Completed

  

  

    ​

  

  

    Distribution & Release Tools

  

  

    changesets

    

    Planned

  

  

    export-map-generator

    

    Completed

  

  

    ​

  

  

    Libraries & Frameworks

  

  

    Express

    

    Planned

  

  

    React

    

    Planned

  

  

    ​

  

  

    Polyfills

  

  

    core-js

    

    Planned

  

  

    trusted-types

    

    Planned

  



## Packages



  

    Name

    Package

    Status

  

  

    core

    @holypack/core

    Completed

  

  

    cli

    @holypack/cli

    Planned

  

  

    prelude

    holypack

    Completed

  



## Installation



The packages will be available once the initial implementation is complete.



## Usage



The final view of the usage will be provided at a later stage.



### Configuration



Multiple file formats are supported for configuration, including JSON, YAML,

JavaScript and TypeScript.



Example of configuration in `holypack.config.mjs`:



```js

import eslint from "@holypack/integration-eslint";

import { defineConfig } from "holypack/config";



export default defineConfig({

  integrations: [

    eslint(),

  ],

});

```



  

    

      Toggle the eslint.config.mjs view for the above example

    

  



  ```js

  import createHolypackPlugin from "@holypack/eslint-plugin";



  const holypack = await createHolypackPlugin();



  export default [

    ...holypack.configs.recommended,

  ];

  ```



#### Configuration Exploration



When a configuration file is provided, the system will use it as the main

configuration file. Otherwise, it will look for a configuration file in the

current working directory with the following priority:



- `package.json` (`holypack.config` property)

- `holypack.config.ts`

- `holypack.config.js`

- `holypack.config.mts`

- `holypack.config.mjs`

- `holypack.config.cts`

- `holypack.config.cjs`

- `.holypackrc.ts`

- `.holypackrc.js`

- `.holypackrc.mts`

- `.holypackrc.mjs`

- `.holypackrc.cts`

- `.holypackrc.cjs`

- `.holypackrc.json`

- `.holypackrc.yml`

- `.holypackrc.yaml`

- `.holypackrc`

- `.config/holypackrc.ts`

- `.config/holypackrc.js`

- `.config/holypackrc.mts`

- `.config/holypackrc.mjs`

- `.config/holypackrc.cts`

- `.config/holypackrc.cjs`

- `.config/holypackrc.json`

- `.config/holypackrc.yml`

- `.config/holypackrc.yaml`

- `.config/holypackrc`



### Low-level API



The final view of the API will be provided at a later stage.



#### Context Resolution



Example:



```ts

import { resolveContext } from "@holypack/core";



const context = await resolveContext();

```



## Name



The name first came from my reaction to how crowded the npm registry felt. But

it now reflects my respect for the stack of technologies that I have used to

build this project. Cats are also very surprising.



Just same as webpack, I prefer not to capitalize it in the middle of a

sentence.



## License



This project is licensed under the

[MIT License](https://opensource.org/license/mit).

See the [LICENSE](LICENSE) file for more information.