open-index/open-npm huggingface dataset:
npm package: @jteppinette/babel-plugin-import-glob
Description: Babel plugin to enable importing modules using glob patterns.
Latest version: 0.3.0

# Babel Plugin Import Glob

Babel plugin to enable importing modules using glob patterns.

## Usage

Given the following file structure:

```txt
├── images
│   ├── cat.webp
│   └── dog.webp
└── videos
    ├── example-1.mp4
    └── example-2.mp4
```

_Simple_

```js
import { cat, dog } from './images/*.webp'
```

_Alias_

```js
import { cat as c, dog as d } from './images/*.webp'
```

_Default_

```js
import videos from './videos/*.mp4'

console.log(videos['example-1'])
```

_Namespace_

```js
import * as videos from './videos/*.mp4'

console.log(videos['example-1'])
```

## Install

```sh
$ npm install @jteppinette/babel-plugin-import-glob
```

**Configuration**

This plugin simply needs to be added to the Babel plugins array.

Here is a simple bare-bones babel configuration file which only supports
this singular plugin.

_.babelrc_

```json
{
  "plugins": ["@jteppinette/babel-plugin-import-glob"]
}
```

## History

This repo was originally forked from and inspired by [novemberborn/babel-plugin-import-glob](https://github.com/novemberborn/babel-plugin-import-glob). All license and git commits have been kept intact.

The origin repo mentioned above had stagnated for many years and was missing a features that I needed:

- You could not import the default export.
- Namespace import keys were transformed into valid identifiers instead of simply using their wildcard path names.

While I do not think we would ever merge the two, I would be open to the idea.

## Development

### Required Software

- [direnv](https://direnv.net)
- [git](https://git-scm.com/)
- [nvm](https://formulae.brew.sh/formula/nvm#default)
- [pre-commit](https://pre-commit.com/#install)

### Getting Started

**Setup**

```sh
$ nvm install 16
$ direnv allow
$ pre-commit install
$ npm install
```

**Test**

```sh
$ npm test
```

### Publishing

The publish process is automated by GitHub Actions. Once a release is
created (at the end of these steps), the package will be published to
the private GitHub NPM Registry.

1. Bump version, commit, and tag:

   ```sh
   $ npm run version:<major|minor|patch>
   ```

2. Commit the changes, tag the commit, and push the tags:

   ```sh
   $ git push origin main --tags
   ```

3. Convert the tag to a release in GitHub.

   ```sh
   $ open "https://github.com/jteppinette/babel-plugin-import-glob/releases/new?tag=<tag>"
   ```
npm package: @jterrazz/codestyle
Description: Fast, opinionated linting and formatting for TypeScript. Powered by Oxlint, Oxfmt, tsgo, and Knip.
Author: Jean-Baptiste Terrazzoni
Latest version: 2.2.1

# @jterrazz/codestyle

Fast, opinionated linting and formatting for TypeScript. Powered by Oxlint, Oxfmt, tsgo, and Knip.

## Quick Start

```bash
npm install @jterrazz/codestyle --save-dev
```

Create `.oxlintrc.json`:

```json
{
  "extends": ["node_modules/@jterrazz/codestyle/presets/oxlint/node.json"]
}
```

Run:

```bash
npx codestyle check   # Check everything (types + lint + format + unused code)
npx codestyle fix     # Fix lint and formatting issues
```

## Presets

Pick a base config:

| Preset                                                      | Use Case                          |
| ----------------------------------------------------------- | --------------------------------- |
| `node_modules/@jterrazz/codestyle/presets/oxlint/node.json` | Node.js (requires .js extensions) |
| `node_modules/@jterrazz/codestyle/presets/oxlint/expo.json` | Expo / React Native               |
| `node_modules/@jterrazz/codestyle/presets/oxlint/next.json` | Next.js                           |

Architecture preset (additive):

| Preset                                                                         | Use Case                           |
| ------------------------------------------------------------------------------ | ---------------------------------- |
| `node_modules/@jterrazz/codestyle/presets/oxlint/architectures/hexagonal.json` | Hexagonal architecture enforcement |

## Architecture Enforcement

Enforce hexagonal architecture boundaries:

```json
{
  "extends": [
    "node_modules/@jterrazz/codestyle/presets/oxlint/node.json",
    "node_modules/@jterrazz/codestyle/presets/oxlint/architectures/hexagonal.json"
  ]
}
```

Rules enforced:

- `domain/` cannot import from other layers
- `application/` cannot import infrastructure
- `presentation/ui/` cannot import navigation
- `features/` cannot import other features

## Unused Code Detection

`codestyle check` runs [Knip](https://knip.dev/) to detect unused files, exports, and dependencies. Knip auto-detects your framework from `package.json` (Next.js, Vitest, Prisma, etc.) with 100+ built-in plugins.

For fine-tuning, create a `knip.json`:

```json
{
  "$schema": "https://unpkg.com/knip@6/schema.json",
  "ignoreDependencies": ["@jterrazz/codestyle", "@jterrazz/test", "@jterrazz/typescript"],
  "ignoreBinaries": ["oxlint", "oxfmt"]
}
```

Knip only runs in `check` mode (not `fix`) since its auto-fix removes exports and files.

## What Runs

`codestyle check` runs four tools in parallel:

| Tool   | Purpose              |
| ------ | -------------------- |
| tsgo   | Type checking        |
| oxlint | Linting              |
| oxfmt  | Formatting           |
| knip   | Unused code analysis |

`codestyle fix` runs three tools in parallel (knip excluded):

| Tool   | Purpose              |
| ------ | -------------------- |
| tsgo   | Type checking        |
| oxlint | Linting (with --fix) |
| oxfmt  | Formatting           |
npm package: @jterrazz/logger
Description: Structured, type-safe logging for Node.js with pluggable adapters.
Author: Jean-Baptiste Terrazzoni
Latest version: 1.5.1

# @jterrazz/logger

Structured, type-safe logging for Node.js with pluggable adapters.

## Installation

```bash
npm install @jterrazz/logger
```

## Usage

```typescript
import { PinoLoggerAdapter } from "@jterrazz/logger";

const logger = new PinoLoggerAdapter({
  level: "debug",
  prettyPrint: true,
});

logger.info("Server started", { port: 3000 });
logger.error("Request failed", { error: new Error("Connection timeout") });
```

### Child Loggers

Create scoped loggers with persistent context:

```typescript
const requestLogger = logger.child({ requestId: "abc-123" });
requestLogger.info("Processing request"); // Includes requestId in every log
```

## Adapters

### PinoLoggerAdapter

Production-ready logging powered by [Pino](https://github.com/pinojs/pino).

```typescript
import { PinoLoggerAdapter } from "@jterrazz/logger";

const logger = new PinoLoggerAdapter({
  level: "info", // 'debug' | 'info' | 'warn' | 'error' | 'silent'
  prettyPrint: true, // Human-readable output for development
  destination: stream, // Optional custom destination stream
});
```

### NoopLoggerAdapter

Zero-overhead adapter for environments where logging should be disabled.

```typescript
import { NoopLoggerAdapter } from "@jterrazz/logger";

const logger = new NoopLoggerAdapter();
```

## Metadata Behavior

The optional `meta` object provides contextual information:

| Mode                 | Output                                           |
| -------------------- | ------------------------------------------------ |
| `prettyPrint: true`  | Keys spread at root level for readability        |
| `prettyPrint: false` | Nested under `meta` key for structured ingestion |

```typescript
logger.info("User login", { userId: 42 });

// prettyPrint: true  → { level: 'info', msg: 'User login', userId: 42 }
// prettyPrint: false → { level: 'info', msg: 'User login', meta: { userId: 42 } }
```

Errors in `meta.error` are automatically serialized with `message` and `stack` properties.

## Port Interface

Use `LoggerPort` for dependency injection:

```typescript
import type { LoggerPort } from "@jterrazz/logger";

class UserService {
  constructor(private readonly logger: LoggerPort) {}

  createUser(name: string) {
    this.logger.info("Creating user", { name });
  }
}
```

## License

MIT
npm package: @jterrazz/monitoring
Description: A TypeScript-based monitoring utility designed with clean port/adapter principles, providing flexible and extensible application monitoring capabilities for Node.js applications.
Author: Jean-Baptiste Terrazzoni
Latest version: 1.0.0

# Package Monitoring

A TypeScript-based monitoring utility designed with clean port/adapter principles, providing flexible and extensible application monitoring capabilities for Node.js applications.

## Features

- 📊 Type-safe monitoring interface
- 🔌 Pluggable monitoring adapters
- 💪 100% TypeScript
- 🚀 Production-ready with no-op adapter
- 📈 NewRelic integration support
- ⏱️ Transaction and segment monitoring
- 📊 Custom metrics recording

## Installation

```bash
npm install @jterrazz/monitoring
```

## Usage

### Basic Usage

```typescript
import { NewRelicMonitoringAdapter, NoopMonitoringAdapter } from '@jterrazz/monitoring';
import { Logger } from '@jterrazz/logger';

// Development environment with NewRelic
const devMonitoring = new NewRelicMonitoringAdapter({
  environment: 'development',
  licenseKey: process.env.NEW_RELIC_LICENSE_KEY,
  logger: new Logger(/* ... */),
});

// Production environment with No-op
const prodMonitoring = new NoopMonitoringAdapter();

// Initialize monitoring
await monitoring.initialize();

// Monitor a transaction
await monitoring.monitorTransaction('User', 'Create', async () => {
  // Your business logic here
});

// Monitor a segment
await monitoring.monitorSegment('User/Profile/Update', async () => {
  // Your operation here
});

// Record metrics
monitoring.recordCount('User', 'Login', 1);
monitoring.recordMeasurement('Performance', 'ResponseTime', 150);
```

### Available Adapters

- **NewRelicMonitoringAdapter**: Full-featured monitoring with NewRelic (recommended for production)

  ```typescript
  new NewRelicMonitoringAdapter({
    environment: 'production',
    licenseKey: process.env.NEW_RELIC_LICENSE_KEY,
    logger: new Logger(/* ... */),
  });
  ```

- **NoopMonitoringAdapter**: Zero-overhead monitoring (recommended for development or testing)
  ```typescript
  new NoopMonitoringAdapter();
  ```

## Architecture

This package follows the hexagonal (ports and adapters) architecture:

- `src/ports/`: Contains the core interfaces and types
  - `monitoring.port.ts`: Defines the monitoring interface
- `src/adapters/`: Implements various monitoring adapters
  - `new-relic.adapter.ts`: NewRelic-based monitoring
  - `noop.adapter.ts`: No-operation monitoring

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is open source and available under the [MIT License](LICENSE).

## Author

- Jean-Baptiste Terrazzoni ([@jterrazz](https://github.com/jterrazz))
- Email: contact@jterrazz.com
npm package: @jterrazz/typescript
Description: Drop-in TypeScript build tooling with zero configuration.
Author: Jean-Baptiste Terrazzoni
Latest version: 5.2.0

# @jterrazz/typescript

Drop-in TypeScript build tooling with zero configuration.

## Installation

```bash
npm install @jterrazz/typescript
```

## Usage

### 1. Choose a TypeScript configuration

```json
// tsconfig.json - Pick one:
{ "extends": "@jterrazz/typescript/presets/tsconfig/node" }  // Node.js projects
{ "extends": "@jterrazz/typescript/presets/tsconfig/next" }  // Next.js projects
{ "extends": "@jterrazz/typescript/presets/tsconfig/expo" }  // Expo/React Native
```

### 2. Use the CLI

```bash
npx typescript build       # Build application (ESM + types)
npx typescript bundle      # Bundle library (ESM + CJS + types)
npx typescript start       # Run the built application
npx typescript dev         # Build, run, and rebuild on changes
```

## What you get

- **Blazing fast** — Powered by [tsdown](https://tsdown.dev) / [Rolldown](https://rolldown.rs) (Rust)
- **Zero configuration** — Works out of the box
- **Multiple outputs** — ESM + CommonJS + TypeScript declarations
- **Source maps** — Full debugging support

### Build outputs

| Command             | Output            | Description             |
| ------------------- | ----------------- | ----------------------- |
| `typescript build`  | `dist/index.js`   | ESM bundle              |
|                     | `dist/index.d.ts` | TypeScript declarations |
| `typescript bundle` | `dist/index.js`   | ESM bundle              |
|                     | `dist/index.cjs`  | CommonJS bundle         |
|                     | `dist/index.d.ts` | TypeScript declarations |
| `typescript start`  | —                 | Runs `dist/index.js`    |
| `typescript dev`    | `dist/index.js`   | Watch + rebuild + run   |

## Project structure

```
your-project/
├── src/
│   ├── index.ts           # Main entry point
│   └── instrumentation.ts # Optional instrumentation entry point
├── dist/                  # Generated files
└── tsconfig.json          # Extends this package
```

## How it works

The package uses a fully compiled toolchain — no JavaScript in the hot path:

| Step         | Tool                                  | Language |
| ------------ | ------------------------------------- | -------- |
| Transpile    | [Oxc](https://oxc.rs) (via tsdown)    | Rust     |
| Bundle       | [Rolldown](https://rolldown.rs)       | Rust     |
| Declarations | [tsdown](https://tsdown.dev) built-in | Rust     |

## License

MIT © [Jean-Baptiste Terrazzoni](https://github.com/jterrazz)