open-index/open-npm huggingface dataset:
npm package: @stewie-js/devtools
Description: Browser overlay devtools for the Stewie framework
Latest version: 0.5.0

# @stewie-js/devtools

Browser overlay devtools panel for the [Stewie](https://github.com/cwins/stewie-js) framework — similar to TanStack Devtools. Provides a floating panel with tabs for Renders, Stores, and Routes, plus a render highlight feature that flashes DOM nodes when reactive effects fire.

## Install

```bash
pnpm add -D @stewie-js/devtools
```

## Usage

### Option A — In your app entry point

```ts
import { initDevtools } from '@stewie-js/devtools'

if (import.meta.env.DEV) {
  initDevtools()
}
```

### Option B — Auto-injected by the Vite plugin

When using `@stewie-js/vite`, the devtools are automatically injected in development mode — provided `@stewie-js/devtools` is installed in the project. The Vite plugin adds a dynamic import for this package, so it must be resolvable. No other manual setup is needed.

## Keyboard Shortcut

Press **Alt+D** to toggle the devtools panel open/closed.

## Tabs

### Renders

Shows a live log of reactive effect re-runs. Each entry displays the DOM element and attribute that triggered the update. Click any entry to flash-highlight the corresponding element in the viewport.

Includes a toggle to enable/disable the render highlight overlay.

### Stores

Shows a live log of signal and store write events. Each entry displays the new value and a timestamp. Useful for tracking how often and when reactive state changes.

### Routes

Shows the current URL pathname, query parameters, URL hash, and router params (if `@stewie-js/router` is in use). Also displays a navigation history list.

## Render Highlight

When a reactive prop effect re-runs, the affected DOM element is briefly outlined with a blue flash overlay (`rgba(56,189,248,0.25)` fill, `2px` solid outline). This makes it easy to see exactly which parts of the page are updating in response to state changes.

The highlight can be toggled on/off from the Renders tab.

## API

```ts
import { initDevtools, destroyDevtools } from '@stewie-js/devtools'

// Mount the devtools panel
initDevtools()

// Unmount and clean up
destroyDevtools()
```
npm package: @stewie-js/router-spi
Description: Router interface definitions (types only) for the Stewie framework
Latest version: 0.5.0

# @stewie-js/router-spi

>❗ **Work in progress.**
>
>Stewie is under active development and not yet stable. APIs may change between releases. Not recommended for production use yet.

TypeScript interface definitions for the Stewie router service provider interface. Primarily types — the only runtime export is a `version` constant.

Use `@stewie-js/router` for standard app routing. This package is for router implementers and framework integrations that need to be router-agnostic.

Implement these interfaces to plug a custom router into the Stewie ecosystem, or reference them when building libraries that need to be router-agnostic.

Part of the [Stewie](https://github.com/cwins/stewie-js) framework.

## Install

```bash
pnpm add @stewie-js/router-spi
```

## Interfaces

```ts
import type { StewieRouterSPI, ReactiveLocation, NavigateOptions, RouteMatch } from '@stewie-js/router-spi'

// Implement this to provide a custom router
class MyRouter implements StewieRouterSPI {
  readonly location: ReactiveLocation  // reactive store — components subscribe to specific properties
  navigate(to: string | NavigateOptions): Promise<void> { ... }
  back(): void { ... }
  forward(): void { ... }
  match(pattern: string): RouteMatch | null { ... }
}
```

### `ReactiveLocation`

```ts
interface ReactiveLocation {
  pathname: string
  params: Record<string, string>  // current route params (:id, etc.)
  query: Record<string, string>   // parsed search params
  hash: string
}
```

### `NavigateOptions`

```ts
interface NavigateOptions {
  to: string
  replace?: boolean  // replace history entry instead of push
  state?: unknown    // History API state object
}
```

### `RouteMatch`

```ts
interface RouteMatch {
  pattern: string
  params: Record<string, string>
  score: number  // higher = more specific match
}
```
npm package: @stewie-js/server
Description: WinterCG-compatible server-side rendering for the Stewie framework
Latest version: 0.5.0

# @stewie-js/server

>❗ **Work in progress.**
>
>Stewie is under active development and not yet stable. APIs may change between releases. Not recommended for production use yet.

WinterCG-compatible server-side rendering for Stewie. Renders component trees to HTML strings or streaming `ReadableStream`s using only standard web APIs — no Node.js dependencies, runs on any WinterCG-compliant runtime (Node 18+, Bun, Deno, Cloudflare Workers).

Part of the [Stewie](https://github.com/cwins/stewie-js) framework.

## Install

```bash
pnpm add @stewie-js/server @stewie-js/core
```

## renderToString

Returns `{ html, stateScript }` separately so you control where each is placed in the document.

```ts
import { renderToString } from '@stewie-js/server'
import { jsx } from '@stewie-js/core'
import App from './App.js'

const { html, stateScript } = await renderToString(jsx(App, {}))

const page = template
  .replace('<!--ssr-outlet-->', html)
  .replace('</body>', `  ${stateScript}\n</body>`)
```

`stateScript` is an inline `<script>` tag that sets `window.__STEWIE_STATE__` — a serialized payload of all hydration registry key/value pairs collected during the render. The client calls `hydrate()` to read this and initialize state without a second network round-trip.

## renderToStream

Streams the HTML shell immediately, then resolves `<Suspense>` boundaries progressively as async data loads.

```ts
import { renderToStream } from '@stewie-js/server'

const stream = renderToStream(jsx(App, {}))
return new Response(stream, {
  headers: { 'content-type': 'text/html; charset=utf-8' },
})
```

## Hydration Registry

`renderToString` and `renderToStream` create their own internal hydration registry automatically. Components use `useHydrationRegistry()` from `@stewie-js/core` to register key/value pairs that get serialized into `__STEWIE_STATE__`.

```ts
import { useHydrationRegistry } from '@stewie-js/core'

function MyComponent() {
  const registry = useHydrationRegistry()
  if (registry) {
    registry.set('myKey', someServerData)
  }
  // ...
}
```

## CSP Nonce

Both renderers accept a `nonce` option. The nonce is applied to all injected `<script>` tags:

```ts
const { html, stateScript } = await renderToString(jsx(App, {}), { nonce: requestNonce })
const stream = renderToStream(jsx(App, {}), { nonce: requestNonce })
```

## API

| Export | Description |
|---|---|
| `renderToString(element, options?)` | Renders to `{ html: string, stateScript: string }` |
| `renderToStream(element, options?)` | Renders to a streaming `ReadableStream` |
| `RenderOptions` | Options type: `{ nonce?: string }` |
| `RenderResult` | Return type of `renderToString`: `{ html: string, stateScript: string }` |
npm package: @stewie-js/vite
Description: Vite plugin for the Stewie framework
Latest version: 0.5.0

# @stewie-js/vite

>❗ **Work in progress.**
>
>Stewie is under active development and not yet stable. APIs may change between releases. Not recommended for production use yet.

Vite plugin for Stewie. Configures the JSX transform to use `@stewie-js/core`'s runtime and wires up HMR.

Part of the [Stewie](https://github.com/cwins/stewie-js) framework.

## Install

```bash
pnpm add -D @stewie-js/vite
```

## Usage

```ts
// vite.config.ts
import { stewie, defineConfig } from '@stewie-js/vite'

export default defineConfig({
  plugins: [stewie()]
})
```

Or with additional Vite config:

```ts
import { stewie, defineConfig } from '@stewie-js/vite'

export default defineConfig({
  plugins: [stewie()],
  server: {
    port: 3000,
  },
})
```

## What it does

- Sets `jsxImportSource: '@stewie-js/core'` and `jsx: 'react-jsx'` so `.tsx` files use Stewie's JSX runtime
- Integrates with Vite's normal HMR flow for development
- In development mode, adds a dynamic import of `@stewie-js/devtools` — provided the package is installed in the project

## `jsxToDom` option

The `jsxToDom` compiler option controls whether JSX is transformed to fine-grained DOM calls. It defaults to `true` for client builds and is disabled automatically for SSR builds (Vite passes `ssr: true` to the transform hook).

```ts
stewie({ jsxToDom: false }) // disable for testing or custom integrations
```

## `defineConfig` vs `defineStewieConfig`

`defineConfig` is a direct re-export from Vite — it provides no Stewie-specific defaults and is included only for convenience.

`defineStewieConfig` is a Stewie helper that adds the `stewie()` plugin automatically, so you don't need to add it explicitly:

```ts
// equivalent to: defineConfig({ plugins: [stewie()] })
export default defineStewieConfig()

// with additional options
export default defineStewieConfig({
  server: { port: 3000 },
})
```

## API

| Export | Description |
|---|---|
| `stewie(options?)` | Vite plugin factory |
| `defineConfig(config)` | Re-export from Vite — same as importing from `vite` directly |
| `defineStewieConfig(config?)` | Like `defineConfig` but adds `stewie()` automatically |
npm package: @stewieoo/primeng
Description: [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![npm version](https://badge.fury.io/js/primeng.svg)](https://badge.fury.io/js/primeng) [![npm downloads](https://img.shields.io/npm/dm/primeng.
Latest version: 12.0.0


[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![npm version](https://badge.fury.io/js/primeng.svg)](https://badge.fury.io/js/primeng)
[![npm downloads](https://img.shields.io/npm/dm/primeng.svg)](https://www.npmjs.com/package/primeng)
[![Build Status](https://travis-ci.org/primefaces/primeng.svg?branch=master)](https://travis-ci.org/primefaces/primeng)
[![Discord Chat](https://img.shields.io/discord/557940238991753223.svg?color=7289da&label=chat&logo=discord)](https://discord.gg/gzKFYnpmCY)

[![PrimeNG Hero](https://www.primefaces.org/wp-content/uploads/2021/06/primeng-release-12-1.jpg)](https://www.primefaces.org/primeng)

### Website

Visit the [PrimeNG Website](https://www.primefaces.org/primeng/) for general information, demos and documentation.
npm package: @stews/noodle
Description: Stews is a Node.JS package meant to make storing data easier by mixing parts from common data types.
Author: paishee
Latest version: 1.1.0

# @stews/noodle
this is a sub-package of the main package [stews](https://npmjs.com/package/stews)<br><br>

here's some related links
- [stews](https://npmjs.com/package/stews) (main)
- [@stews/soup](https://www.npmjs.com/package/@stews/soup)
- [@stews/stew](https://www.npmjs.com/package/@stews/stew)
- [@stews/noodle](https://www.npmjs.com/package/@stews/noodle) (current)
- [@stews/random](https://www.npmjs.com/package/@stews/random)
npm package: @stews/random
Description: Stews is a Node.JS package meant to make storing data easier by mixing parts from common data types.
Author: paishee
Latest version: 1.1.0

# @stews/random
this is a sub-package of the main package [stews](https://npmjs.com/package/stews)<br><br>

here's some related links
- [stews](https://npmjs.com/package/stews) (main)
- [@stews/soup](https://www.npmjs.com/package/@stews/soup)
- [@stews/stew](https://www.npmjs.com/package/@stews/stew)
- [@stews/noodle](https://www.npmjs.com/package/@stews/noodle)
- [@stews/random](https://www.npmjs.com/package/@stews/random) (current)
npm package: @stews/soup
Description: Stews is a Node.JS package meant to make storing data easier by mixing parts from common data types.
Author: paishee
Latest version: 1.2.0

# @stews/soup
this is a sub-package of the main package [stews](https://npmjs.com/package/stews)<br><br>

here's some related links
- [stews](https://npmjs.com/package/stews) (main)
- [@stews/soup](https://www.npmjs.com/package/@stews/soup) (current)
- [@stews/stew](https://www.npmjs.com/package/@stews/stew)
- [@stews/noodle](https://www.npmjs.com/package/@stews/noodle)
- [@stews/random](https://www.npmjs.com/package/@stews/random)
npm package: @stews/stew
Description: Stews is a Node.JS package meant to make storing data easier by mixing parts from common data types.
Author: paishee
Latest version: 1.1.0

# @stews/stew
this is a sub-package of the main package [stews](https://npmjs.com/package/stews)<br><br>

here's some related links
- [stews](https://npmjs.com/package/stews) (main)
- [@stews/soup](https://www.npmjs.com/package/@stews/soup)
- [@stews/stew](https://www.npmjs.com/package/@stews/stew) (current)
- [@stews/noodle](https://www.npmjs.com/package/@stews/noodle)
- [@stews/random](https://www.npmjs.com/package/@stews/random)
npm package: @stfalcon/vue-bank-id-se
Description: Component, which allows to simply implement swedish bankId at vue. It integrates with mobile app: - if vue app is openned on mobile, then performes redirect to mobile BankId app by clicking on vue-bank-se component. And when user authenticates, mobile app
Author: Illia Osmanov
Latest version: 0.2.5

# VUE-BANKID-SE

Component, which allows to simply implement swedish bankId at vue. It integrates with mobile app:
- if vue app is openned on mobile, then performes redirect to mobile BankId app by clicking on vue-bank-se component. And when user authenticates, mobile app redirects back and vue component requires session from the server.
- if vue app is openned on desktop, then showes QR code by clicking on vue-bank-se component. After that user can scan code with mobile bankId app and authenticate. Simultaniously the vue app requests session with some interval

## Installing

```shell
npm i @stfalcon/vue-bank-id-se
```

## Interface for use

It receives a component (in default slot) as an actor.

It receives a component as wrapper for showing QR-code in scoped slot `qrDialog`. This scoped slot returns `imgUrl`(base64 image to insert into `img` tag), `countdownTime`(time is left to close dialog) and `closeDialog`(function which you can call to close the dialog)

`requestToken: () => Promise<{ autoStartToken<string>, orderRef<string> }>` - required. Initialize BankId session at server.

`requestSesstion: ({ orderRef<string> }) => Promise<any>` - required. Requires session from server by `orderRef`. If you want that dialog will be closed automatically then requestSesstion should return any defined value.

`tryCount: Number` - optional(default 10), is used only for desktop. Number of tries to require `requestSesstion`

`qrDuration: Number` - optional(default 50), is used only for desktop. Full duration of showing QR-code.

_Note_: If you specify `tryCount = 2`, `qrDuration = 30` - it means that that QR popup will be shown within 30 seconds and it will make two requests to server: first at 15sec and second at 30sec.

## Example of usage

```html
<template>
  <BankIdLogin
    :request-session="onLogin"
    :request-token="startBankIdSession"
    :try-count="2"
    :qr-duration="30"
  >
    <button type="primary">
      Login with BankId
    </button>

    <template v-slot:qrDialog="props">
      <QrDialog v-bind="props"/>
    </template>
  </BankIdLogin>
</template>

<script>
import BankIdLogin from '@stfalcon/vue-bank-id-se';
import QrDialog from '@/components/MyDialog';

export default {
  name: 'Auth',
  components: { BankIdLogin, QrDialog },
  methods: {
    ...mapActions('auth', ['login', 'startBankIdSession']),
    async onLogin(ref) {
      await this.login(ref);
      this.$router.push('/registration');
    },
  },
};
</script>
```
npm package: @stfalcon/vue-notify-layer
Description: Vue notification layer for binding any Notify plugins
Latest version: 0.0.1

### Installation

#### npm
```
$ npm i -S @stfalcon/vue-notify-layer
```

### Quick usage
```
import VueNotifyLayer from '@stfalcon/vue-notify-layer';
Vue.use(Notify, {
  // optional pluginOptions
  name: 'stNotify' // stNotify - name by default
});
```

### Using in components
```
<template>
  <button @click="handleNotify">
    Call notify
  </button>
</template>

<script>
export default {
  methods: {
    handleNotify() {
      this.$stNotify.emit({ type: 'default', title: 'Hello', message: 'World!' });
    }
  },
  created() {
    this.$stNotify.watch((params, pool) => {
      console.log(params); // Get notify data from our application
      console.log(pool); // Get all messages what we created
    })
  }
}
</script>
```

### Using in Store
Just call `dispatch` from your actions
```
actions: {
  someAction({ dispatch }) {
    dispatch('stNotify/notify', { /* payload */ });
  }
}
```

### Options

| Name           | Type        | Default          | Description |
| ---            | ---         | ---              | ---         |
| name           | String      | stNotify           | Defines the instance name. It's prefixed with the dollar sign. E.g. `$stNotify` |
| moduleName     | String      | notify-layer-api | Store module name if you want call notification from store |
| store          | Store  | null

### Glossary

#### Notify payload

```
type Notification = {
  type: string;
} & { [key: string]: any };
```

#### Notify interface
```
$notify: {
  emit: (params: Notification) => void,
  watch: (cb: (params: Notification, pool: Notification[]) => void) => void
}
```
npm package: @stfalcon/vuex-crud-module-creator
Description: Package for creating basic crud operation
Author: Illia Osmanov
Latest version: 1.1.10

# Stfalcon-vuex-crud-module-creator

If you need to create a lot of crud operation. It's for you. The Simple wrapper on your vuex-modules. Included four basic operations.
`$create`, `$read`, `$update`, `$remove`

## Installing

```shell
npm i @stfalcon/vuex-crud-module-creator
```

## Usage

### Create module

`some-module.js`

```js
import { createModule } from "@stfalcon/vuex-crud-module-creator";
const module = createModule(
  "todo",
  {
    /* options */
  },
  {
    /* override store */
  }
);

export default module;
```

## Options

```js
{
  endpoint?: string;
  getKey?: () => string | number;
  transportAdapter?: fetch | axios;
  paginationStrategy? "basic" | "pointer";
}
```

| Name               | Type     | Default           | Description                                                                                  |
| ------------------ | -------- | ----------------- | -------------------------------------------------------------------------------------------- |
| endpoint           | String   | as a module name  | URL where you will send requests. For example: "users" or "users/:userId/orders"             |
| getKey             | Function | () => "id"        | By default getKey return id and all your collections saved how a object `{ [id]: someData }` |
|                    |          |                   | If you wanna change key you should write your custom reducer                                 |
| transportAdapter   | any      | fetch             | Your layer for send requests to a server. We recommend using axios                           |
| paginationStartegy | Object   | { type: "basic" } | In to `createModule` including pagination options. In basic strategy you have next keys:     |
|                    |          |                   | `{ total: number, offset: number, limit: number }`                                           |

## Global configuration

`store.js`

You can install transportAdapter globally

```js
import { createModule } from "stfalcon-vuex-crud-module-creator";
import axios from "axios";

createModule.configure({
  transportAdapter: axios
});
```
npm package: @stfalcon/vuex-loading-plugin
Description: Lightweight plugin for handle loading before and after action request
Author: Illia Osmanov
Latest version: 2.1.0

# vuex-loading-plugin

The plugin which including to your modules `loading logic`. When you will handle any actions you triggering `loading` mutation. When actions will be done `loading flag` came back to false. Basically, this plugin indicates async actions for you.
_Note_: This plugin also make a patch of dispatch method of the vuex, since in original implementation if action fails, then `after` subscribtion is not called. The patch fixed this thing.

### Prerequisites

This library requires vue and vuex as a peer dependency.

## Installing

```shell
npm i @stfalcon/vuex-loading-plugin
```

## Usage

### In `store.js` file

```js
import loadingPlugin from "@stfalcon/vuex-loading-plugin"

const store = new Vuex.Store({
  ...other store options,
  plugins: [loadingPlugin(options)]
})
```
`options` contains:
 - `options.blacklistFilter`: Function(<String>) - receives an action type as argument and allows to blacklist any of action by a rule.

### In `SomeComponent.vue` file

You can handle async actions of any namespaced module:
```js
computed: {
  ...mapGetters('yourModuleName', ['isLoading'])
}
```

If you want to listen to all async actions of all modules, then you should use global getter:
```js
computed: {
  ...mapGetters(['isLoading']),
}
```
This getter is just an alias for listening `loading` getters of all modules simultaniously.
npm package: @stfy/react-editor.js
Description: React wrapper component for Editor.js
Author: Semenyuk Timofey
Latest version: 1.0.3

# react-editor.js

![npm version](https://img.shields.io/npm/v/@stfy/react-editor.js.svg)

React wrapper component for [Editor.js](https://github.com/codex-team/editor.js)

## Install

```bash
npm install --save @stfy/react-editor.js

// or Yarn

yarn add @stfy/react-editor.js
```

## Usage

```jsx

import React, { Component } from 'react'
import Editor from '@stfy/react-editor.js'

const App => (
  <>
    <Editor
        autofocus
        holderId="editorjs-container"
        excludeDefaultTools={['header']}
        onChange={(data) => console.log(data)}
        customTools={{
          header: CustomHeader
        }}
        onReady={() => console.log('Start!')}
        data={{
          "time" : 1554920381017,
          "blocks" : [
              {
                  "type" : "header",
                  "data" : {
                      "text" : "Hello Editor.js",
                      "level" : 2
                  }
              },
          ],
          "version" : "2.12.4"
        }}
      />
  </>
)

```

## Props

| Name                |    Type    |      Default      | Description                                   |
| :------------------ | :--------: | :---------------: | :-------------------------------------------- |
| autofocus           | `boolean`  |      `true`       | Set Caret to the Editor after initialisation  |
| holderId            |  `string`  | `editorjs-holder` | Id of Element that should contain the Editor  |
| onChange            | `function` |      `null`       | onChange callback                             |
| onReady             | `function` |      `null`       | onReady callback                              |
| data                |  `object`  |      `null`       | Previously saved data that should be rendered |
| customTools         |  `object`  |      `null`       | Set custom tools config or overwrite existed  |
| excludeDefaultTools |  `array`   |      `null`       | Exclude default tool by tool name             |

## Default tools

| Name       |        Package         |
| :--------- | :--------------------: |
| header     |   `@editorjs/header`   |
| list       |    `@editorjs/list`    |
| inlineCode | `@editorjs/inlineCode` |
| image      |   `@editorjs/image`    |
| embed      |   `@editorjs/embed`    |
| quote      |   `@editorjs/quote`    |
| marker     |   `@editorjs/marker`   |
| code       |    `@editorjs/code`    |
| link       |    `@editorjs/link`    |
| delimiter  | `@editorjs/delimiter`  |
| raw        |    `@editorjs/raw`     |
| table      |   `@editorjs/table`    |
| warning    |  `@editorjs/warning`   |
| paragraph  | `@editorjs/paragraph`  |
| checklist  | `@editorjs/checklist`  |

## Contributing

Welcome to contribute.

## License

[MIT Licensed.](https://github.com/stfy/react-editor.js/blob/master/LICENSE) License 2019
npm package: @stfy/test-contract-sdk
Description: Implements JS Contract SDK core functionality, rpc services, tools and utilities.
Author: Timofey Semenyuk
Latest version: 1.0.15

# JS SDK CONTRACT CORE

Implements JS Contract SDK core functionality, rpc services, tools and utilities.

### Getting Started

Run following in command line:

```bash 
npm i @wavesenterpise/contract-core
```

Create `contract.ts` as follows

```ts 
import {Action, Contract, ContractState, Param, State} from '@wavesenterpise/contract-core';

@Contract
class MyContract {
    @State state: ContractState;

    @Action
    greeting(@Param('name') name: string) {
        this.state.set('greeting', `Hello, ${name}`);
    }
}
```


## License

This project is licensed under the [MIT License](LICENSE).
npm package: @stg-247/react-d3-credit-score-guage
Description: Guage graph using d3 and ReactJs for visualizing Credit Scores.
Author: Shashwat Kaundinya
Latest version: 1.0.0

## Description

React + Typescript Credit Score Guage component using D3.

## Install 
```sh
$ npm install @STG-247/react-d3-credit-score-guage --save
```

## Usage
```tsx
import React from 'react'
import { CreditScoreGuage } from '@STG-247/react-d3-credit-score-guage'

const DateScore: React.FC = () => {
   const config = {
        id: 0,
        score: 750,
        min_score: 300,
        max_score: 900,
        scale: 0.7
    }
    return (
        <div>
            <CreditScoreGuage id={config.id} max_score={config.max_score} min_score={config.min_score} score={config.score} scale={config.scale}/>
        </div>
    );
};

export default DateScore;
```
npm package: @stgdp/gulp-archiver
Description: Create archives from files
Author: Andrew Palfrey
Latest version: 1.0.0

# @stgdp/gulp-archiver
## Adapted from [gulp-tar](https://github.com/sindresorhus/gulp-tar)
> Create archives from files


## Install

```
$ npm install --save-dev @stgdp/gulp-archiver
```


## Usage

```js
const gulp = require( 'gulp' )
const archiver = require( '@stgdp/gulp-archiver' )
const gzip = require( 'gulp-gzip' )

exports.default = () => (
	gulp.src( 'src/*' )
		.pipe( archiver( 'archive.tar' ) )
		.pipe( gzip() )
		.pipe( gulp.dest( 'dist' ) )
)
```


## API

### archiver(filename, format, options?)

#### filename

Type: `string`

Filename for the output archive.

#### format

Type: `string`

Format for the output tar archive. Can be `zip`, `tar` or `json`

#### options

Type: `object`

Default options passed to [Archiver](https://github.com/archiverjs/node-archiver)'s [constructor](https://archiverjs.com/docs/Archiver.html) and merged into the [data](https://archiverjs.com/docs/global.html#TarEntryData) passed to its [`append`](https://archiverjs.com/docs/Archiver.html#append) method.
npm package: @stguten/pd-js
Description: Pixel Drain package for pixeldrain.com API
Author: Gutemberg a.k.a StGuten
Latest version: 1.4.3

# Pixel Drain

Pixel Drain is a simple and efficient file sharing service.

## Features

- Fast file uploads
- Easy sharing links
- No registration required

## Usage

1. Upload your file.
2. Share the generated link with others.
3. Download files using the shared link.

## License

This project is licensed under the MIT License.
npm package: @sthakur/react-static-tweets
Description: Extremely fast static renderer for tweets.
Author: Travis Fischer
Latest version: 0.7.13

<p align="center">
  <a href="https://react-static-tweets.vercel.app/1352687755621351425">
    <img alt="React Static Tweets" src="https://raw.githubusercontent.com/transitive-bullshit/react-static-tweets/master/example/demo.jpg" width="550">
  </a>
</p>

# React Static Tweets

> Extremely fast static renderer for tweets.

[![NPM](https://img.shields.io/npm/v/react-static-tweets.svg)](https://www.npmjs.com/package/react-static-tweets) [![Build Status](https://github.com/transitive-bullshit/react-static-tweets/actions/workflows/build.yml/badge.svg)](https://github.com/transitive-bullshit/react-static-tweets/actions/workflows/build.yml) [![Prettier Code Formatting](https://img.shields.io/badge/code_style-prettier-brightgreen.svg)](https://prettier.io)

## Install

```bash
npm install react-static-tweets
```

## Usage

The easiest way to get started is to render tweets client-side (which will by default fetch the tweet AST data on-the-fly).

```tsx
import React from 'react'
import { Tweet } from 'react-static-tweets'

export default Example({ tweetId }) => (
  <Tweet
    id={tweetId}
  />
)
```

For more optimized SSR usage, you'll want to pre-fetch the tweet AST data server-side:

```tsx
import React from 'react'
import { fetchTweetAst } from 'static-tweets'
import { Tweet } from 'react-static-tweets'

const tweetId = '1358199505280262150'

export const getStaticProps = async () => {
  try {
    const tweetAst = await fetchTweetAst(tweetId)

    return {
      props: {
        tweetId,
        tweetAst
      },
      revalidate: 10
    }
  } catch (err) {
    console.error('error fetching tweet info', err)

    throw err
  }
}

export default Example({ tweetId, tweetAst }) => {
  return <Tweet id={tweetId} ast={tweetAst} />
}
```

## Styles

You'll need to import some CSS styles as well. If you're using Next.js, we recommend you put these in `pages/_app.js`:

```ts
import 'react-static-tweets/styles.css'
```

## Credit

My main contribution is packaging the Vercel team's excellent work into two isolated packages (`static-tweets` for server-side fetching of tweet ASTs and `react-static-tweets` for client-side rendering as well as SSR).

- Inspired by this [demo](https://static-tweet.vercel.app/) from the Vercel team
- And the underlying [repo](https://github.com/lfades/static-tweet) by [Luis Alvarez](https://github.com/lfades)
- Most of the core code is adapted from [Guillermo Rauch's blog](https://github.com/rauchg/blog/blob/master/pages/2020/2019-in-review.js)
- Converted JS codebase to TypeScript
- Removed `styled-jsx` because using a flat CSS file (with a `.static-tweet` class prefix) makes bundling for NPM easier
- Fixed some minor formatting bugs

## License

MIT © [Travis Fischer](https://transitivebullsh.it)

Support my OSS work by <a href="https://twitter.com/transitive_bs">following me on twitter <img src="https://storage.googleapis.com/saasify-assets/twitter-logo.svg" alt="twitter" height="24px" align="center"></a>
npm package: @sthakur/static-tweets
Description: Utilities for fetching and manipulating tweet ASTs.
Author: Travis Fischer
Latest version: 0.7.13

<p align="center">
  <a href="https://react-static-tweets.vercel.app/1352687755621351425">
    <img alt="React Static Tweets" src="https://raw.githubusercontent.com/transitive-bullshit/react-static-tweets/master/example/demo.jpg" width="550">
  </a>
</p>

# static-tweets

> Utilities for fetching and manipulating tweet ASTs.

[![NPM](https://img.shields.io/npm/v/static-tweets.svg)](https://www.npmjs.com/package/static-tweets) [![Build Status](https://github.com/transitive-bullshit/react-static-tweets/actions/workflows/build.yml/badge.svg)](https://github.com/transitive-bullshit/react-static-tweets/actions/workflows/build.yml) [![Prettier Code Formatting](https://img.shields.io/badge/code_style-prettier-brightgreen.svg)](https://prettier.io)

## Install

```bash
npm install static-tweets
```

This package is compatible with Node.js.

## Usage

```ts
import [ fetchTweetAst } from 'static-tweets'
import { Tweet } from 'react-static-tweets'

const tweetId = '1358199505280262150'

async function example (tweetId) {
  const tweetAst = await fetchTweetAst(tweetId)

  // tweetAst is a JSON representation of this tweet's contents
  // which `react-static-tweets` can use to render
}
```

## Docs

See the [auto-generated docs](https://github.com/transitive-bullshit/react-static-tweets/blob/master/docs/static-tweets.md).

## License

MIT © [Travis Fischer](https://transitivebullsh.it)

Support my OSS work by <a href="https://twitter.com/transitive_bs">following me on twitter <img src="https://storage.googleapis.com/saasify-assets/twitter-logo.svg" alt="twitter" height="24px" align="center"></a>
npm package: @sthan/core
Description: TypeScript client for sthan.io APIs — address verification, parsing, autocomplete, geocoding, IP geolocation
Author: sthan.io
Latest version: 0.1.1

# @sthan/core

TypeScript client for [sthan.io](https://sthan.io) APIs.

## Usage

```typescript
import { SthanClient } from "@sthan/core";

const client = new SthanClient({ apiKey: "sthan_test_your_key" });

const result = await client.verifyAddress("123 Main St, New York, NY 10001");
console.log(result.Result);
```

## Methods

| Method | Description |
|--------|-------------|
| `verifyAddress(address)` | Verify US address deliverability |
| `parseAddress(address)` | Parse freeform address into components |
| `autocompleteAddress(text)` | Address suggestions from partial input |
| `autocompleteCity(text, displayType?)` | City suggestions |
| `autocompleteZipCode(text, displayType?)` | ZIP code suggestions |
| `geocodeAddress(address)` | Forward geocode (address to coordinates) |
| `reverseGeocode(lat, lon)` | Reverse geocode (coordinates to address) |
| `ipGeolocation(ip)` | IP address location lookup |

## License

MIT
npm package: @sthan/mcp-server
Description: MCP server for sthan.io — US address verification, parsing, autocomplete, geocoding, and IP geolocation
Author: sthan.io
Latest version: 0.1.1

# @sthan/mcp-server

MCP server for [sthan.io](https://sthan.io) — US address verification, parsing, autocomplete, geocoding, and IP geolocation.

Works with Claude Code, Cursor, VS Code, Windsurf, and any MCP-compatible client.

## Setup

### 1. Get an API key

Sign up at [sthan.io](https://sthan.io) (free tier, no credit card required). Create an API key from your [dashboard](https://sthan.io/dashboard).

### 2. Configure your client

**Claude Code** (`~/.claude/mcp.json` or project `.claude/mcp.json`):

```json
{
  "mcpServers": {
    "sthan": {
      "command": "npx",
      "args": ["@sthan/mcp-server"],
      "env": { "STHAN_API_KEY": "sthan_test_your_api_key_here" }
    }
  }
}
```

**Cursor** (`.cursor/mcp.json`):

```json
{
  "mcpServers": {
    "sthan": {
      "command": "npx",
      "args": ["@sthan/mcp-server"],
      "env": { "STHAN_API_KEY": "sthan_test_your_api_key_here" }
    }
  }
}
```

**VS Code** (`settings.json`):

```json
{
  "mcp.servers": {
    "sthan": {
      "command": "npx",
      "args": ["@sthan/mcp-server"],
      "env": { "STHAN_API_KEY": "sthan_test_your_api_key_here" }
    }
  }
}
```

## Tools

| Tool | Description |
|------|-------------|
| `sthan_verify_address` | Verify a US address for deliverability. Returns DPV confirmation, ZIP+4, carrier route. |
| `sthan_parse_address` | Parse freeform address text into structured components (street, city, state, zip, unit). |
| `sthan_autocomplete_address` | Get address suggestions from partial input. Sub-100ms response time. |
| `sthan_autocomplete_city` | Get US city suggestions from partial input. |
| `sthan_autocomplete_zipcode` | Get US ZIP code suggestions from partial input. |
| `sthan_geocode` | Convert a US address to latitude/longitude coordinates. |
| `sthan_reverse_geocode` | Convert coordinates to the nearest US street address. |
| `sthan_ip_geolocation` | Look up geographic location of an IPv4 or IPv6 address. |

## Environment variables

| Variable | Required | Description |
|----------|----------|-------------|
| `STHAN_API_KEY` | Yes | Your sthan.io API key (`sthan_test_*` or `sthan_live_*`) |
| `STHAN_API_URL` | No | Override base URL (default: `https://api.sthan.io`) |

## Examples

Once configured, just ask your AI assistant naturally:

- "Is 123 Main St, New York, NY 10001 a real address?"
- "Parse this address: apt 2b 500 broadway new york ny"
- "What are the coordinates for the White House?"
- "What address is at 40.7128, -74.0060?"
- "Where is IP 8.8.8.8 located?"

## Links

- [API docs](https://sthan.io/docs)
- [Pricing](https://sthan.io/pricing/united-states)
- [OpenAPI spec](https://api.sthan.io/openapi.json)
- [AI reference](https://api.sthan.io/llms-full.txt)

## License

MIT
npm package: @sthefanyk/eslint-config
Description: ESLint configuration used by Sthefanyk
Latest version: 1.0.4

# Sthefany Kimberly Personal ESLint config

## Whats included?

- Standard config base;
- Prettier;

## Setup

### Node.js

Install dependencies:
```
npm i -D eslint @sthefanyk/eslint-config
```
Inside `.eslintrc.json`
```
{
  "extends": "@sthefanyk/eslint-config/node"
}
```
npm package: @stheine/ringbufferjs
Description: A ring buffer data structure for Node.js and the browser, extended with some functions for numeric data (sum, min, max, avg).
Latest version: 0.1.1

# @stheine/ringbuffer.js

A ring buffer data structure for Node.js and the browser, extended with
some functions for numeric data (`sum`, `min`, `max`, `avg`).

## Reference

This module is based on
[ringbufferjs](https://www.npmjs.com/package/ringbufferjs) by
[janogonzalez](https://www.npmjs.com/~janogonzalez).

## Installation

As component for the browser:

```
$ component install stheine/ringbufferjs
```

As npm for Node.js:

```
$ npm install @stheine/ringbufferjs
```

## Example

```js
var RingBuffer = require('ringbufferjs');

var ring = new RingBuffer(2);

ring.enq(10);
ring.enq(5);
ring.enq(1); // 10 will be discarded
ring.size(); // 2
ring.peek(); // 5
ring.deq(); // 5
ring.size(); // 1
```

## API

### RingBuffer()

Initializes a new empty `RingBuffer` with the default capacity (50).

### RingBuffer(capacity)

Initializes a new empty `RingBuffer` with the given `capacity`.

### RingBuffer#capacity()

Returns the capacity of the ring buffer.

### RingBuffer#deq()

Dequeues the top element of the ring buffer.
Throws an `Error` when the buffer is empty.

### RingBuffer#enq(element)

Enqueues the `element` at the end of the ring buffer and returns its new size.
When the buffer is full the oldest element is discarded.

### RingBuffer#isEmpty()

Returns whether the ring buffer is empty or not.

### RingBuffer#isFull()

Returns whether the ring buffer is full or not.

### RingBuffer#peek()

Peeks at the top element of the ring buffer.
Throws an `Error` when the buffer is empty.

### RingBuffer#size()

Returns the size of the ring buffer.

### RingBuffer#dump()

Returns all elements of the queue.
Throws an `Error` when the buffer is empty.

### RingBuffer#sum()

Returns the sum of all elements of the queue.
Throws an `Error` when the buffer is empty.

### RingBuffer#min()

Returns the minimum of all elements of the queue.
Throws an `Error` when the buffer is empty.

### RingBuffer#max()

Returns the maximum of all elements of the queue.
Throws an `Error` when the buffer is empty.

### RingBuffer#avg()

Returns the average of all elements of the queue.
Throws an `Error` when the buffer is empty.

## Testing

As component in the browser, open test/test.html in your browser:

```
$ make
$ open test/test.html
```

As npm package:

```
$ npm test
```

## Licence

MIT