open-index/open-npm huggingface dataset:
npm package: @monkeyplus/cms-monkey-lib
Description: All functions for load files json
Author: Andres Navarrete
Latest version: 1.0.0

# My Awesome Greeter

V1.1.0
Creacion de generador da carpetas

V1.8.0

Se agrego una funcion buldSite que separa la logica del contexto global con el de pagina

V1.8.8

Control de error al no existir la carpeta global

V1.9.0

Se agrego la opcion de tener rutas en otras carpetas

V1.9.1

Correccion de errores de generacion de ruta de imagen
ahora se pueden cargar imagenes en subcarpetas
npm package: @monkeyplus/unorm
Description: Universal Orm Layer
Latest version: 0.5.16

# Unorm
Herramienta para capa de datos


## Uso

```bash
# yarn
yarn add @monkeyplus/unorm

# npm
npm install @monkeyplus/unorm

# pnpm
pnpm add @monkeyplus/unorm
```

## Ejemplo

```js
import { createOrm } from '@monkeyplus/unorm';
import { defineDriver } from '@monkeyplus/unorm/drivers/knex';

const driver = defineDriver(/* ...options */);
const orm = createOrm({ driver });

const User = orm.defineModel('users', {
  fields: ['id', 'name', 'email'],
});

// Create User
const user = await User.create({ name: 'John Doe', email: 'email@test.com' });
// Update UserByPk
const user = await User.updateByPk(1, { name: 'John Doe', email: '' });
// Delete UserByPk
const user = await User.deleteByPk(1);
// Find UserByPk
const user = await User.findByPk(1);
// FindAll
const users = await User.findAll();
```
npm package: @monkeysfoot/daysjs
Description: Days js date package
Author: Sean Mathews
Latest version: 0.0.3

## DAYSJS - A TYPESCRIPT / JAVASCRIPT DATE HANDLING LIBRARY

DaysJS is a library that provides base functions for _**DATE**_ handling.  The dates are represented as an integer; the count of days from the Unix epoch (1st January 1970).  There is no time component, and as such no need for any time zone manipulation.  These functions are meant to be used to support Date libraries you develop.  The functions are fast and robust.

This is a port, with permission, of the C++ code by [Howard Hinnant](howard.hinnant@gmail.com) which can be found
here: [https://howardhinnant.github.io/date_algorithms.html](https://howardhinnant.github.io/date_algorithms.html).  
Howard has also graciously allowed me to include his explanations of the algorithms in the documentation, which is a
good thing, cause any attempt I make to explain them would inevitably devolve into a diatribe about the need to
include far more primate species in every level of government; and why modern day law enforcement could be entirely
replaced by a guild of bounty hunters with cool spaceships.

Also, here is a monkey:

```
                                            __,__
                                   .--.  .-"     "-.  .--.
                                  / .. \/  .-. .-.  \/ .. \
                                 | |  '|  /   Y   \  |'  | |
                                 | \   \  \ 0 | 0 /  /   / |
                                  \ '- ,\.-"`` ``"-./, -' /
                                   `'-' /_   ^ ^   _\ '-'`
                                       |  \._   _./  |
                                       \   \ `~` /   /
                                        '._ '-=-' _.'
                                           '~---~'
```
npm package: @monkeysfoot/mkfvalfromdotn
Description: Extracts a value from js object using dot notation
Latest version: 1.2.0

## valueFromDotNotation

Extremly simple library I use in multiple places to extract values from json objects.

`
valueFromDotNotation = (path: string, itm: Record<string, any>): any | undefined
`

The export is aliased as `vfdn`, and is the default export as well.

`valueToDotNotation = (path: string, itm: Record<string, any>, value: any, delim: string = '.'): boolean`

This export is aliased as `vtdn`.

`hasValue = (path: string, itm: Record<string, any>, delim: string = '.'): boolean`

This export is aliased as `has`.

### Usage

given object

```
{
    info: 'val i need',
    test: {
        deeperval: 100
    }    
}
```

vfdn with path param `info` returns `val i need`

vfdn with path param `test.deeperval` returns `100`

vfdn with path param `idontexist` returns `undefined`

after vtdn with path param `dollars.fordonuts` and value param `"combat rabbit"` the object is now:

has with path param `idontexist` returns false

has with path param `test.deeperval` returns true

```
{
    info: 'val i need',
    test: {
        deeperval: 100
    },
    dollars: {
        fordonuts: "combat rabbit"
    }    
}
```
npm package: @monkhai/telelogger
Description: A Telegram-based logging utility for Node.js applications
Author: Monkhai
Latest version: 0.1.1

# @monkhai/telelogger

A lightweight, easy-to-use Telegram logging utility for Node.js applications.

## Features

- Simple integration with Telegram Bot API
- Multiple log levels (info, error, success, warn)
- Customizable message formatters
- TypeScript support
- Zero dependencies

## Installation

Choose your preferred package manager:

```bash
# npm
npm install @monkhai/telelogger

# yarn
yarn add @monkhai/telelogger

# pnpm
pnpm add @monkhai/telelogger

# bun
bun add @monkhai/telelogger
```

## Quick Start

```ts
import { TelegramLogger } from '@monkhai/telelogger'

const logger = new TelegramLogger({
  botToken: 'YOUR_BOT_TOKEN',
  chatId: YOUR_CHAT_ID,
})

// Basic logging
logger.logInfo('Hello, world!')
logger.logError('Something went wrong!')
logger.logSuccess('Operation completed successfully!')
logger.logWarn('Warning: Resource running low')
```

## Configuration

The `TelegramLogger` constructor accepts a configuration object with the following options:

```ts
export interface TelegramLoggerConfig {
  /** Your Telegram Bot Token */
  botToken: string

  /** Target Chat ID where messages will be sent */
  chatId: number

  /** The formatting of the message. */
  parse_mode?: 'HTML' | 'Markdown' | 'MarkdownV2'

  /** Custom formatter for info messages */
  infoFormatter?: (message: string) => string

  /** Custom formatter for error messages */
  errorFormatter?: (message: string) => string

  /** Custom formatter for success messages */
  successFormatter?: (message: string) => string

  /** Custom formatter for warning messages */
  warnFormatter?: (message: string) => string
}
```

### Custom Formatters Example

You can customize how messages are formatted before they're sent to Telegram:
notice the `<b>` tags in the formatters, adding bold text to the titles.
This allows you to add more information to the messages, such as links, bold text, etc.
for more information on the different parse modes, see the [Telegram API documentation](https://core.telegram.org/bots/api#formatting-options).

```ts
const logger = new TelegramLogger({
  botToken: 'YOUR_BOT_TOKEN',
  chatId: 'YOUR_CHAT_ID',
  parse_mode: 'HTML', // allows us to add <b> tags and more
  infoFormatter: message => `ℹ️ <b>INFO:</b>\n${message}`,
  errorFormatter: message => `❌ <b>ERROR:</b>\n${message}`,
  successFormatter: message => `✅ <b>SUCCESS:</b>\n${message}`,
  warnFormatter: message => `🚨️ <b>WARNING:</b>\n${message}`,
})
```

## License

MIT

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.
npm package: @monkhsaikhan/vue3-facebook-login
Description: Vue3 Facebook Login
Author: HealerNguyen
Latest version: 1.0.7

# Vue 3 facebook login

[![npm](https://img.shields.io/npm/v/@healerlab/vue3-facebook-login?style=flat-square)](https://www.npmjs.com/package/@healerlab/vue3-facebook-login)
[![npm](https://img.shields.io/npm/dw/@healerlab/vue3-facebook-login?style=flat-square)](https://www.npmjs.com/package/@healerlab/vue3-facebook-login)
[![GitHub](https://img.shields.io/github/license/healerlab/vue3-facebook-login?style=flat-square)](https://github.com/healerlab/vue3-facebook-login/blob/main/LICENSE)

## Demo
[Demo and docs](https://healerlab.github.io/vue3-facebook-login)

## Installation

### Prerequisites

- [Node.js](https://nodejs.org/) version 16 or higher.
- Text Editor.
  - [VSCode](https://code.visualstudio.com/) is recommended, along with the [official Vue extension](https://marketplace.visualstudio.com/items?itemName=Vue.volar).

To get started, you can install `vue3-facebook-login` with:

```bash
npm i @healerlab/vue3-facebook-login
```

with pnpm:

```bash
pnpm add @healerlab/vue3-facebook-login
```

with yarn:

```bash
yarn add @healerlab/vue3-facebook-login
```



## Usage
See the [FaceBook Graph API](https://developers.facebook.com/tools/explorer) for more information about scope.

Import the component and register it locally in your Vue component:

```vue
<script setup>
import { HFaceBookLogin } from '@healerlab/vue3-facebook-login';

const onSuccess = (response) => {
  // get your auth token and info
}

const onFailure = () => {
  // logic if auth failed
}
</script>
```

Use the component in your template:

```vue
<HFaceBookLogin 
  v-slot="fbLogin" 
  app-id="391069538168549" 
  @onSuccess="onSuccess" 
  @onFailure="onFailure"
  scope="email,public_profile"
  fields="id,name,email,first_name,last_name,birthday"
>
  <span @click="fbLogin.initFBLogin" class="fb-button">Login with facebook</span>
</HFaceBookLogin>
```

This is style for this example and not required, you can change and customize it to match your use-case:
```scss
.fb-button {
  display: inline-block;
  margin: 10px 0 10 0;
  color: white;
  background-color: #1967d2;
  border-radius: 8px;
  padding: 16px;
  cursor: pointer;
}
```

See the [Vue3 FaceBook Login](https://healerlab.github.io/vue3-facebook-login) page for more information.
npm package: @monkilabs/backbone
Description: Scaffold a production-ready Nx monorepo for MonkiLabs projects
Author: MonkiLabs
Latest version: 0.6.0

# BACKBONE

Scaffold a production-ready monorepo for scalable projects. The interactive CLI lets you pick your stack — monorepo tool, framework, backend, CMS, testing, deployment, and optional packages — then generates a fully wired workspace.

## Quickstart

```bash
npx @monkilabs/backbone my-app
```

The CLI walks you through each choice, then scaffolds the project:

```bash
cd my-app
npm install
npx nx serve web     # Nx
npx turbo dev        # Turborepo
```

## Options

| Category | Choices |
|----------|---------|
| **Monorepo** | Nx, Turborepo |
| **Framework** | Next.js, Astro |
| **Backend** | Convex, Supabase, Prisma |
| **CMS** | Sanity, Contentful, Strapi, None |
| **E2E Testing** | Playwright, Cypress |
| **Deployment** | Vercel, Netlify, None |
| **Mobile** | Ionic + Capacitor, None |
| **Packages** | UI library (React), Email library (Resend), LLM library |

Unit testing with **Vitest** and CI with **GitHub Actions** are always included.

### Incompatible combinations

Astro is not compatible with Ionic, Convex, or the UI library (all require React). The CLI prevents these selections automatically.

## Requirements

- Node.js ≥ 22.5.0

## Project name rules

Must start with a lowercase letter, contain only lowercase letters, digits, hyphens, or underscores, and be at most 214 characters. Reserved names (`node_modules`, `dist`, `build`, `test`, `src`, `lib`, `bin`, `tmp`, `temp`, `cache`, `coverage`) are not allowed.

## Generated project structure

The exact layout depends on your choices. A typical Nx + Next.js + Supabase project looks like:

```
my-app/
├── apps/
│   ├── web/            # Next.js or Astro app
│   └── mobile/         # Ionic + Capacitor (if selected)
├── packages/
│   ├── ui/             # Shared UI component library (if selected)
│   ├── llm/            # LLM prompts & tools (if selected)
│   └── email/          # Email templates with Resend (if selected)
├── backend/
│   ├── supabase/       # Supabase config (if selected)
│   ├── contentful/     # Contentful client + type gen (if selected)
│   └── ...             # Other backend/CMS integrations
├── convex/             # Convex functions (if selected)
├── e2e/                # Playwright or Cypress specs
├── .github/workflows/
│   ├── ci.yml          # Lint, type-check, test
│   └── deploy.yml      # Deployment workflow (if configured)
├── nx.json             # Nx workspace config (Nx mode)
├── turbo.json          # Turborepo config (Turborepo mode)
├── vitest.config.ts
├── tsconfig.base.json
└── package.json
```

## Deployment

When you select Vercel or Netlify, the generated project includes the corresponding configuration files and a GitHub Actions deployment workflow.

If no deployment platform is selected, a generic CI workflow (`.github/workflows/ci.yml`) is still generated for linting, type-checking, and testing.

## Development

```bash
# Build the CLI
npm run build

# Run tests
npm test

# Watch mode
npm run dev        # TypeScript
npm run test:watch # Vitest
```