The empty environment - this Environment has nothing installed in it. It can be easily extended using withDevTools.

Plugin for vite projects. This will add to your Project:

Creates a new Package, which will be built using the given shell script. It's run in the emptyEnvironment.

Gets apps, checks, dev-shells, and packages from an existing flake file within your current project.

Creates a new shell script Check, run in the emptyEnvironment.

A garn plugin that allows easy deployment of a package to GitHub pages.

Creates a go-based garn Project.

Creates a haskell-based garn Project.

Gets apps, checks, dev-shells, and packages from an existing flake file by adding it as a flake input to your project.

Imports a flake file from a GitHub repository.

Imports a flake file from a GitLab repository.

Imports a flake file from a SourceHut repository.

Creates a npm-based garn Project.

Creates a yarn-based garn Project.

A garn plugin that adds a format Executable that formats your code using prettier, and a Check to verify that your code is formatted.

A low-level helper to create new Environments.

A low-level helper to create new Packages from NixExpressions.

Creates a new Project.

Turns a javascript object of NixExpressions into a Nix attribute set. Filters out undefined values.

Returns a NixExpression that renders as an identifier that refers to a flake input. At the same time it registers the flake input as a dependency, so that it'll be included in the inputs of the generated flake file. See renderFlakeFile for an example.

Turns a javascript array of NixExpressions into a Nix list.

A template literal function to construct NixExpressions from raw strings.

Returns a NixExpression which represents a Nix string literal, but with all typescript interpolations properly escaped and interpolated.

Renders the nix expression as the outputs of a flake file with all flake deps provided as inputs.

Converts a NixExpression to a string representing that Nix expression.

Converts a NixExpression to a (hopefully concise) human readable string with incidental dependencies snipped out with "[...]"

Creates an executable project that runs all specified executables simultaneously using process-compose.

Creates a new shell script Executable, run in the emptyEnvironment.

Checks are commands (usually shell commands) that are used to define reproducible automated tests or other checks.

Environments define what files and tools are available to Executables, Checks and development shells.

Executables are commands (usually shell snippets) that are being run on your local machine (not in a sandbox).

Project components returned by mkHaskellProject

Methods for obtaining apps, checks, dev-shells, and packages from an imported flake file to include in your garn project.

An opaque type representing a Nix expression.

A union of types that are allowed to be interpolated into the nixStrLit template literal function. This is also used in some higher level functions, such as Environment.shell.

Packages are instructions to garn about how to build a set of files.

Plugins automatically add one or more fields to your project. You can use existing plugins to automatically add prepackaged functionality to your Project. declare them manually yourself.

A Project is a logical grouping of Packages and Environments. For example, you may have a 'frontend' Project, a 'backend' Project, a 'cli' Project, etc.

Config for importing flake files from GitHub/GitLab/SourceHut.