open-index/open-npm huggingface dataset:
npm package: @inghamdev/xlf-merge
Description: Command-line tool for merging XLF files
Author: Brendan Ingham
Latest version: 1.0.11

# xlf-merge

## Forked from <https://github.com/jaroslavsvak/xlf-merge>

Command line tool that merges any number of XLF 1.2 files.

Useful for Angular apps where the NG compiler requires single translation file per language. If your translations are organized into
many small XLF files you can run this tool to merge them before invoking Angular compilation.

## Installation

```bash
npm install -g @inghamdev/xlf-merge
```

```bash
yarn global add @inghamdev/xlf-merge
```

## Usage

- Accespts any number of input files (wildcards supported)
- Requires single output file path (-o parameter)
- If an input file contains a translation (and another input has the same target) they are merged across.

```bash
# Merges three input files into output.xlf
xlf-merge input1.xlf input2.xlf input3.xlf -o output.xlf

# Merges all language-specific XLF files in directory i18n into a file containing all translations per language
xlf-merge i18n/*.en.xlf -o all.en.xlf
xlf-merge i18n/*.de.xlf -o all.de.xlf
xlf-merge i18n/*.fr.xlf -o all.fr.xlf
```

## Author

[Brendan Ingham](https://github.com/breningham)

## License

MIT
npm package: @ingirorhaun/oc-react-dropdown-select
Description: Dropdown select component for React
Latest version: 1.0.6

# React Dropdown Select

A customizable dropdown select component for React applications.

## Installation

```bash
npm install @ingirorhaun/oc-react-dropdown-select
```

## Usage

```javascript
import DropdownSelect from "@ingirorhaun/oc-react-dropdown-select";

const options = [
  { value: "option1", label: "Option 1" },
  { value: "option2", label: "Option 2" },
];

function App() {
  const handleSelect = (e) => {
    console.log("Selected:", e.target.value);
  };

  return (
    <DropdownSelect
      options={options}
      onSelect={handleSelect}
      id="my-dropdown"
    />
  );
}
```
npm package: @ingitdb/client
Description: Core types, interfaces, and utilities for inGitDB clients
Latest version: 0.1.0

# @ingitdb/client

[![npm version](https://img.shields.io/npm/v/@ingitdb/client)](https://www.npmjs.com/package/@ingitdb/client)

Core types, interfaces, and shared utilities for inGitDB clients. This package is a **pure abstraction layer** — it has no dependency on IndexedDB, browser APIs, or Node.js-specific modules and works in any JavaScript environment.

## Packages

| Package | Description |
|---------|-------------|
| `@ingitdb/client` | Core interfaces and shared utilities (this package) |
| [`@ingitdb/client-github`](../client-github/README.md) | Browser client backed by the GitHub REST API (owns IndexedDB) |
| [`@ingitdb/client-fs`](../client-fs/README.md) | Client for local git repositories *(coming soon)* |

## Installation

```bash
npm install @ingitdb/client
```

## What's in this package

- **`IngitDbClient`** — transport-agnostic client interface
- **`Cache` / `StorageAdapter`** — caching interfaces + `createCache(adapter?)` factory
  - No adapter → memory-only (works in Node.js, browsers, tests)
  - Pass a `StorageAdapter` (e.g. `idbCache` from `@ingitdb/client-github`) for persistence
- **`CollectionSchema`** — schema parsing utilities (`parseCollectionSchema`, `normalizeCollectionSchema`)
- **`parseYaml` / `stringifyYaml`** — YAML helpers
- **`createCommittedChangesStore`** — in-memory `CommittedChangesStore` (Node.js / testing)
- **Shared types** — `DatabaseConfig`, `RecordRow`, `RecordData`, `FKView`, `RepoMeta`, `RepoSettings`, `PendingChange`, `CommittedChangesStore`, `PendingChangesStore`

## What's NOT in this package

IndexedDB and any other browser/platform-specific storage is intentionally absent. The `StorageAdapter` interface lets you plug in your own:

```ts
import { createCache } from '@ingitdb/client'
import { idbCache } from '@ingitdb/client-github' // browser IDB adapter

const cache = createCache(idbCache) // IDB-backed
const memCache = createCache()      // memory-only
```

## Development

```bash
pnpm build     # compile to dist/
pnpm lint      # tsc --noEmit
pnpm test      # vitest (watch)
pnpm test:run  # vitest (single run)
```
npm package: @ingitdb/client-github
Description: inGitDB client implementation using the GitHub REST API
Latest version: 0.1.0

# @ingitdb/client-github

[![npm version](https://img.shields.io/npm/v/@ingitdb/client-github)](https://www.npmjs.com/package/@ingitdb/client-github)
[![CI](https://github.com/ingitdb/ingitdb-client-ts/actions/workflows/publish.yml/badge.svg)](https://github.com/ingitdb/ingitdb-client-ts/actions/workflows/publish.yml)

GitHub API-backed inGitDB client — use GitHub repositories as a structured database.

This package is the **browser implementation** of `@ingitdb/client`. It owns all IndexedDB-specific code:
- `idbCache` — `StorageAdapter` backed by IndexedDB (for persistent HTTP response caching)
- `createIdbCommittedChangesStore` — `CommittedChangesStore` backed by IndexedDB

For Node.js environments or testing, use `createCache()` and `createCommittedChangesStore()` from `@ingitdb/client` (memory-only).

## Installation

```bash
npm install @ingitdb/client-github
```

Peer dependencies (must be installed separately):

```bash
npm install axios idb @ingr/codec
```

## Usage

```ts
import { createIngitDbClient } from '@ingitdb/client-github'

const client = createIngitDbClient({ token: 'ghp_...' })

const config = await client.loadDatabaseConfig('owner/repo')
const schema = await client.loadCollectionSchema('owner/repo', 'main', 'countries')
const { records } = await client.loadCollectionRecords('owner/repo', 'main', 'countries', schema.schema, schema.collectionPath)
```

### Disable persistence (memory-only cache)

```ts
const client = createIngitDbClient({ token: 'ghp_...', cache: false })
```

### Use the IDB adapters directly

```ts
import { createCache } from '@ingitdb/client'
import { idbCache, createIdbCommittedChangesStore } from '@ingitdb/client-github'

const cache = createCache(idbCache)
const committedStore = createIdbCommittedChangesStore()
```

## Features

- Zero framework dependencies (no Vue, React, Angular, or RxJS)
- Optional GitHub token for authenticated access
- IndexedDB + in-memory caching (browser); memory-only (`cache: false`) for SSR/Node
- Full schema support (columns, FK views, materialized views)
- Pending and committed changes tracking with IDB persistence
- Dual ESM + CJS build with full TypeScript declarations

## Development

```bash
pnpm build     # compile to dist/
pnpm lint      # tsc --noEmit
pnpm test      # vitest (watch)
pnpm test:run  # vitest (single run)
```

> `@ingitdb/client` must be built before running `lint` or `test:run` in this package.
> From the monorepo root, `pnpm build`, `pnpm lint`, and `pnpm test:run` handle the order automatically via Turborepo.
> To build the dependency manually: `pnpm --filter @ingitdb/client build`
npm package: @inglorious-three/tech-bullshit-word-generator
Description: Useful library to create tech bullshit phrases.
Latest version: 0.2.2

# tech-bullshit-word-generator

Usefull library to create tech bullshit phrases.

## Usage

 ```javascript
    const wordGenerator = require('@inglorious-three/tech-bullshit-word-generator');
    
    const randomWord = wordGenerator.getRandomWord();
    
    console.log(randomWord); // 'KI'
 ```
npm package: @inglorious/ag-grid
Description: AG Grid integration for Inglorious Web.
Author: IceOnFire
Latest version: 4.0.2

# @inglorious/ag-grid

AG Grid integration for Inglorious Web.

This package is intentionally thin: it provides a generic `agGrid` type and minimal adapter CSS.
Keep app-specific data mutations and domain handlers in your app types via composition.

## Install

```bash
pnpm add @inglorious/ag-grid @inglorious/web ag-grid-community
```

## Usage

```js
import { createStore } from "@inglorious/web"
import { AgGrid, configureAgGrid } from "@inglorious/ag-grid"
import {
  AllCommunityModule,
  createGrid,
  ModuleRegistry,
} from "ag-grid-community"

configureAgGrid({
  createGrid,
  registerModules() {
    ModuleRegistry.registerModules([AllCommunityModule])
  },
})

const store = createStore({
  types: {
    AgGrid,
  },
  entities: {
    agGrid: {
      type: "AgGrid",
      columnDefs: [],
      rowData: [],
    },
  },
})
```

```js
import "ag-grid-community/styles/ag-grid.css"
import "ag-grid-community/styles/ag-theme-quartz.css"
```

Set sizing from entity state:

```js
{
  type: "AgGrid",
  themeClass: "ag-theme-quartz",
  height: 520, // number (px) or CSS string like "70vh"
  gridOptions: {
    suppressCellFocus: true,
  },
  columnDefs: [],
  rowData: [],
}
```

For AG Grid Enterprise, import enterprise modules and license setup in your app, then pass the enterprise `createGrid` and module registration via `configureAgGrid(...)`.

## Event handlers

The adapter keeps a small event surface:

- `mounted` updates runtime status when the grid instance is ready.
- `rowDataChange` replaces `entity.rowData`.
- `columnDefsChange` replaces `entity.columnDefs`.
- `gridOptionsChange` replaces `entity.gridOptions`.
- `apiCall` calls a grid API method by name:

```js
api.notify("#agGrid:apiCall", { method: "sizeColumnsToFit" })
api.notify("#agGrid:apiCall", {
  method: "setFilterModel",
  args: [{ id: null }],
})
```

Backward-compatible aliases still exist (`gridMounted`, `setRowData`, `setColumnDefs`, `setGridOptions`).
npm package: @inglorious/babel-preset-inglorious-script
Description: Babel preset for the IngloriousScript language.
Author: IceOnFire
Latest version: 1.0.6

# @inglorious/babel-preset-inglorious-script

[![npm version](https://img.shields.io/npm/v/@inglorious/babel-preset-inglorious-script.svg)](https://www.npmjs.com/package/@inglorious/babel-preset-inglorious-script)

This package is the official Babel preset for **IngloriousScript**.

It provides a convenient way to enable vector operator overloading by including the [`@inglorious/babel-plugin-inglorious-script`](../babel-plugin-inglorious-script/README.md) plugin.

## Installation

First, install the preset using your package manager:

```bash
npm install -D @inglorious/babel-preset-inglorious-script
# or
yarn add -D @inglorious/babel-preset-inglorious-script
# or
pnpm add -D @inglorious/babel-preset-inglorious-script
```

## Usage

Add the preset to your Babel configuration file (e.g., `.babelrc.json`).

```json
{
  "presets": ["@inglorious/inglorious-script"]
}
```

Babel will automatically resolve `@inglorious/inglorious-script` to `@inglorious/babel-preset-inglorious-script`.

### What is IngloriousScript?

IngloriousScript is a superset of JavaScript that allows you to use intuitive arithmetic operators (`+`, `-`, `*`, `/`, etc.) for vector math.

```javascript
// Before
const newPosition = mod(add(position, scale(velocity, dt)), worldSize)

// After (with IngloriousScript)
const newPosition = (position + velocity * dt) % worldSize
```

For a complete guide on features, supported operators, and advanced usage, please see the documentation for the **[`@inglorious/babel-plugin-inglorious-script`](https://www.npmjs.com/package/@inglorious/babel-plugin-inglorious-script)** package.
npm package: @inglorious/create-app
Description: A scaffolding tool to quickly create a new app with Inglorious Web.
Author: IceOnFire
Latest version: 1.0.2

# @inglorious/create-app

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

The official scaffolding tool to quickly create a new web app with the [@inglorious/web](https://www.npmjs.com/package/@inglorious/web) framework or a static site with [@inglorious/ssx](https://www.npmjs.com/package/@inglorious/ssx).

This package allows you to generate a new project from a set of pre-configured templates, so you can start developing your web app right away.

## Usage

To create a new app, run one of the following commands in your terminal. You will be prompted to choose a project name and select a template.

```bash
# with npm
npm create @inglorious/app@latest

# with yarn
yarn create @inglorious/app

# with pnpm
pnpm create @inglorious/app
```

The CLI will guide you through the setup process, asking for a project name and which template you'd like to use.

## Templates

The following templates are available to get you started:

- **minimal**: A minimal starter template that requires no bundling: just HTML, CSS, and JS.
- **js**: A starter template for a plain JavaScript project, bundled with Vite.
- **ts**: A starter template for a plain TypeScript project, bundled with Vite.
- **ssx-js**: A starter template for a Static Site Xecution (SSX) project using JavaScript.
- **ssx-ts**: A starter template for a Static Site Xecution (SSX) project using TypeScript.

## What it does

The tool will create a new directory with your chosen project name and copy the template files into it. It will also automatically update the `package.json` with your project's name.

After the project is created, you can navigate into the directory and install the dependencies.

```bash
# 1. Change into your new project directory
cd my-awesome-app

# 2. Install dependencies
pnpm install

# 3. Start the development server
pnpm dev
```

## License

**MIT License - Free and open source**

Created by [Matteo Antony Mistretta](https://github.com/IngloriousCoderz)

You're free to use, modify, and distribute this software. See [LICENSE](./LICENSE) for details.
npm package: @inglorious/create-game
Description: A scaffolding tool to quickly create a new game with the Inglorious Engine.
Author: IceOnFire
Latest version: 1.0.9

# @inglorious/create-game

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

The official scaffolding tool to quickly create a new game with the [Inglorious Engine](https://www.npmjs.com/package/@inglorious/engine).

This package allows you to generate a new project from a set of pre-configured templates, so you can start developing your game right away.

## Usage

To create a new game, run one of the following commands in your terminal. You will be prompted to choose a project name and select a template.

```bash
# with npm
npm create @inglorious/game@latest

# with yarn
yarn create @inglorious/game

# with pnpm
pnpm create @inglorious/game
```

The CLI will guide you through the setup process, asking for a project name and which template you'd like to use.

## Templates

The following templates are available to get you started:

- **minimal**: A minimal starter template that requires no bundling: just HTML, CSS, and JS.
- **js**: A starter template for a plain JavaScript project, bundled with Vite.
- **ts**: A starter template for a plain TypeScript project, bundled with Vite.
- **ijs** (IngloriousScript): A starter template for a JavaScript project using IngloriousScript, bundled with Vite.
- **its** (IngloriousScript w/ TypeScript): A starter template for a TypeScript project that uses IngloriousScript, bundled with Vite.

## What it does

The tool will create a new directory with your chosen project name and copy the template files into it. It will also automatically update the `package.json` with your project's name.

After the project is created, you can navigate into the directory and install the dependencies.

```bash
# 1. Change into your new project directory
cd my-awesome-game

# 2. Install dependencies
pnpm install

# 3. Start the development server
pnpm dev
```

## License

**MIT License - Free and open source**

Created by [Matteo Antony Mistretta](https://github.com/IngloriousCoderz)

You're free to use, modify, and distribute this software. See [LICENSE](./LICENSE) for details.
npm package: @inglorious/logo
Description: The Inglorious Coderz logo, remade to be compatible with Inglorious Web.
Author: IceOnFire
Latest version: 3.0.2

# @inglorious/logo

The Inglorious Logo component — a small, dependency-light package that provides the 3D logo render and interactive handlers for Inglorious Web.

---

## Install

Add the package to your project:

```bash
pnpm add @inglorious/logo
```

---

## Usage

Import the package and its stylesheet, and (optionally) the types for TypeScript.

Then, register the `logo` type in your store, create an entity of that type, and use `api.render(entityId)` inside your templates (see the [`web-logo`](https://github.com/IngloriousCoderz/inglorious-forge/tree/main/examples/apps/web-logo) demo app).

```js
import { createStore } from "@inglorious/web"
import { logo } from "@inglorious/logo"
import "@inglorious/logo/style.css"

const entities = {
  logo: {
    type: "Logo",
    size: 256,
    faces: [
      { image: "I", reverse: false, eye: true },
      { image: "W", reverse: false, eye: false },
    ],
    isInteractive: false,
    isScrollPrevented: true,
  },
}

const store = createStore({
  types: { logo },
  entities,
})

// app render function receives `api` from mount()
const app = {
  render(api) {
    return api.render("logo")
  },
}

// TypeScript: import the entity type if you want to annotate entity shapes
// import type { LogoEntity } from "@inglorious/logo"
```

---

## License

**MIT License - Free and open source**

Created by [Matteo Antony Mistretta](https://github.com/IngloriousCoderz)

You're free to use, modify, and distribute this software. See [LICENSE](./LICENSE) for details.

---

## Contributing

Contributions welcome! Please read our [Contributing Guidelines](../../CONTRIBUTING.md) first.
npm package: @inglorious/motion
Description: CSS-first motion helpers for Inglorious Web type composition.
Author: IceOnFire
Latest version: 4.0.2

# @inglorious/motion

CSS-first motion primitives for `@inglorious/web` using type composition.

## Install

```bash
pnpm add @inglorious/motion @inglorious/web
```

## API

### `withMotion(config)`

Composes a type with a motion lifecycle driven by WAAPI.

- Adds `motionVariantChange(entity, variant)` handler.
- Adds `removeWithMotion(entity, payload, api)` handler (plays exit variant, then removes entity).
- Supports layout FLIP with `layout: true` (or custom timing).
- Supports shared layout transitions with `motionLayoutId`.
- Supports presence groups with `presence: { mode: "wait" }`.
- Wraps your render with a motion host and applies lifecycle classes:
  - `${classPrefix}--start`
  - `${classPrefix}--active`
  - `${classPrefix}--end`
  - `${classPrefix}--variant-<name>`

## Stability

- Stable:
  - Variant lifecycle (`motionVariantChange`, `removeWithMotion`)
  - Class phases (`--start`, `--active`, `--end`, `--variant-*`)
  - Presence `mode: "wait"` semantics (queue exits per group)
- Experimental:
  - Shared-layout behavior driven by `motionLayoutId`
  - Internal FLIP heuristics and thresholds

## Migration policy

- Patch versions: bug fixes and non-breaking behavior improvements.
- Minor versions: additive config and handlers; no required app changes.
- Major versions: breaking semantics or API shape changes.
- Deprecated behavior keeps a compatibility alias for at least one minor release when feasible.

## Browser support and fallbacks

- Primary engine: WAAPI (`Element.animate`).
- If WAAPI is unavailable, motion still updates final styles and lifecycle classes (no smooth tween).
- `prefers-reduced-motion: reduce` is honored by skipping tweening and committing end state.
- For robust visual guarantees across browsers, use Playwright E2E (unit tests cover deterministic logic only).

## Example

```js
import { html } from "@inglorious/web"
import { withMotion } from "@inglorious/motion"

const card = {
  render(entity, api) {
    return html`
      <article>
        <button
          @click=${() =>
            api.notify(`#${entity.id}:motionVariantChange`, "hidden")}
        >
          Hide
        </button>
        <button
          @click=${() => api.notify(`#${entity.id}:removeWithMotion`, "exit")}
        >
          Remove
        </button>
      </article>
    `
  },
}

const motionCard = [
  card,
  withMotion({
    initial: "visible",
    layout: true,
    presence: { mode: "wait" },
    variants: {
      visible: {
        frames: [
          { opacity: 0, transform: "translateY(12px)" },
          { opacity: 1, transform: "translateY(0)" },
        ],
        options: { duration: 220, easing: "ease-out" },
      },
      hidden: {
        frames: [{ opacity: 1 }, { opacity: 0.2 }],
        options: { duration: 180, easing: "ease-in" },
      },
      exit: {
        frames: [
          { opacity: 1, transform: "scale(1)" },
          { opacity: 0, transform: "scale(0.96)" },
        ],
        options: { duration: 160, easing: "ease-in" },
      },
    },
  }),
]
```
npm package: @inglorious/ui
Description: A design system for Inglorious Web with render-function components and customizable themes
Author: IceOnFire
Latest version: 2.0.2

# @inglorious/ui

A design system for Inglorious Web with render-function components and customizable themes.

## Getting started

Import the base stylesheet (tokens + reset), pick a theme, then pull in the component styles you need:

```js
import "@inglorious/ui/base.css"
import "@inglorious/ui/themes/bootstrap.css"
import "@inglorious/ui/data-grid.css"
```

Apply the theme classes to your root element (or any container that wraps your UI), otherwise the theme will not take effect:

```html
<body class="iw-theme-bootstrap iw-theme-light">
  <!-- Your app -->
</body>
```

If you want everything, you can import the full bundle:

```js
import "@inglorious/ui/all.css"
```

## Styles structure

The core styles live under `src/styles/`:

- `styles/reset.css`: sensible resets (box-sizing, body margin, etc.)
- `styles/tokens.css`: design tokens
- `styles/base.css`: reset + tokens (the recommended public entry)
- `styles/themes/`: built-in themes

The public CSS exports are:

- `@inglorious/ui/base.css`
- `@inglorious/ui/tokens.css`
- `@inglorious/ui/themes/inglorious.css`
- `@inglorious/ui/themes/material.css`
- `@inglorious/ui/themes/bootstrap.css`
- `@inglorious/ui/all.css`
npm package: @inglorious/utils
Description: A set of general-purpose utility functions designed with functional programming principles in mind.
Author: IceOnFire
Latest version: 3.8.0

# Inglorious Utils

[![NPM version](https://img.shields.io/npm/v/@inglorious/utils.svg)](https://www.npmjs.com/package/@inglorious/utils)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

A set of general-purpose utility functions designed with functional programming principles in mind. This package is part of the [Inglorious Forge](https://github.com/IngloriousCoderz/inglorious-forge) monorepo.

---

## Overview

This package provides a collection of pure, composable helper functions to streamline development in any JavaScript or TypeScript project. It embraces a data-oriented and functional approach, operating on plain data structures like objects and arrays.

---

## Installation

```bash
npm install @inglorious/utils
```

---

## Usage

Here are a few examples of how you can use the utilities in this package.

### `pipe`

Compose functions together in a readable, left-to-right sequence.

```javascript
import { pipe } from "@inglorious/utils/functions/functions"

const add = (a) => (b) => a + b
const multiply = (a) => (b) => a * b

const calculate = pipe(
  add(5), // 10 + 5 = 15
  multiply(2), // 15 * 2 = 30
  add(10), // 30 + 10 = 40
)

const result = calculate(10) // 40
```

### Vector Math

Perform vector operations on plain objects.

```javascript
import { add } from "@inglorious/utils/math/vector.js"

const position = [10, 20]
const velocity = [2, -1]

const newPosition = add(position, velocity)
// => [12, 19]
```

---

## API

This package is designed to be used with subpath imports, which helps with tree-shaking.

- **`@inglorious/utils/algorithms`**: Utilities for AI algorithms, like decision trees and A\*.
- **`@inglorious/utils/functions`**: Utilities for function composition.
- **`@inglorious/utils/math`**: Utilities for math operations.
- **`@inglorious/utils/physics`**: Utilities for calculations on friction, acceleration, and gravity.

---

## License

**MIT License - Free and open source**

Created by [Matteo Antony Mistretta](https://github.com/IngloriousCoderz)

You're free to use, modify, and distribute this software. See [LICENSE](./LICENSE) for details.

---

## Contributing

We welcome contributions! Please see the root `CONTRIBUTING.md` file for more details.
npm package: @ingluza/platzom
Description: Traductor de idioma platzom
Author: Sacha Lifszyc
Latest version: 0.1.0

# Platzom

Platzom es un idioma inventado para el [Curso de Fundamentos de JavaScript](https://platzi.com/js) de [Platzi](https://platzi.com), el mejor lugar de educación online

## Descripción del idioma

- Si la palabra termina con "ar", se le quitan esas dos letras
- Si la palabra inicia con Z, se le añade "pe" al final
- Si la palabra traducida tiene 10 o más letras, se debe partir en dos por la mitad y unir con un guión medio
- Por último, si la palabra original es un palíndromo, ninguna regla anterior cuenta y se devuelve la misma palabra pero intercalando letras mayúsculas y minúsculas

## Instalación

```
npm install platzom
```

## Uso

```
import platzom from 'platzom'

platzom("Programar") // Program
platzom("Zorro") // Zorrope
platzom("Zarpar") // Zarppe
platzom("abecedario") // abece-dario
platzom("sometemos") // SoMeTeMoS
```

## Créditos
- [Sacha Lifszyc](https://twitter.com/@slifszyc)

## Licencia

[MIT](https://opensource.org/licenses/MIT)
npm package: @ingrain/ingrain-client-js
Description: Ingrain (ingrain.dev) client-side SDK
Author: Ingrain
Latest version: 0.0.6

# Ingrain Client SDK

Ingrain (https://ingrain.dev) SDK for the browser.

<p align="middle">
  <img src="https://ingrain.dev/_next/image?url=%2Ficon.png&w=128&q=100" width="20%">
</p>

## Overview

This is the client-side Javascript SDK for [Ingrain](https://ingrain.dev). Ingrain is a service that makes it easy for you to add user activity logging to your app in minutes.

### UI Components Package

Ingrain also provides React UI Components that work out of the box. The components are part of the [Ingrain React](https://www.npmjs.com/package/@ingrain/ingrain-react) package.

## Getting Started

### Installation

```sh
npm i @ingrain/ingrain-client-js
```

or with `yarn`:

```sh
yarn add @ingrain/ingrain-client-js
```

## Usage

```ts
import { Ingrain } from '@ingrain/ingrain-client-js';

// Initialize Ingrain
const opts = {
  publishableKey: 'your-publishable-key',
  getUserJwtToken: async () => {
    return "your-user's-jwt-token";
  },
};

const ingrain = new Ingrain(opts);

// Log action
ingrain
  .createUserEvent({
    actorId: 'example-actor-id',
    actorDisplayName: 'example-actor-id',
    actorMetadata: {
      // Can also be null for no metadata
      any: 'any',
      metadata: 'metadata',
      here: 'here',
    },
    entityId: 'example-application',
    entityName: 'Example Application',
    entityDisplayLabel: `Example Application's settings`,
    entityMetadata: null,
    entityPropName: 'Settings', // Can be null
    appUserOrgId: 'example-org-id',
    action: Action.UPDATE,
    oldValue: 'old-settings-value', // can be null
    newValue: 'new-settings-value', // can be null
  })
  .catch((err) => {
    console.error('Error creating user event', err);
  });

// Get data
ingrain
  .readUserEvents({
    actorId: 'example-actor-id',
  })
  .then((resp) => {
    const { data } = resp;

    // Display the data
  });
```

## Documentation

You can start from [Introduction](https://docs.ingrain.dev) or jump straight to [Client JS SDK](https://docs.ingrain.dev/category/client-javascript-sdk)
npm package: @ingrain/ingrain-react
Description: Ingrain (ingrain.dev) React components for display user activity audit trails
Author: Ingrain
Latest version: 0.0.8

# Ingrain React

<p align="middle">
  <img src="https://ingrain.dev/_next/image?url=%2Ficon.png&w=128&q=100" width="20%">
</p>

## Overview

This is the React UI Components package for [Ingrain](https://ingrain.dev).

Ingrain is the fastest and easiest way to integrate activity audit trails in your app. Log a trail of user activities and employ our easy-to-integrate components to display these actions within your app's interface, offering your users a transparent view of their account activities.

### Client JS SDK

If you only need the client side SDK, you can check out [Ingrain Client SDK](https://www.npmjs.com/package/@ingrain/ingrain-client-js).

## Getting Started

### Prerequisites

- React v18+
- Node.js v18+

### Installation

```sh
npm i @ingrain/ingrain-react
```

or with `yarn`:

```
yarn add @ingrain/ingrain-react
```

## Usage

Ingrain requires your application to be wrapped in the `<IngrainProvider/>` context.

If using Create React App, set `REACT_APP_INGRAIN_PUBLISHABLE_KEY` to your publishable key in your `.env.local` file to make the environment variable accessible on `process.env` and pass it as the `publishableKey` prop.

You will also need to obtain and pass in your user's JWT.

```jsx
import { render } from 'react-dom';

import { IngrainProvider, UserActivity, EntityActivity  } from '@ingrain/ingrain-react';

const publishableKey = process.env.REACT_APP_INGRAIN_PUBLISHABLE_KEY;
const userJwt = getUserJWT(); // Define how you can obtain your user's JWT

render(
  <IngrainProvider
    theme={{ mode: 'light' }} // or set it to dark mode. You can also customize your colors here.
    opts={{
      publishableKey,
      getUserJwtToken: () => {
        return userJwt;
      },
    }}
  >
    <App />
  </IngrainProvider>,
  document.getElementById('root'),
);

function App() {
  return (
    <>
      {/* Activity timeline based on user */}
      <UserActivity userId={'user-id-here'}>
      {/* Activity timeline based on entity e.g. access token changes */}
      <EntityActivity entityId={'entity-id-here'}>
    </>
  );
}
```

## Documentation

You can start from [Introduction](https://docs.ingrain.dev) or jump straight to [React UI Components](https://docs.ingrain.dev/category/component-references)

## Contributing

We're open to all community contributions! If you'd like to contribute in any way, please read [our contributing guidelines](https://github.com/ingrain-dev/ingrain-javascript/blob/main/packages/react/docs/CONTRIBUTING.md)
npm package: @ingram-tech/camt053
Description: TypeScript parser for ISO 20022 CAMT.053 (Bank-to-Customer Statement) XML
Latest version: 0.1.0

# @ingram-tech/camt053

TypeScript parser for [ISO 20022](https://www.iso20022.org/) CAMT.053 (Bank-to-Customer Statement) XML documents. Parses CAMT.053.001.x (any version) into fully typed objects, extracting every data element from the standard.

## Installation

```bash
npm install @ingram-tech/camt053
```

## Usage

```typescript
import { parseCamt053 } from "@ingram-tech/camt053";

const xml = fs.readFileSync("statement.xml", "utf8");
const report = parseCamt053(xml);

if (report) {
    console.log(report.messageId);
    for (const stmt of report.statements) {
        console.log(`Account: ${stmt.account.iban}`);
        console.log(`Owner: ${stmt.account.owner?.name}`);
        console.log(`Bank: ${stmt.account.servicer?.name}`);

        for (const balance of stmt.balances) {
            console.log(`${balance.type}: ${balance.amount} ${balance.currency}`);
        }

        for (const entry of stmt.entries) {
            console.log(`${entry.creditDebitIndicator} ${entry.amount} ${entry.currency}`);
            console.log(`  Status: ${entry.status}`);
            console.log(`  Info: ${entry.additionalInformation}`);

            if (entry.amountDetails?.currencyExchange) {
                const fx = entry.amountDetails.currencyExchange;
                console.log(`  FX: ${fx.sourceCurrency}/${fx.targetCurrency} @ ${fx.exchangeRate}`);
            }
        }
    }
}
```

## Parsed fields

The parser extracts all CAMT.053 data elements:

- **Group header**: message ID, creation date, recipient
- **Statement**: ID, sequence numbers, date range, account, balances, entries
- **Account**: IBAN or other ID, currency, owner (name, address, org ID), servicer (name, BIC, address)
- **Balances**: type (OPBD, CLBD, CLAV, etc.), amount, currency, credit/debit indicator, date
- **Transaction summary**: total/credit/debit entry counts and sums, net amount
- **Entries**: reference, amount, currency, credit/debit, status, booking/value dates, bank transaction code, charges, reversal indicator, additional info
- **Amount details**: transaction amount, currency exchange (source/target/unit currency, exchange rate)
- **Entry details**: batch info, transaction details
- **Transaction details**: references (message/payment/instruction/end-to-end/transaction/mandate IDs), amount details, bank transaction code, related parties (debtor/creditor/ultimate), related agents, purpose, remittance info (unstructured and structured), charges, return info, additional info

## Supported versions

Supports all CAMT.053.001.x namespace versions (001 through 010+), including the v10 `Cdtr > Pty > Nm` nesting used by modern banks.

## Development

```bash
npm test          # run tests in watch mode
npm run test:run  # run tests once
npm run lint      # eslint
npm run format    # prettier
npm run build     # build to dist/
npm run ci        # type-check + lint + test + build
```

## License

MIT
npm package: @ingram-tech/eslint-plugin-recommended
Description: ESLint plugin with recommended rules for Ingram Tech projects
Author: Ingram Tech
Latest version: 1.0.0

# @ingram-tech/eslint-plugin-recommended

ESLint plugin with recommended rules for Ingram Tech projects.

## Installation

```bash
npm install --save-dev @ingram-tech/eslint-plugin-recommended
# or
yarn add -D @ingram-tech/eslint-plugin-recommended
# or
bun add -D @ingram-tech/eslint-plugin-recommended
```

## Usage

Add the plugin to your ESLint configuration:

```javascript
// eslint.config.mjs
import ingramRecommended from "@ingram-tech/eslint-plugin-recommended";

export default [
	{
		plugins: {
			"@ingram-tech/recommended": ingramRecommended,
		},
		rules: {
			"@ingram-tech/recommended/lucide-icon-suffix": "error",
			"@ingram-tech/recommended/supabase-no-direct-imports": "error",
			"@ingram-tech/recommended/supabase-no-insert-with-id": "error",
			"@ingram-tech/recommended/react-no-redundant-usestate-types": "warn",
			"@ingram-tech/recommended/next-no-redirect-only-pages": "warn",
			"@ingram-tech/recommended/nextjs-page-pattern": "error",
		},
	},
];
```

## Available Rules

### `lucide-icon-suffix`

Enforces that all lucide-react icon imports use the "Icon" suffix.

### `supabase-no-direct-imports`

Prevents direct imports from @supabase packages. Use wrapper clients instead.

### `supabase-no-insert-with-id`

Disallows specifying 'id' when inserting into database tables. Let the database auto-generate IDs.

### `react-no-redundant-usestate-types`

Removes redundant type annotations in useState hooks that can be inferred.

### `next-no-redirect-only-pages`

Suggests using next.config.ts redirects instead of pages that only perform redirects.

### `nextjs-page-pattern`

Enforces consistent Next.js page component patterns (const arrow functions with NextPage type).

## License

MIT
npm package: @ingram-tech/ubl
Description: UBL (Universal Business Language) invoice XML parser for TypeScript
Latest version: 0.3.0

# @ingram-tech/ubl

TypeScript parser for [UBL (Universal Business Language)](https://www.oasis-open.org/committees/ubl/) invoice XML documents. Parses UBL 2.1 Invoice and CreditNote documents into typed objects, with an optional normalization layer that produces a flat DTO suitable for database storage or API responses.

## Installation

```bash
npm install @ingram-tech/ubl
```

## Usage

### Parse UBL XML

```typescript
import { parseUblInvoice } from "@ingram-tech/ubl";

const xml = `<?xml version="1.0"?>
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2" ...>
  <cbc:ID>INV-001</cbc:ID>
  ...
</Invoice>`;

const invoice = parseUblInvoice(xml);
// invoice.id => "INV-001"
// invoice.seller.name => "Acme BV"
// invoice.lines[0].description => "Consulting services"
// invoice.monetaryTotal.payableAmount => 121
```

Returns a typed `UblInvoice` object, or `null` if the XML is not a valid UBL Invoice/CreditNote.

### Normalize to DTO

```typescript
import { normalizeUblResponse } from "@ingram-tech/ubl";

const { extracted, rawPayload } = normalizeUblResponse(xml, "doc-123");
// extracted.invoice.invoice_number => "INV-001"
// extracted.invoice.supplier.name => "Acme BV"
// extracted.line_items[0].tax_rate => 21
```

### Parse from raw bytes

```typescript
import { parseUblInvoiceDocument } from "@ingram-tech/ubl";

const result = parseUblInvoiceDocument({
	bytes: new Uint8Array(buffer),
	documentId: "doc-123",
	mimeType: "application/xml",
});
```

Handles UTF-8 BOM stripping automatically.

## Supported document types

- UBL 2.1 Invoice
- UBL 2.1 CreditNote

## Parsed fields

Parties (seller/buyer), addresses, contacts, endpoint IDs, line items with quantities/prices/tax, allowance/charge at both header and line level, tax subtotals, monetary totals, payment means (including multiple), payment terms, invoice period, delivery information, order/contract/project references, notes, and embedded attachments.

## Development

```bash
npm test          # run tests in watch mode
npm run test:run  # run tests once
npm run lint      # eslint
npm run format    # prettier
npm run build     # build to dist/
npm run ci        # type-check + lint + test + build
```