open-index/open-npm huggingface dataset:
npm package: @gilsdav/storybook-angular-source
Description: Displays template code to use to have same result into your app.
Author: David Gilson
Latest version: 0.1.1

# Storybook Addon Angular Source

This addon for Storybook adds a tab that displays angular template code for each
story. It uses [prismjs](https://prismjs.com/) for syntax highlighting.

![Animated preview](images/preview.png)

## Getting Started

With NPM:

```sh
npm i --save-dev @gilsdav/storybook-angular-source
```

With Yarn:

```sh
yarn add -D @gilsdav/storybook-angular-source
```

### Register addon

```js
// .storybook/main.js

module.exports = {
  // ...
  addons: [
    '@gilsdav/storybook-angular-source',
    // ...
  ],
};
```
npm package: @gilt-tech/swig-assets
Description: Deploys assets to S3.
Latest version: 2.9.1

# swig-assets
Swig task that prepares frontend assets and deploys them to S3.

## Usage
Meant to be used via the [Swig CLI][1], just run:

```
swig assets-deploy
```

## TODO

 - Add more helpful information on the README.


 [1]:https://www.npmjs.com/package/@gilt-tech/swig
npm package: @gilt-tech/swig-install
Description: Installs and organizes front-end assets.
Latest version: 2.9.1

Meant to be used via the [Swig CLI][1], just run:

```
swig install
```

Swig install does an npm install on dependencies and then copies those dependencies to a public folder to be served by
the app. The default 'public' directory for apps is /web/APP-NAME/public but you can also specify a target directory
for public assets e.g. the usual Scala play public folder can be 'target' or 'main/resources' etc.

For example:

```
swig install --public ~Code/web/web-mosaic/target/public
```

If you're fixing IE11 issues locally you may want to use the --transpile flag
during `swig install`. It adds a final step that transpiles all JS once it's
finished installing to `/public/js`. It's not needed on canary etc because the
minification step takes care of it.

E.g.

```
swig install --transpile
```
npm package: @gilt-tech/swig-lint
Description: Lints front-end assets.
Latest version: 2.5.0

# swig-lint
Swig task that checks for possible issues in your code base.

## Usage
Meant to be used via the [Swig CLI][1], just run:

```
swig lint
```

You can also instruct the CSS linter to use a different engine (default is an ancient version
of [Lesshint][2]), namely [Stylelint][3], like so:

```
swig lint --use-stylelint
```

You can also instruct the linter to look at a specific source folder

```
swig lint --src /web/web-blah/target
```

In this case you shall provide the linter a `.stylelintrc.yml` file with the necessary Stylelint
configuration.

By using [Stylelint][3] you can now also specify files to ignore (previously not possible), using the
special `.stylelintignore` config file, which uses a `.gitignore`-like syntax.


## TODO

 - Add more helpful information on the README (like list of JS/CSS rules) and
 how to override them.


[1]:https://www.npmjs.com/package/@gilt-tech/swig
[2]:https://github.com/gilt/lesshint
[3]:https://stylelint.io/
npm package: @gilt-tech/swig-nova
Description: gilt-swig module for deploying with nova deployment tool
Latest version: 2.9.1

# swig module to for use with nova deploy tool

### Install:

Assuming you have a swig project already setup, in your project folder do the following:

Install module and save as a dev dependency

```
npm install @gilt-tech/swig-nova --save-dev
```


### Usage

swig-nova uses the same conventions that nova tool uses for deploy locations. Envirnoments and stacks, when deploying you must specify both of these. For other options here's the output of the built in help accessible at `swig nova-deploy -h`:

```
Usage:
swig nova-deploy [options]

Options:
  --env            Name of environment in nova.yml to deploy to.
  --stack          Name of stack in nova.yml to deploy to.
  --new-version    Deploy a new version, valid options are (patch|minor|major). Version will
                   be incremented in package.json accordingly and tagged in git.
  --latest-tag     Get the latest version tag on the current repo
  --version        Specify new version manually. Value should be N.N.N and newer that latest
                   deployed version.
```


Links:

* [swig](https://github.com/gilt/swig)
* [nova deploy tool](https://github.com/gilt/nova)
npm package: @gilt-tech/swig-publish
Description: Publishes a UI Module, providing linting and spec automation.
Latest version: 2.9.1

# swig-publish
Swig plugin that allows for a super easy way to publish NPM modules.

## Installation

```
npm install -D @gilt-tech/swig-publish
```

or, if you are really kool:

```
yarn add -D @gilt-tech/swig-publish
```

## Usage
This plugin will add the task `publish` to the [`swig`][1] CLI.

Once you have it installed, you have to organize your modules codebase, like so:

```
modules-repo
 - src
   + moduleA
   - moduleB
     package.json
     ...
 package.json // <-- where the swig package is installed
```

You can then ask `swig` to publish one of the modules with a simple command:

```
swig publish -m <module-name>
```

This will instruct `swig` to search inside the `src` folder for a module, which
`package.json` property `name` matches the given `module-name`, and then
publish the new version of it on NPM.

## CLI options

`--module <module-name>`, `-m <module-name>` (required):

This one tells the `publish` plugin which module it has to process.

`--beta` (optional):

This will instruct the `publish` plugin to create a `*-beta` version of the
module you want to publish, and publish it on the `beta` dist tag of NPM.

It also checks if there is an already published beta version with the same
semver number, and if so, it asks the user if it should override it with a new
beta version.


[1]:https://www.npmjs.com/package/@gilt-tech/swig
npm package: @gilt-tech/swig-run
Description: Swig tasks for running Gilt Node Framework apps. Currently this tool is limited to node.js apps.
Latest version: 2.9.0

# gilt-swig-run
Swig tasks for running Gilt Node Framework apps.
Currently this tool is limited to node.js apps.

Launch with `swig run` in the target node app.

## File watchers

`swig run --watch` will automatically watch scripts and stylesheets.

####TODO

 Add more info on how this task works
npm package: @gilt-tech/swig-util
Description: A collection of common utilities for use within swig tasks.
Latest version: 2.6.3

# gilt-swig-util

Contains utility modules for swig.

### swig-util

Documentation forthcoming


### swig-log

Swig-log provides logging mechanisms to swig modules. The `log` object
is appended onto the swig-wide `swig` shared object.

Properties:

  - log.symbols
    This object is initally populated with unicode symbols from the npm module
     `log-symbols`. If --pretty=false is used, the unicode symbols are replaced
     with ascii representations.
    Available properties:
    - symbols.info
    - symbols.warning
    - symbols.error
    - symbols.success
    - symbols.connector
    - symbols.start

  - log.padding
    The default line padding used by the main function.

Methods:

  - log(what)
    Sends data to the terminal. eg. console.log.

  - log.confirm(question)
    Sends a question to the terminal and waits for user input. Returns the
    user's response.

  - log.error(prefix, what)
    Sends an 'error' line to the terminal.
    The line is prefixed with the error symbol, optional prefix text, and the
    data specified.

  - log.info(prefix, what)
    Sends an 'info' line to the terminal.
    The line is prefixed with the info symbol, optional prefix text, and the
    data specified.

  - log.padLeft(what, howMany)
    Pads a string at the beginning with the number of `log.padding` values
    specified.

  - log.padLeft(what, howMany)
    Pads a string at the end with the number of `log.padding` values
    specified.

  - log.success(prefix, what)
    Sends a 'success' line to the terminal.
    The line is prefixed with the success symbol, optional prefix text, and the
    data specified.

  - log.strip(what)
    Strips ansi colors from a string. Provided by the npm module `strip-ansi`.

  - log.task(name)
    Sends a 'task' line to the terminal.
    The line is prefixed with the start symbol and the name of the task.

  - log.verbose(what)
    Akin to `log(what)` but only if the --verbose flag is used.

  - log.warn(prefix, what)
    Sends an 'warning' line to the terminal.
    The line is prefixed with the warning symbol, optional prefix text, and the
    data specified.

  - log.write(what)
    Sends data to the terminal without a trailing newline.
npm package: @giltiq/mcp
Description: MCP server for EU VAT validation — VIES + BZSt failover, §18e qualified confirmations, cached fallback. Works when VIES is down.
Author: Giltiq
Latest version: 0.1.0

# @giltiq/mcp

MCP server for EU VAT validation with **multi-source reliability** (VIES + Germany's BZSt), automatic failover, and legally binding **qualified confirmations per §18e UStG**. Works when VIES is down. No other MCP server provides this.

## Install

```bash
npx @giltiq/mcp
```

## Configure

### Claude Desktop

Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "giltiq": {
      "command": "npx",
      "args": ["-y", "@giltiq/mcp"],
      "env": {
        "GILTIQ_API_KEY": "gq_live_your_key_here"
      }
    }
  }
}
```

### Cursor

Add to `.cursor/mcp.json`:

```json
{
  "mcpServers": {
    "giltiq": {
      "command": "npx",
      "args": ["-y", "@giltiq/mcp"],
      "env": {
        "GILTIQ_API_KEY": "gq_live_your_key_here"
      }
    }
  }
}
```

### Windsurf

Add to `~/.codeium/windsurf/mcp_config.json`:

```json
{
  "mcpServers": {
    "giltiq": {
      "command": "npx",
      "args": ["-y", "@giltiq/mcp"],
      "env": {
        "GILTIQ_API_KEY": "gq_live_your_key_here"
      }
    }
  }
}
```

> **No API key?** The server works without one in anonymous mode (10 free validations, VIES only). Set `GILTIQ_API_KEY` to unlock 100 calls/month, qualified confirmations, and usage tracking.

## Tools

| Tool | Description |
|------|-------------|
| `validate_vat_id` | Validate an EU VAT ID against VIES + BZSt with automatic failover and cached fallback. Returns company data and source freshness. |
| `qualified_confirmation` | Request a legally binding BZSt qualified confirmation per §18e UStG for audit-proof cross-border VAT exemption in Germany. |
| `check_api_status` | Check real-time availability and latency of VIES and BZSt upstream sources. |
| `get_usage` | Get current API usage: calls used, monthly limit, tier, and reset date. |

## Environment Variables

| Variable | Required | Description |
|----------|----------|-------------|
| `GILTIQ_API_KEY` | No | API key for authenticated access. Without it, runs in anonymous mode (10 lifetime calls). Get one free at [giltiq.de](https://giltiq.de). |
| `GILTIQ_API_URL` | No | Override the API base URL (default: `https://api.giltiq.de`). |

## Links

- [API Documentation](https://giltiq.de/en/api-reference/overview/)
- [agents.json](https://giltiq.de/agents.json)
- [llms.txt](https://giltiq.de/llms.txt)
- [OpenAPI Spec](https://giltiq.de/openapi.json)

## License

MIT

---

Powered by [Giltiq](https://giltiq.de) — the only VAT validation API with legally binding German tax compliance.
npm package: @giltiq/sdk
Description: Node.js SDK for the Giltiq VAT Validation API
Author: Giltiq
Latest version: 0.1.0

# @giltiq/sdk

Node.js SDK for the [Giltiq VAT Validation API](https://giltiq.de).

## Installation

```bash
npm install @giltiq/sdk
```

## Usage

```typescript
import { Giltiq } from "@giltiq/sdk";

const client = new Giltiq({ apiKey: "your-api-key" });

// Validate a VAT ID
const result = await client.validate("DE123456789");
console.log(result.valid, result.company_name);

// Check usage
const usage = await client.usage();
console.log(usage.requests);

// Check API status
const status = await client.status();
console.log(status.sources);
```

### Qualified Confirmation (German BZSt)

```typescript
const result = await client.validate("DE123456789", {
  requester_vat_id: "DE987654321",
  company_name: "Example GmbH",
  company_city: "Berlin",
  company_zip: "10115",
});

if (result.qualified_confirmation) {
  console.log(result.qualified_confirmation.company_name);
}
```

### Error Handling

```typescript
import { Giltiq, GiltiqApiError } from "@giltiq/sdk";

try {
  const result = await client.validate("INVALID");
} catch (error) {
  if (error instanceof GiltiqApiError) {
    console.error(error.code, error.message, error.status);
  }
}
```

## Configuration

```typescript
const client = new Giltiq({
  apiKey: "your-api-key",
  baseUrl: "https://api.giltiq.de", // default
  timeout: 15000, // ms, default
  retries: 2, // default
});
```

## Documentation

Full API documentation at [giltiq.de/docs](https://giltiq.de/docs).

## License

MIT
npm package: @gim1ing/chatgpt-authenticator
Description: OpenAI Authentication Library for ChatGPT
Author: Gimling
Latest version: 0.0.5

[![CI Workflow](https://github.com/AllanOricil/chat-gpt-authenticator/actions/workflows/ci.yml/badge.svg)](https://github.com/AllanOricil/chat-gpt-authenticator/actions/workflows/ci.yml)

# ChatGPT Authenticator

This node library is based on this
python [implementation](https://github.com/acheong08/OpenAIAuth/blob/main/src/OpenAIAuth.py).

Since AllanOricil/chat-gpt-authenticator is not maintained, I forked it for further update.

## How to use

Create an Open AI account in this [link](https://platform.openai.com/login/).

### Methods

```js
//requests a new token or return a token that has already been fetched
chatGPTAuthTokenService.getToken()
:
<Promise>

    //requests a new token
    chatGPTAuthTokenService.refreshToken() :
    <Promise>
```

### ES Modules

```js
import {ChatGPTAuthTokenService} from "chat-gpt-authenticator";

const chatGptAuthTokenService = new ChatGPTAuthTokenService(
    "OPEN_AI_EMAIL",
    "OPEN_AI_PASSWORD"
);

(async () => {
    const token = await chatGptAuthTokenService.getToken();
    console.log(token);

    token = await chatGPTAuthTokenService.refreshToken();
    console.log(token);
})();
```

### Common JS

```js
const {ChatGPTAuthTokenService} = require("chat-gpt-authenticator");

const chatGPTAuthTokenService = new ChatGPTAuthTokenService(
    "OPEN_AI_EMAIL",
    "OPEN_AI_PASSWORD"
);

(async () => {
    let token = await chatGPTAuthTokenService.getToken();
    console.log(token);

    token = await chatGPTAuthTokenService.refreshToken();
    console.log(token);
})();
```
npm package: @gimenete/type-writer
Description: Generate type definitions for TypeScript, Flow, PropTypes, etc. by using examples of the data
Author: Alberto Gimeno
Latest version: 0.1.5

# 📇 Typewriter

Generate type definitions for TypeScript, Flow, PropTypes, etc. by using examples of the data

## Installing

```
npm install @gimenete/type-writer
# or
yarn add @gimenete/type-writer
```

## Example

```javascript
const TypeWriter = require('@gimenete/type-writer')
const tw = new TypeWriter()
const examples = []
examples.push({ user: { name: 'Julia' }, foo: 'bar' })
examples.push({ user: { name: 'Julia' }, foo: 1 })
examples.push({ user: { name: 'Julia' }, foo: [1, 2, 3] })
tw.add(examples, { rootTypeName: 'ProjectName' })
console.log('# TypeScript')
console.log(tw.generate('typescript'))
console.log()
console.log('# Inlined TypeScript')
console.log(tw.generate('typescript', { inlined: true }))
console.log()
console.log('# Inlined PropTypes')
console.log(tw.generate('propTypes', { inlined: true }))
console.log()
console.log('# PropTypes')
console.log(tw.generate('propTypes'))
console.log()
```

Output:

```
# TypeScript
type ProjectNameUser = { name: string }
type ProjectName = {
  user: ProjectNameUser,
  foo: string | number | Array<number>
}


# Inlined TypeScript
{
  user: { name: string },
  foo: string | number | Array<number>
}

# Inlined PropTypes
PropTypes.shape({
  user: PropTypes.shape({ name: PropTypes.string.isRequired }).isRequired,
  foo: PropTypes.oneOfType(
    PropTypes.string,
    PropTypes.number,
    PropTypes.arrayOf(PropTypes.number)
  ).isRequired
})

# PropTypes
const ProjectNameUser = PropTypes.shape({ name: PropTypes.string.isRequired })
const ProjectName = PropTypes.shape({
  user: ProjectNameUser.isRequired,
  foo: PropTypes.oneOfType(
    PropTypes.string,
    PropTypes.number,
    PropTypes.arrayOf(PropTypes.number)
  ).isRequired
})
```
npm package: @gimerstedt/log
Description: misc. logging.
Latest version: 0.1.0

# log
simple log util, env-var LOG\_LEVEL controls log level (none, error, warn, info)

## example logging
``` typescript
import { log } from '@gimerstedt/log'

log.info('yup')
log.success('yup')
log.warn('yup')
log.error('yup')
```
npm package: @gimerstedt/log-express-middleware
Description: express middlware logging.
Latest version: 0.0.1

# log-express-middleware
simple express logging middleware, env-var LOG\_LEVEL controls log level (none, error, warn, info)

## example
``` typescript
import { logger } from '@gimerstedt/log-express-middleware'
import express from 'express'

express()
  .use(logger())
  .get('/y', (_,r) => r.send('y'))
  .get('/n', (_,r) => r.status(500).send('n'))
  .listen(3333)
```
npm package: @gimerstedt/pipe-buffer
Description: write a Buffer to stdin of a cli-app and get the resulting stdout
Latest version: 0.0.2

# pipeBuffer
write a Buffer to stdin of a cli-app and get the resulting stdout as a Promise\<Buffer\>

## stupid example
``` typescript
const stdin = 'console.log(2 * 3 * 7)'
const buffer = Buffer.from(stdin)
const buf2str = (b: Buffer) => b.toString()
const str2int = (s: string) => parseInt(s.trim())
const is42 = (n: number) => n === 42

pipeBuffer(buffer, 'node')
  .then(buf2str)
  .then(str2int)
  .then(is42)
  .then(console.log) // true
```