open-index/open-npm huggingface dataset:
npm package: @overcastsre/angular
Description: Overcast SRE monitoring SDK for Angular — captures everything via ErrorHandler + HttpInterceptor.
Latest version: 2.0.0

# @overcast/angular

Overcast SRE monitoring SDK for Angular. One provider — captures everything.

## Install

```bash
npm install @overcast/angular
```

## Usage (Standalone — Angular 15+)

```typescript
// app.config.ts
import { provideOvercast } from '@overcast/angular';

export const appConfig = {
  providers: [
    provideOvercast({ apiKey: 'oc_...', serviceName: 'my-app' })
  ]
};
```

## Usage (NgModule — Angular 14+)

```typescript
import { OvercastModule } from '@overcast/angular';

@NgModule({
  imports: [
    OvercastModule.forRoot({ apiKey: 'oc_...', serviceName: 'my-app' })
  ]
})
export class AppModule {}
```

Captures everything from `@overcast/browser` plus:

- All Angular component errors (custom ErrorHandler)
- ALL HttpClient requests automatically (HttpInterceptor)
- Router navigation tracking
- Angular warnings and Zone.js errors

## Injectable Service

```typescript
import { OvercastService } from '@overcast/angular';

@Component({ ... })
export class MyComponent {
  constructor(private overcast: OvercastService) {}

  doSomething() {
    this.overcast.info('User action', { action: 'clicked' });
  }
}
```
npm package: @overcastsre/browser
Description: Overcast SRE monitoring SDK for browsers — captures everything client-side.
Latest version: 2.0.0

# @overcast/browser

Overcast SRE monitoring SDK for browsers. One line — captures everything client-side.

## Install

```bash
npm install @overcast/browser
```

## Usage

```js
import Overcast from '@overcast/browser';
Overcast.init({ apiKey: 'oc_...', serviceName: 'my-app' });
```

Or via CDN:

```html
<script src="https://cdn.overcastsre.com/sdk/browser/1.0.0/overcast.min.js"></script>
<script>Overcast.init({ apiKey: 'oc_...', serviceName: 'my-app' });</script>
```

Automatically captures:

- All console output (log, info, debug, warn, error)
- JavaScript errors and unhandled promise rejections
- Resource loading failures (images, scripts, CSS)
- All fetch() and XMLHttpRequest calls
- Web Vitals (LCP, FID, CLS, INP)
- Slow page loads and high memory
- Rage clicks and dead clicks
- SPA navigation (pushState, popstate, hashchange)
- CSP violations
- Online/offline connectivity changes
npm package: @overcastsre/node
Description: Overcast SRE monitoring SDK for Node.js — one-line install, captures everything.
Latest version: 2.1.0

# @overcast/node

Overcast SRE monitoring SDK for Node.js. One install, one line — captures everything.

## Install

```bash
npm install @overcast/node
```

## Usage

```js
require('@overcast/node').init({ apiKey: 'oc_...', serviceName: 'my-api' });
```

That's it. The SDK automatically captures:

- All `console.log/info/debug/warn/error` output
- Uncaught exceptions and unhandled promise rejections
- All outgoing HTTP/HTTPS requests (status, latency, request/response bodies)
- Process warnings and deprecations
- Memory usage, event-loop lag, handle leaks
- Stack traces with full context

## Express Middleware (optional)

```js
const overcast = require('@overcast/node');
overcast.init({ apiKey: 'oc_...' });

const app = express();
app.use(overcast.middleware()); // Captures all incoming requests
```

## Options

| Option | Default | Description |
|---|---|---|
| `apiKey` | required | Your Overcast API key |
| `serviceName` | `'node-app'` | Service name in the dashboard |
| `environment` | `NODE_ENV` | `'production'`, `'staging'`, etc. |
| `encryptPayload` | `false` | AES-256-GCM encrypt payloads |
| `encryptionKey` | `''` | 32-byte hex key for encryption |
| `sanitize` | `true` | Redact PII (passwords, tokens, etc.) |
| `batchSize` | `50` | Logs per batch |
| `flushInterval` | `5000` | Flush interval in ms |
npm package: @overcastsre/react
Description: Overcast SRE monitoring SDK for React — captures everything with ErrorBoundary.
Latest version: 2.0.0

# @overcast/react

Overcast SRE monitoring SDK for React. Wrap your app — captures everything.

## Install

```bash
npm install @overcast/react
```

## Usage

```jsx
import { OvercastProvider } from '@overcast/react';

function App() {
  return (
    <OvercastProvider apiKey="oc_..." serviceName="my-app">
      <YourApp />
    </OvercastProvider>
  );
}
```

That's it. The SDK automatically captures everything from `@overcast/browser` plus:

- React component render errors (via ErrorBoundary)
- Component stacks for every error
- Custom fallback UI support

## Hook

```jsx
import { useOvercast } from '@overcast/react';

function MyComponent() {
  const overcast = useOvercast();
  overcast.info('User clicked checkout', { cartSize: 5 });
}
```

## HOC (for class components)

```jsx
import { withOvercast } from '@overcast/react';
export default withOvercast(MyClassComponent);
```
npm package: @overcastsre/svelte
Description: Overcast SRE monitoring SDK for SvelteKit — captures everything via hooks.
Latest version: 2.0.0

# @overcast/svelte

Overcast SRE monitoring SDK for SvelteKit. Drop into hooks — captures everything.

## Install

```bash
npm install @overcast/svelte
```

## Client Setup (src/hooks.client.ts)

```typescript
import { initOvercast, handleError } from '@overcast/svelte';

initOvercast({ apiKey: 'oc_...', serviceName: 'my-app' });

export { handleError };
```

## Server Setup (src/hooks.server.ts)

```typescript
import { handleServerError, handleRequest } from '@overcast/svelte';

export const handleError = handleServerError;
export const handle = handleRequest;
```

Captures everything from `@overcast/browser` plus:

- SvelteKit client-side errors (handleError hook)
- SvelteKit server-side errors
- All server requests with timing
- SPA navigation tracking
- Route IDs and params in error context
npm package: @overcastsre/vue
Description: Overcast SRE monitoring SDK for Vue.js — captures everything via plugin.
Latest version: 2.0.0

# @overcast/vue

Overcast SRE monitoring SDK for Vue 3. One plugin — captures everything.

## Install

```bash
npm install @overcast/vue
```

## Usage

```js
import { createApp } from 'vue';
import { OvercastPlugin } from '@overcast/vue';
import App from './App.vue';

createApp(App)
  .use(OvercastPlugin, { apiKey: 'oc_...', serviceName: 'my-app' })
  .mount('#app');
```

Captures everything from `@overcast/browser` plus:

- Vue component render errors
- Vue warnings (dev mode)
- Component names and lifecycle hooks in error context
- vue-router navigation tracking (auto-detected)

## Composable

```js
import { useOvercast } from '@overcast/vue';

const overcast = useOvercast();
overcast.info('User clicked checkout');
```
npm package: @overcodehungary/overgrid
Description: <a href="https://overgrid.overcode.hu" target="_blank">Demo and Docs</a>
Latest version: 2.2.1

# OverGrid
## Fully customizable, feature rich grid/datatable component for Vue3 projects.

<a href="https://overgrid.overcode.hu" target="_blank">Demo and Docs</a>

<a href="https://github.com/OverCodeHungary/OverGrid" target="_blank">Github project</a>

### Getting started

```
npm i @overcodehungary/overgrid
```

### Basic Usage
```
<template>
  <OverGrid :config="config"></OverGrid>
</template>

<script setup lang="ts">
import { OverGrid, OverGridConfig } from '@overcodehungary/overgrid';
import '@overcodehungary/overgrid/dist/style.css' // default theme
import './theme.css' // custom theme

const config: OverGridConfig = {
  ... // your config here
};
</ script>
```

Check the Docs for more info.
npm package: @overcodehungary/test-package-001
Description: This template should help get you started developing with Vue 3 in Vite.
Latest version: 1.0.3

# overgrid2

This template should help get you started developing with Vue 3 in Vite.

## Recommended IDE Setup

[VSCode](https://code.visualstudio.com/) + [Volar](https://marketplace.visualstudio.com/items?itemName=Vue.volar) (and disable Vetur).

## Type Support for `.vue` Imports in TS

TypeScript cannot handle type information for `.vue` imports by default, so we replace the `tsc` CLI with `vue-tsc` for type checking. In editors, we need [Volar](https://marketplace.visualstudio.com/items?itemName=Vue.volar) to make the TypeScript language service aware of `.vue` types.

## Customize configuration

See [Vite Configuration Reference](https://vite.dev/config/).

## Project Setup

```sh
npm install
```

### Compile and Hot-Reload for Development

```sh
npm run dev
```

### Type-Check, Compile and Minify for Production

```sh
npm run build
```

### Run Unit Tests with [Vitest](https://vitest.dev/)

```sh
npm run test:unit
```

### Lint with [ESLint](https://eslint.org/)

```sh
npm run lint
```
npm package: @overcoder/vue-context-menu
Description: Context menus for VueJS
Author: Yousef Sultan
Latest version: 0.1.3

vue-context-menu
==============

> The plugin is VERY minimal and does NOT provide any styling or anything. This simplifies context menus implementation but that's it.

## Usage

There are **three** steps for using this plugin.

#### Step 1: Create context menu

```vue
<template>
  ...
  <ContextMenu ref="contextMenu">
    interesting stuff
  </ContextMenu>
</template>

<script>
  import ContextMenu from '@overcoder/vue-context-menu';
  
  export default {
    ...
    
    components: {
      ...
      ContextMenu,
    },
  };
</script>
```

#### Step 2: Trigger the menu

```vue
  <ul>
    <li v-for="cats in cat" :key="cat.id"
      @contextmenu.prevent="event => contextMenu.open(event)">
      {{ cat.name }}
    </li>
  </ul>
```

> Test it out, context menu should work now (assuming `cats`).

#### Step 3: Make it useful

Ok first of all you noticed the `event` is passed to `contextMenu.open` and this is to determine mouse location etc.

Now this plugin supports thing called **contexts**, here's an example:

```vue
  <ul>
    <li v-for="cats in cat" :key="cat.id"
      @contextmenu.prevent="event => contextMenu.open(event, cat)">
      {{ cat.name }}
    </li>
  </ul>
```

You can see we provided the `cat` as the second parameter to `contextMenu.open`. We gave it a context. Now you can access this context within the menu itself:

```vue
  <ContextMenu ref="contextMenu">
    <template v-slot="slotProps"> <!-- slotsProps are props passed from child to slot in parent -->
      <!-- Now, here slotProps.ctx does contain the context (cat) BUT -->
      <template v-if="slotProps.ctx"> <!-- we need to add this since context is null on initial render -->
        <!-- Now we can peacefully access slotProps.ctx without getting any errors -->

        {{ slotProps.ctx.name }}
      <template>
    </template>
  </ContextMenu>
```

That's all I think.

## Other things

- `close()` closes the menu
- You can also do `open()` without passing an event to open the menu at last position (defaults to 0,0)
npm package: @overconsulting/js-cli
Description: A maker CLI tool for JavaScript projects
Author: ldandoy
Latest version: 1.0.3

# Maker cli for JS projects

## Install

```bash
npm i @overconsulting/js-cli
```

## Test IT !

### Create a ReactJS component

```bash
npx js-cli make:component <component Name>
```

## Roadmap

[x] Migrate to typescript
[ ] Add asking peolpe information or find information of projet type
[ ] Séparate commande in files
[ ] Add Controllers, Page, Services, Routing
[ ] Support Express, Tanstack and NextJS
npm package: @overcut/ui-workflow-viewer
Description: Read-only, Overcut workflow viewer based on React Flow and ELK.
Latest version: 0.1.1

# @overcut/ui-workflow-viewer

Read‑only, marketing‑ready workflow viewer component.

## Install (external consumer)

```bash
npm i @overcut/ui-workflow-viewer react react-dom reactflow elkjs
```

```tsx
import { WorkflowViewer } from '@overcut/ui-workflow-viewer';
import '@overcut/ui-workflow-viewer/styles.css';

export function Example({ definition }) {
  return (
    <div style={{ height: 520 }}>
      <WorkflowViewer definition={definition} />
    </div>
  );
}
```

The stylesheet includes React Flow base CSS internally, so a single CSS import is enough.

---

## Local testing before publish

You have two easy options.

### A) Tarball install (quickest)
1. Build the library:
   ```bash
   npx nx build ui-workflow-viewer
   ```
2. Pack it (creates a .tgz file):
   ```bash
   cd dist/libs/ui/workflow-viewer
   npm pack
   # -> overcut-ui-workflow-viewer-x.y.z.tgz
   ```
3. In a test app, install the tarball:
   ```bash
   npm i /absolute/path/to/dist/libs/ui/workflow-viewer/overcut-ui-workflow-viewer-x.y.z.tgz
   ```
4. Import and run as shown above.


---

## Publishing

1. Bump the version in `libs/ui/workflow-viewer/package.json`.
2. Build the package:
   ```bash
   npx nx build ui-workflow-viewer
   ```
3. Publish from the dist folder:
   ```bash
   cd dist/libs/ui/workflow-viewer
   npm publish --access public
   ```

Notes
- Peers: `react`, `react-dom`, `reactflow`. Dependency: `elkjs`.
- Output: ESM bundle `index.esm.js`, types, and `styles.css`.