open-index/open-npm huggingface dataset:
npm package: @kiota-community/kiota-gen
Description: Wrapper around the Kiota command line for generating client SDKs from OpenAPI.
Latest version: 1.0.2

# kiota-gen
Kiota Gen is a wrapper around the Kiota CLI tool that is used to generated client SDKs
from OpenAPI specifications.

This package can be used, for example, in a standard node.js/npm project to generate
a client for a REST API.

## Usage

In your `package.json` file, you must add the `@kiota-community/kiota-gen` package
as a dev dependency, something like this:

```json
{
  "name": "kiota-gen-example",
  "version": "0.1.0",
  "devDependencies": {
    "@kiota-community/kiota-gen": "0.1.0"
  }
}
```

Once this is done, and `npm install` is run, you can use `kiota`` as a command in the
`scripts` section of your `package.json`.  For example:

```json
{
  "name": "kiota-gen-example",
  "version": "0.1.0",
  "scripts": {
    "kiota-help": "kiota --help",
    "kiota-generate": "kiota generate -l typescript -d openapi.yaml -c MyGeneratedClient -o ./client"
  }
}
```

See the [documentation for Kiota](https://learn.microsoft.com/en-us/openapi/kiota/using) for more 
information on usage of the Kiota CLI.

## Options

By default, this package will use the most recent version of Kiota, downloaded from the
Kiota GitHub repository (based on the most recent GitHub release of Kiota).  It will 
download and unpack that released binary to a temporary local location and execute the
CLI from there.

You can optionally customize the above behavior. This is done by setting ENV variables.
The following ENV variables are available:

| Variable Name       | Description                   | Default Value |
| ------------------- | ----------------------------- | ------------- |
| KIOTA_VERSION       | The version of Kiota to use.  | `latest`      |
| KIOTA_DOWNLOAD_URL  | Where to download Kiota from. | `https://github.com/microsoft/kiota/releases/download` |
| KIOTA_DOWNLOAD_DIR  | Where to download Kiota to.   | `./.kiota`    |
npm package: @kiota-community/kiota-wasm
Description: Kiota compiled in a native WASM module.
Latest version: 0.0.3

# Kiota-Wasm

This project brings the power of [Kiota](https://github.com/microsoft/kiota) straight into your browser!
[Kiota](https://github.com/microsoft/kiota) is a C# project and the `dotnet` toolchain allows you to compile it with target `browser-wasm`and eventually run it in the browser.

## Usage

There are a few minor challenges with the integration of the produced artifacts into a real-world, modern, frontend application.
We do maintain working examples up to date to make sure that it's feasible to leverage this functionality.

1. Add this dependency to your project:

`npm install -D @kiota-community/kiota-wasm`

2. Unpack the resources in the public assets folder of your project (and we suggest to add it to your `.gitignore`):

```bash
npm install -D copyfiles rimraf
```

```json
  "scripts": {
    ...
    "postinstall": "rimraf ./public/kiota-wasm && copyfiles -u 4 'node_modules/@kiota-community/kiota-wasm/dist/**/*.*' 'public/kiota-wasm'"
  }
  ...
```

3. With some build tool such as `vite` you need to exclude those dependencies from the bundler:

```ts
export default defineConfig({
  plugins: [
    react(),
  ],
  build: {
    rollupOptions: {
      external: [
        /^.*kiota-wasm.*/,
      ]
    }
  }
})
```

4. Now you can integrate the WASM module with a dynamic import, with `vite`:

```ts
// @ts-ignore
const { generate } = await import('/kiota-wasm/main.js?url');
```

or with `webpack`:

```ts
const { generate } = await import(
  /* webpackIgnore: true */ './kiota-wasm/main.js'
);
```

5. Use the code generator functionality:

```ts
generate(spec: string, language: string, clientClassName: string, namespaceName: string, includePatterns: string, excludePatterns: string);
```


## Build

To build this project you need `dotnet` version 8+ and the `wasm-tools`:

```bash
dotnet workload install wasm-tools
```

and run the build:

```bash
dotnet build --configuration Release
```

## Run the example vite app

Publish the package with:

```bash
yalc publish
```

In the example application folder:

```bash
yalc add @kiota-community/kiota-wasm@0.0.1
npm install
npm run dev
```

## Release

This repository is released on tag:

```
git fetch origin
git checkout origin/main
git tag <version>
git push origin <version>
```

and the CI will do the job.