open-index/open-npm huggingface dataset:
npm package: @nutanek/vite-react-component-library-template
Description: A clean and modern React 18+ component library built with Vite and TypeScript.
Latest version: 1.0.2

# vite-react-component-library-template

A clean and modern **React 18+ component library template**, powered by [Vite](https://vitejs.dev/), [TypeScript](https://www.typescriptlang.org/), and [Vitest](https://vitest.dev/).

This template is designed to help you build your own reusable React component library, with playground and testing ready to go.

---

## ✨ Features

✅ React 18+
✅ Vite for blazing-fast dev & build
✅ TypeScript for type-safe components
✅ Playground with React Router to test components
✅ Vitest + Testing Library for unit testing
✅ ESLint & Prettier for linting and formatting
✅ Husky & lint-staged support for pre-commit hooks

---

## 🚀 Getting Started

1. **Clone the template**

   ```bash
   git clone https://github.com/scg-wedo/vite-react-component-library-template.git my-lib
   cd my-lib
   ```

2. **Update package info**
   - Edit `package.json`:
     - Change `"name"` to your library name (e.g. `"my-awesome-lib"`)
     - Update `"repository"`, `"bugs"`, `"homepage"`

   - Update LICENSE file owner & year if needed.

3. **Install dependencies**

   ```bash
   yarn install
   ```

4. **Run playground**

   ```bash
   yarn dev
   ```

   👉 This will open a local dev server at [http://localhost:3000](http://localhost:3000) to test your components.

5. **Build the library**

   ```bash
   yarn build
   ```

   👉 Outputs files to `dist/`, ready to publish.

6. **Run tests**

   ```bash
   yarn test
   ```

7. **Lint & Format**

   ```bash
   yarn lint
   yarn format
   ```

8. **Publish**
   - Make sure you’re logged in to npm:

     ```bash
     npm login
     ```

   - Publish your library:

     ```bash
     npm publish --access public
     ```

---

## 🗂 Project Structure

```
src/
  components/       → your library components
  index.ts          → export all components here

playground/
  index.html        → entry HTML for playground
  main.tsx          → entry point for React
  App.tsx           → setup routes or demos for components
  previews/         → separate component demos

vite.config.ts              → config for building the library
playground/vite.config.ts   → config for running playground

package.json                → library config, scripts, dependencies
```

---

## 🔥 Recommended Next Steps

✅ Add your own components in `src/components`
✅ Update `src/index.ts` to export them
✅ Write tests in `src/components/YourComponent/YourComponent.test.tsx`
✅ Add preview pages in `playground/previews/`
✅ Customize README and package metadata before publish

---

## 🙌 License

[MIT](LICENSE)
npm package: @nutella-ui/nutella-ui
Description: This template should help get you started developing with Vue 3 in Vite. The template uses Vue 3 `<script setup>` SFCs, check out the [script setup docs](https://v3.vuejs.org/api/sfc-script-setup.html#sfc-script-setup) to learn more.
Author: yyy
Latest version: 1.0.0

# Vue 3 + Vite

This template should help get you started developing with Vue 3 in Vite. The template uses Vue 3 `<script setup>` SFCs, check out the [script setup docs](https://v3.vuejs.org/api/sfc-script-setup.html#sfc-script-setup) to learn more.

## Recommended IDE Setup

- [VS Code](https://code.visualstudio.com/) + [Volar](https://marketplace.visualstudio.com/items?itemName=Vue.volar)
npm package: @nuteruls/mailgun-js-sdk
Description: A simple node mailgun sdk
Author: Uladzislau Vasiuk
Latest version: 1.0.5

# Mailgun Node SDK
A simple Mailgun SDK to send e-mails.
Fork of https://github.com/mocallu/mailgun-js-sdk

## Install
```shell
npm install @nuteruls/mailgun-js-sdk
```

## Setup
```javascript
const MailgunSDK = require('mailgun-js-sdk');
const Mailgun = new MailgunSDK({
    apiKey: 'YOUR_API_KEY', // Required
    baseUrl: 'https://api.eu.mailgun.net/v3/'
});
```

## Send a message
```javascript
async function sendMessage() => {
    const domain = 'domain.used.on.mailgun.org';
    const message = {
        from: 'From Name <from@email.com>',
        to: 'To <to@email.com>',
        subject: 'Mocallu Mailgun SDK Test',
        text: 'This is a simple e-mail test',
        html: `<html><strong>This is a simple e-mail test</strong></html>`,
        'o:tag': 'test-sdk',
        'o:testmode': true,
    };
    const result = await Mailgun.sendMessage(domain, message);
    console.log(result);
};
sendMessage();
```

## Getting domains
```javascript
const domainsList = Mailgun.getDomains();
const domain = Mailgun.getDomains('especific.domain.mailgun.org');
```

> This SDK is not finished, feel free to help on development.
npm package: @nutgaard/data-pack
Description: Utility pack for working with random data
Author: Nicklas Utgaard
Latest version: 2.1.2

# Data-pack

Utility pack for working with random data

## File utils

Simple wrapper around `fs` and `fs/promises`.

```typescript
function read(path: string): Promise<string>;
function readSync(path: string): string;
function readJSON<T>(path: string): Promise<T>;
function readJSONSync<T>(path: string): Promise<T>;

function write(path: string, content: any): Promise<void>;
function writeSync(path: string, content: any): void;
function withWriteStream(path: string, block: (stream: WriteStream) => void): void;
```

## CSV

Utilities for parsing and writing CSV files

```typescript
function* parseCSV(content: string, delimiter: string = ''): Generator<Array<string>, void>;
function* parseCSVSync(content: string, delimiter: string = ''): Array<Array<string>>;
function* parseCSVToFlow(content: string, delimiter: string = ''): GeneratorFlow<Array<string>>;
```

## JSON

Utilities for parsing and writing JSON

```typescript
function serialize(content: any): string;
function deserialize<T>(content: string): T;
```

## KeyValue (KV)

Utilities for parsing and writing in key-value pairs

```typescript
function writeKVSync(object: object, delimiters: KvDelimiters): string;
function parseKVSync<T>(content: string, delimiters: KvDelimiters): T;
```

## Generator flows

Utilities for working with generators as if they are arrays

```typescript
// Creation
const flow = GeneratorFlow.ofArray([1, 2, 3, 4]);
const numFlow = GeneratorFlow.ofArray([5, 6]);
const otherFlow = new GeneratorFlow(function* () {
    yield 'a';
    yield 'b';
    yield 'c';
    yield 'd';
});

// Stream functions
flow.skipWhile((it) => it < 2); // Flow[3,4]
flow.takeWhile((it) => it < 2); // Flow[1]
flow.skip(2); // Flow[3,4]
flow.tail(); // Flow[2,3,4]
flow.take(2); // Flow[1,2]
flow.map((it) => it * 2); // Flow[2,4,6,8]
flow.flatMap((it) => [it * 2]); // Flow[2,4,6,8]
flow.filter((it) => it % 2 == 0); // Flow[2,4]
flow.zip(otherFlow); // Flow[[1, 'a'], [2, 'b'], [3, 'c'], [4, 'd']]
flow.cartesianProduct(otherFlow); // Flow[[1, 'a'], [1, 'b'], [1, 'c'], [1, 'd'], [2, 'a'], ... [4, 'd']]
flow.concat(otherFlow); // Flow[1, 2, 3, 4, 5, 6]
flow.peek(console.log); // Flow[1, 2, 3, 4]
flow.reduce(add, 0); // 10
flow.size(); // 4
flow.toArray(); // [1, 2, 3, 4]
flow.toSet(); // Set<1, 2, 3, 4>
```
npm package: @nutgaard/dktp
Description: A simple cli to interact with Azure ContainerApps with arm/yaml templates
Author: Nicklas Utgaard
Latest version: 2.1.1

# dktp

A simple cli to interact with Azure ContainerApps with arm/yaml templates

## Usage

```shell
Usage: dktp [options] [command]

CLI to help working dktp apps

Options:
  -h, --help                                display help for command

Commands:
  wrap [options] <configfile> [outputfile]  Download secrets, and encrypt environment
  run [options] <env_file> <command...>     Run command with environment variables from lock-file
  inspect [options] <env_file>              Print content of encrypted lock-file
  help [command]                            display help for command
```

### Wrap: Download and encrypt environment

```shell
Usage: dktp wrap [options] <configfile> [outputfile]

Download secrets, and encrypt environment

Arguments:
  configfile                        Path to dktp yaml file
  outputfile                        Path to encrypted vault file

Options:
  -c, --container <container_name>  Container name to process (defaults to create a combined env file)
  -e, --env <env_file>              Envfile to use for interpolation
  -h, --help                        display help for command
  
  
Example: dktp wrap example/main.yml -e example/prod.env example/prod.env.locked
```

### Run: Start a process with environment variable set

```shell
Usage: dktp run [options] <env_file> <command...>

Run command with environment variables from lock-file

Arguments:
  env_file                      Envfile to use for process
  command                       The command to run

Options:
  -o, --override [keyvalue...]  Override or pass extra environment variable, e.g MY_VAR=abba (default: {})
  -h, --help                    display help for command
  
  
Example: dktp run example/prod.env.locked -o APP_NAME=Hello -- node index.mjs
```

### Inspect: Print the content of a encrypted lock-file

```shell
Usage: dktp inspect [options] <env_file>

Print content of encrypted lock-file

Arguments:
  env_file                      File to inspect

Options:
  -o, --override [keyvalue...]  Override or pass extra environment variable, e.g MY_VAR=abba (default: {})
  -h, --help                    display help for command
  
  
Example: dktp inspect example/prod.env.locked -o APP_NAME=Hello
```



## Contribution
To install dependencies:

```bash
bun install
```

To run:

```bash
bun run src/index.ts
```

To test wrapping of secrets;
1. Update [targetPlatform.ts](src/utils/targetPlatform.ts) to set `AZ_MOCK = true`.
2. Run `bun run src/index.ts wrap example/main.yml -e example/prod.env example/prod.env.locked`


### Commiting changes

This repository uses commitizen and conventional-changelog to determine which new semver-version should be used in a release.
To help with keeping your commits correctly formatted please use `bun commit` / `npm run commit`.
npm package: @nutgaard/gh-report
Description: Simple tool to extract a report of a teams PRs since a timestamp.
Author: Nicklas Utgaard
Latest version: 0.0.1-beta-03

# GH-Report

Simple tool to extract a report of a teams PRs since a timestamp.

## Usage 
```
GH-Report
Automatically look for PR merges the last week for a given team.

gh-report myorg/myteam

Options:
    -l, --limit:    Extend the number of PRs checked for each repo. 
                    Default: 10
             
    -d, --since:    Set the cutoff for which PRs er relevant.
                    Default: now() - 1w
                    Example: 2021-09-15
                 
    -r, --reporter: Set the reporter format
                    Default: terminal
                    Options: terminal, markdown
                    
Examples:
    Specify the cutoff for relevant PRs 
    gh-report myorg/myteam --since 2021-09-01
    
    Increase the limit when fetching PRs for github 
    gh-report myorg/myteam --limit 20
    
    Print the report in markdown 
    gh-report myorg/myteam --reporter markdown
```
npm package: @nutgaard/gitnext
Description: Small cli to help prioritize your github tasks
Author: Nicklas Utgaard
Latest version: 0.0.1-beta.20

# GitNext

Small cli to help prioritize your github tasks

<img alt="screenshot of gitnext" src="media/screenshot.png">

The motivation behind this package is to aid in discoverability and prioritization 
when using github as a primary source-control system. 
Github has its own [pull-request view](https://github.com/pulls) which can be extremely useful in many cases.
However it is not always a good match when using code-owners and required reviews from teams.

## Prerequisites
This package uses [github's own cli](https://cli.github.com/), and requires you to be logged in.

Login can be done be issuing the command `gh auth login`, and verified by `gh auth status`.

## Install

To install this package;
`npm i @nutgaard/gitnext -g`

## Run
After installation, run it;
`gitnext`

**NB** Some terminals require a restart in order to pick up on globally installed script. 

## Configuration
GitNext allows the user to configure what repositories and teams they would like to follow.
This configuration is located at `$HOME/.gitnext.yaml` and is automatically created the first time you start GitNext.

An example configuration;
```yaml
sources:
  - username: __self__                     # __self__ is based on your current user.
    ignore:
      - repo: another-username/legacy      # A repository, which you have access to. But dont want to actively follow
      - username: dependabot               # Ignore pull-requests from this user
  - organization: your-awesome-org
    #Due to how large organizations can be, we have to explicit about which teams and repos we are interested in
    include:
      - team: the-best-team                # A team you got access to
      - repo: repository-outside-team      # A repository outside of your primary team
    ignore:
      # In case a team has a repo you're not interested in
      - repo: your-awesome-org/old-legacy  # Ignore this old legacy repo in your org
      - username: annoying-coworker        # Ignore pull-request from this user (within this org)
```
npm package: @nutgaard/maybe-ts
Description: Maybe monad for typescript inspired by elm's Maybe
Author: Nicklas Utgaard
Latest version: 1.4.0

# Maybe-ts

[![styled with prettier](https://img.shields.io/badge/styled_with-prettier-ff69b4.svg)](https://github.com/prettier/prettier)
[![Travis](https://img.shields.io/travis/nutgaard/maybe-ts.svg)](https://travis-ci.org/alexjoverm/typescript-library-starter)
[![codecov](https://codecov.io/gh/nutgaard/maybe-ts/branch/master/graph/badge.svg)](https://codecov.io/gh/nutgaard/yet-another-fetch-mock)
[![dependencies Status](https://david-dm.org/nutgaard/maybe-ts/status.svg)](https://david-dm.org/nutgaard/yet-another-fetch-mock)

Maybe monad for typescript inspired by elm's Maybe.

## Installation:
```
npm install @nutgaard/maybe-ts --save
```

## Examples
The library exports two different ways of using the `Maybe`-monad, functional and classical.

**NB!** Uses different ways of importing the library.

Function:
```
import Maybe from 'maybe-ts';

Maybe.map((value) => value.toUpperCase(), Maybe.just('Hello, World'));

// If you use a library for `compose`/`flow`/`pipe` or similar concepts. (See ./test/pipe.ts example)
pipe(
  Maybe.just('Hello, World'),
  Maybe.map((value: string) => value.toUpperCase())
);

// Or, with the use of the pipe-operator
Maybe.just('Hello, World')
  |> Maybe.map((value) => value.toUpperCase())
```

Classical:
```
import { MaybeCls as Maybe } from '../src/maybe-ts';

Maybe.just('Hello, World')
  .map((value) => value.toUpperCase())
```

#### Types
Full documentation of types can be seen [here](https://www.utgaard.xyz/maybe-ts/)

## Credits

Made using the awesome [typescript library starter](https://github.com/alexjoverm/typescript-library-starter)
npm package: @nutgaard/remark-slide-builder
Description: utility for builder remark slidedecks.
Author: Nicklas Utgaard
Latest version: 0.0.1-beta.3

# remark-slide-builder

utility for builder remark slidedecks.

# Getting started
```
npx degit github:nutgaard/remark-slide-builder/example my-slides
cd my-slides
npm i
npm run dev
```

# Commands
```
remark-builder dev
remark-builder build
remark-builder help
```
npm package: @nutgaard/sanity-migrate
Description: Utility for managing migration in a sanity dataset
Author: Nicklas Utgaard
Latest version: 1.0.0

# sanity-migrate

:construction: WIP :construction:

A simple CLI tool to help migrate [sanity.io](https://www.sanity.io/) data.


Install:
```
npm i @nutgaard/sanity-migrate -g
```

**Commands:**
```
sanity-migrate install      Creates a hidden sanity document for tracking migrations
sanity-migrate uninstall    Deletes the hidden sanity document for tracking migrations
sanity-migrate status       Lists the current status of migrations
sanity-migrate clean        Resets the hidden document
sanity-migrate migrate      Run the migrations      
sanity-migrate help         Prints the help
```
npm package: @nutgaard/typeanalyzer
Description: Captures and analyzes datastructures
Author: Nicklas Utgaard
Latest version: 1.1.0

# Type analyzer

A port of a [similar library](https://github.com/navikt/modia-common-utils/tree/main/typeanalyzer) written in kotlin.

Useful in cases where you're not quite sure how a datastructure looks like, e.g whats nullable and whats not.

This library helps the investigation into what you can expect by capturing the structure, and generating examples classes for you.

**Usage:**

```typescript
import {Typeanalyzer} from "./Typeanalyzer";

const serviceAnalyzer = new Typeanalyzer();

function somemethod(): Map<string, unknown> {
    const data = service.getSomeData();
    serviceAnalyzer.capture(data);
    return data;
}
```

**NB:** You should not reuse an instance of `Typeanalyzer` for objects you expect to be different.

`Typeanalyzer` captures and maintains an inner representation of the datastructures it has captures, 
which fields that are nullable, and what their types should be (See the representation in the [snapshot](src/__snapshots__/Typeanalyzer.Snapshot.test.ts.snap)).

To get the representation programmatically you can call `serviceAnalyzer.report()`, which returns the most up-to-date representation.
This representation can be used to generate pseudo-code for kotlin and typescript:

```typescript
const typescriptCode = serviceAnalyzer.print(new TypescriptFormat());
const kotlinCode = serviceAnalyzer.print(new KotlinFormat());
```

**In-depth:**

The typeanalyzer works by capturing the structure of a given value, and gradually relaxing the constraints.

F.ex;
```typescript
const analyzer = new Typeanalyzer();
analyzer.capture(["value"]); // ListCapture[PrimitiveCapture[type = TEXT, nullable = false]]
analyzer.capture([null]);    // ListCapture[PrimitiveCapture[type = TEXT, nullable = true]]
```

If the typeanalyzer has not previously seen a valid type for a field, it tries to specify it if given the chance.

F.ex;
```typescript
const analyzer = new Typeanalyzer();
analyzer.capture([null]);     // ListCapture[NullCapture[]]
analyzer.capture(["value"]);  // ListCapture[PrimitiveCapture[type = TEXT, nullable = true]]
```

In the previous example the analyzer was initally passed `null` in the first capture, and the specified field was thus marked as `nullable`.
This is in contrast to if the analyzer has not yet seen any values in the list.

F.ex;
```typescript
const analyzer = new Typeanalyzer();
analyzer.capture([]);         // ListCapture[UnknownCapture[]]
analyzer.capture(["value"]);  // ListCapture[PrimitiveCapture[type = TEXT, nullable = false]]
analyzer.capture([null]);     // ListCapture[PrimitiveCapture[type = TEXT, nullable = true]]
```
npm package: @nutgaard/use-async
Description: [![styled with prettier](https://img.shields.io/badge/styled_with-prettier-ff69b4.svg)](https://github.com/prettier/prettier) [![Travis](https://img.shields.io/travis/nutgaard/use-async.svg)](https://travis-ci.org/nutgaard/use-async) [![codecov](https://c
Author: Nicklas Utgaard
Latest version: 2.3.1

# use-async

[![styled with prettier](https://img.shields.io/badge/styled_with-prettier-ff69b4.svg)](https://github.com/prettier/prettier)
[![Travis](https://img.shields.io/travis/nutgaard/use-async.svg)](https://travis-ci.org/nutgaard/use-async)
[![codecov](https://codecov.io/gh/nutgaard/use-async/branch/master/graph/badge.svg)](https://codecov.io/gh/nutgaard/use-async)
[![dependencies Status](https://david-dm.org/nutgaard/use-async/status.svg)](https://david-dm.org/nutgaard/use-async)

### Installation

```
npm install @nutgaard/use-async --save
```

### Usage
The library exposes one hook `useAsync`, and three utility-functions to help use the result (`isPending`, `hasData` and `hasError`).

```typescript
import React from 'react';
import useAsync, { isPending, hasError } from '@nutgaard/use-async';

const source = React.useCallback((isRerun) => Promise.resolve("your data here"), []);
const result = useAsync(source);

if (isPending(result)) {
  return <Spinner />;
} else if (hasError(result)) {
  return <Error />
} 

return <pre>{result.data}</pre>
``` 

### useAsync API

| Argument  | Type | Optional | Default |
| ------------- | ------------- | ------------- | ------------- |
| `source`  | `(isRerun) => Promise<DATA>` | No | - |
| `lazy`  | `boolean`  | Yes | `false` |
| `dependencyList`  | `Array<any>`  | Yes | `undefiend` |

In cases where `dependencyList` is defined it is passed on to `useEffect` instead of `source`.  
This allows a greater control of when the effect should run in cases where the `source` does
not necessarily change.

#### Types
Full documentation of types can be seen [here](https://www.utgaard.xyz/use-async/), or in the 80-ish lines of code.

## Credits

Made using the awesome [typescript library starter](https://github.com/alexjoverm/typescript-library-starter)
npm package: @nutgaard/use-fetch
Description: A useFetch hook to be used with react@^16.8.0
Author: Nicklas Utgaard
Latest version: 2.4.1

# use-fetch

[![styled with prettier](https://img.shields.io/badge/styled_with-prettier-ff69b4.svg)](https://github.com/prettier/prettier)
[![Build](https://github.com/nutgaard/use-fetch/actions/workflows/master.yaml/badge.svg)](https://github.com/nutgaard/use-fetch/actions/workflows/master.yaml)
[![codecov](https://codecov.io/gh/nutgaard/use-fetch/branch/master/graph/badge.svg)](https://codecov.io/gh/nutgaard/use-fetch)
[![dependencies Status](https://david-dm.org/nutgaard/use-fetch/status.svg)](https://david-dm.org/nutgaard/use-fetch)

Wrapper library around `@nutgaard/use-async` which simplifies doing fetch-request. 

### Installation

```
npm install @nutgaard/use-fetch --save
```

### Usage
The library exposes one hook `useFetch`, the cache, and three utility-functions from `@nutgaard/use-async` to help use the result (`isPending`, `hasData` and `hasError`).

```typescript jsx
import React from 'react';
import useFetch, { isPending, hasError } from '@nutgaard/use-fetch';

function LoadingComponent() {
    const result = useFetch('http://dummy.io');
    
    if (isPending(result)) {
      return <Spinner />;
    } else if (hasError(result)) {
      return <Error />
    } 
    
    return <pre>{result.data}</pre>
}
```

**Working with the cache:**
```typescript jsx
import { cache, createCacheKey } from '@nutgaard/use-fetch';

const options: RequestInit = { credentials: 'include' };

export function prefetch(url: string) {
    const cachekey = createCacheKey(url, options);
    cache.fetch(cachekey, url, options);
}

export function putIntoCache(url: string, value: any) {
    const cachekey = createCacheKey(url, options);
    cache.put(cachekey, Promise.resolve(new Response(JSON.stringify(value))));
}

export function removeFromCache(url: string) {
    const cachekey = createCacheKey(url, options);
    cache.remove(cachekey);
}

```

### useFetch API

| Argument  | Type | Optional | Default |
| ------------- | ------------- | ------------- | ------------- |
| `url`  | `string` | No | - |
| `option`  | `RequestInit`  | Yes | `undefined` |
| `config`  | `Config`  | Yes | `{ lazy: false, cacheKey: undefined }` |

The library will immediately perform `fetch(url, option)` when run, making sure to check its cache to avoid 
loading the same data more then once. 

If `lazy` is set to `true` it will not fetch data until `result.rerun()` is called. 
`cacheKey` may be used to override the cachekey used to index data, if left as `undefined` a key is generated based on `url` and `option`.

#### Types
Full documentation of types can be seen [here](https://www.utgaard.xyz/use-fetch/), or in the 80-ish lines of code.

## Credits

Made using the awesome [typescript library starter](https://github.com/alexjoverm/typescript-library-starter)
npm package: @nutility/jwt
Description: JWT module for NestJS
Author: Emirhan Güler
Latest version: 1.0.7

# @nutility/jwt

JWT Wrapper module for [NestJS](https://github.com/nestjs)

## Usage

Import NutilityJwtModule

NutilityJwtService exposes 3 methods (sign, verify, decode), which are native mappings to [jsonwebtoken](https://github.com/auth0/node-jsonwebtoken)

You can specify a type for those methods:
Example:

```ts
interface IUser {
  id: string;
  name: string;
}

const token = nutilityJwtService.sign<IUser>(foo); // foo must be of type IUser!
const user = nutilityJwtService.verify<IUser>(token); // user is of type IUser!
const decodedUser = nutilityJwtService.decode<IUser>(token); // decodedUser is of type IUser!
```
npm package: @nutin/cli
Description: Build SPAs by understanding SPAs. A minimal frontend toolkit crafted for learning and lean applications.
Author: Loïs Kouninef
Latest version: 1.3.0

# [nutin](https://www.nutin.org)

**Build SPAs by understanding SPAs. A minimal frontend toolkit crafted for learning and lean applications.**                    
Includes essential features out of the box.                          
*Pure TypeScript, SASS, and DOM-driven components — zero runtime dependencies.*

- Required : Node >=18 
- **JSDOM requirement** (testin-nutin companion) : `{ node: '^20.19.0 || ^22.12.0 || >=24.0.0' }`

## Install

```bash
# install package globally
npm install -g @nutin/cli
```

## New App

```bash
# create a new app
create-nutin-app # or
nutin-new

# without global installation
npx @nutin/cli
```

- Flags

```bash
# argument: project-name (prompt if not provided)

# Help
-h --help

# Defaults settings - see below
-d --defaults

# Package manager
-pm --package-manager <manager> # npm (Default), yarn, pnpm, bun

# Features
--template # (Default) Use external templates
--no-template # Use inline templates
--stylin-nutin # (Default) Use built-in SCSS utility classes & mixins
--no-stylin-nutin # Do not use built-in SCSS utility
--testin-nutin # Use testin-nutin toolkit
--no-testin-nutin # (Default) Do not use testin-nutin toolkit
--i18n # Use i18n & json-based content
--no-i18n # (Default) Do not use i18n & json-based content
--deploy-helper # Use Docker & deployment helpers
--no-deploy-helper, # (Default) Do not use Docker & deployment helpers
--transition # Use animated view transitions. Note: May interfere with CSS `position: fixed`, `z-index`...
--no-transition # (Default) Do not use animated view transitions
```

## [First app tutorial](https://www.nutin.org/tutorial)

## 📄 Docs

- Docs on [website](https://www.nutin.org).
- Docs on [repository](https://github.com/LoisKOUNINEF/nutin/tree/main/docs).