open-index/open-npm huggingface dataset:
npm package: @pb33f/ranch
Description: A tiny event bus to connect to the ranch
Latest version: 0.7.0

## ranch.js

If you're a cowboy, you need a ranch.

To get to the ranch, you need a horse.

This is the horse.

---

Designed to be used with [ranch](https://github.com/pb33f/ranch).

---

ranch.js and [saddlebag](https://github.com/pb33f/saddlebag-js) and [ranch](https://github.com/pb33f/ranch) are re-imagined, 
simplified and modernized versions of [transport](https://transport-bus.io).

All the power, none of the complexity.

---

This is very much under construction, and should **not be used by anyone, anywhere, for anything**. If you do, you're on your own.

It's custom designed for pb33f and our needs for now.
npm package: @pb4/ng-fluentui
Description: Wrapper library to use Fluent UI web components within Angular
Latest version: 0.0.4

# @pb4/ng-fluentui

**Angular wrapper library for [@fluentui/web-components](https://www.npmjs.com/package/@fluentui/web-components) v2.6.1**

This package allows you to use Fluent UI Web Components in Angular without needing to configure `CUSTOM_ELEMENTS_SCHEMA`.

Template validation remains enabled, which can help catch template errors early in development.

## Installation

1. Install the npm package:
```bash
npm install @pb4/ng-fluentui@latest
```

2. Register Fluent UI components in your `main.ts` file (before bootstrapApplication):

```ts
import {
  provideFluentDesignSystem,
  allComponents
} from "@fluentui/web-components";

provideFluentDesignSystem()
  .register(
    allComponents
  );
```

Instead of using allComponents, you can register only the Fluent UI Web Components you need.
For alternative configuration options, see the official documentation:
[Use Fluent UI Web Components with Angular](https://learn.microsoft.com/en-us/fluent-ui/web-components/integrations/angular)

## Prerequisites

This package requires an Angular project.

This library is expected to work with Angular v18 LTS through v20.1. Only minimal compatibility checks (e.g. basic rendering) have been done, since the package does not modify component behavior.

## 🚀 Usage

Here's how to use fluent-tree-view and fluent-tree-item via this wrapper (no need for CUSTOM_ELEMENTS_SCHEMA):

```ts
import { Component } from '@angular/core';
import { FluentTreeView, FluentTreeItem } from '@pb4/ng-fluentui';

@Component({
  selector: 'app-example',
  standalone: true,
  imports: [FluentTreeView, FluentTreeItem],
  template: `
<fluent-tree-view>
  Root
  <fluent-tree-item>
    Fruit
    <fluent-tree-item>Pear</fluent-tree-item>
    <fluent-tree-item>Mango</fluent-tree-item>
    <fluent-tree-item>Guava</fluent-tree-item>
    <fluent-tree-item>Pomegranate</fluent-tree-item>
  </fluent-tree-item>
  <fluent-tree-item>
    Guitars
    <fluent-tree-item>Fender</fluent-tree-item>
    <fluent-tree-item>Gibson</fluent-tree-item>
    <fluent-tree-item>Teisco</fluent-tree-item>
    <fluent-tree-item>Martin</fluent-tree-item>
  </fluent-tree-item>
  <fluent-tree-item>Earth</fluent-tree-item>
</fluent-tree-view>
  `,
})
export class PageComponent {}
```

If you're not registering allComponents, then your `main.ts` file should include just web components you use:
```ts
import {
  provideFluentDesignSystem,
  fluentTreeView,
  fluentTreeItem
} from "@fluentui/web-components";

provideFluentDesignSystem()
  .register(
    fluentTreeView(), fluentTreeItem()
  );
```

## What this package is (and isn't)
This is a wrapper for [@fluentui/web-components](https://www.npmjs.com/package/@fluentui/web-components).
It does not change or extend the original web components.

Microsoft maintains the actual web components. This wrapper library is not maintained by Microsoft.
Regular updates are not guaranteed, but the source code is available.

It simply exposes the Fluent UI Web Components as Angular standalone components, for a better developer experience.
npm package: @pbackup/capacitor-audio-session-plugin
Description: Capacitor plugin to set AVAudioSession to use loudspeaker on iOS
Author: Your Name
Latest version: 1.0.1

# Capacitor Audio Session Plugin

A Capacitor plugin that sets iOS AVAudioSession to use the loudspeaker while recording.

## Install

```bash
npm install @yourname/capacitor-audio-session-plugin
npx cap sync
```
npm package: @pbackup/capaudio
Description: Handles ios quietness on mic use.
Author: Pepe Kustovitz
Latest version: 0.0.11

# @pbackup/capaudio

Handles ios quietness on mic use.

## Install

```bash
npm install @pbackup/capaudio
npx cap sync
```

## API

<docgen-index>

* [`showSharedSessions()`](#showsharedsessions)

</docgen-index>

<docgen-api>
<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->

### showSharedSessions()

```typescript
showSharedSessions() => Promise<any>
```

Shows shared audio sessions (iOS only).

**Returns:** <code>Promise&lt;any&gt;</code>

--------------------

</docgen-api>
npm package: @pbackup/capbaudio
Description: This is good.
Author: Peter
Latest version: 0.0.2

# @pbackup/capbaudio

This is good.

## Install

```bash
npm install @pbackup/capbaudio
npx cap sync
```

## API

<docgen-index>

* [`echo(...)`](#echo)

</docgen-index>

<docgen-api>
<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->

### echo(...)

```typescript
echo(options: { value: string; }) => Promise<{ value: string; }>
```

| Param         | Type                            |
| ------------- | ------------------------------- |
| **`options`** | <code>{ value: string; }</code> |

**Returns:** <code>Promise&lt;{ value: string; }&gt;</code>

--------------------

</docgen-api>
npm package: @pbackup/slate-react
Description: Tools for building completely customizable rich-text editors with React.
Latest version: 0.22.15

This package contains the React-specific logic for Slate. It's separated further into a series of directories:

- [**Components**](./src/components) — containing the React components for rendering Slate editors.
- [**Constants**](./src/constants) — containing a few private constants modules.
- [**Plugins**](./src/plugins) — containing the React-specific plugins for Slate editors.
- [**Utils**](./src/utils) — containing a few private convenience modules.

Feel free to poke around in each of them to learn more!
npm package: @pbdesk/serverless-jest-plugin
Description: Serverless plugin for test driven development using Jest
Author: Eetu Tuomala
Latest version: 0.1.4

# Serverless Jest Plugin

[![Build Status](https://travis-ci.org/SC5/serverless-jest-plugin.svg?branch=master)](https://travis-ci.org/SC5/serverless-jest-plugin)

A Serverless Plugin for the [Serverless Framework](http://www.serverless.com) which
adds support for test-driven development using [jest](https://facebook.github.io/jest/)

**THIS PLUGIN REQUIRES SERVERLESS V1.0 OR LATER!**

More familiar with Mocha? Try [serverless-mocha-plugin](https://github.com/sc5/serverless-mocha-plugin).

## Introduction

This plugins does the following:

* It provides commands to create and run tests manually
* It provides a command to create a function, which automatically also creates a test

## Installation

In your service root, run:

```bash
npm install --save-dev serverless-jest-plugin
```

Add the plugin to `serverless.yml`:

```yml
plugins:
  - serverless-jest-plugin
```

## Usage

### Creating functions

Functions (and associated tests) can be created using the command

```
sls create function -f functionName --handler handler
```
 
e.g.

```
sls create function -f myFunction --handler functions/myFunction/index.handler
```

creates a new function `myFunction` into `serverless.yml` with a code template for
the handler in `functions/myFunction/index.js` and a Javascript function `module.exports.handler` 
as the entrypoint for the Lambda function. A test template is also created into `test/myFunction.js`. Optionally tests can be created to specific folder using `--path` or `-p` switch, e.g. 

```
sls create function -f myFunction --handler functions/myFunction/index.handler --path tests
```

To create tests next to handler use `--path {function}`, in following example test file `myFunction.test.js` is created to `functions/myFunction/` directory.

```
sls create function -f myFunction --handler functions/myFunction/index.handler --path {function}
```

### Creating tests

Tests can also be added to existing handlers using

```
sls create test -f functionName
```

### Running tests

Tests can be run directly using Jest or using the "invoke test" command

```
sls invoke test [--stage stage] [--region region] [-f function]
```

If no function names are passed to "invoke test", all tests related to handler functions are run.

## License
https://github.com/SC5/serverless-jest-plugin/blob/master/LICENSE
npm package: @pbe/fastify-jsonp
Description: A Fastify plugin to add jsonp support
Author: Pavel Bely
Latest version: 1.0.2

# @pbe/fastify-jsonp

[![checks](https://github.com/R1ZEN/fastify-jsonp/actions/workflows/checks.yml/badge.svg?branch=master)](https://github.com/R1ZEN/fastify-jsonp/actions/workflows/checks.yml)
[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](https://standardjs.com/)
[![npm](https://img.shields.io/npm/v/@pbe/fastify-jsonp?label=npm%20version)](https://www.npmjs.com/package/@pbe/fastify-jsonp)
[![npm bundle size](https://img.shields.io/bundlephobia/min/@pbe/fastify-jsonp)](https://bundlephobia.com/package/@pbe/fastify-jsonp)

A plugin for [Fastify](http://fastify.io/) that adds support for [jsonp](https://en.wikipedia.org/wiki/JSONP#JSONP) response.

## Installation

```sh
npm i @pbe/fastify-jsonp
```

or

```sh
yarn add @pbe/fastify-jsonp
```

## Example

```js
const fastify = require('fastify')()

fastify.register(require('@pbe/fastify-jsonp'))

fastify.get('/', (req, reply) => {
  reply.jsonp({ hello: 'world' });
});

fastify.listen({ port: 3000 });
```

Terminal:
```sh
$ curl "http://localhost:3000/?callback=myCallback"
$ /**/ typeof myCallback === 'function' && myCallback({"hello":"world"});
```

## License

[MIT License](http://jsumners.mit-license.org/)
npm package: @pbe/react-yandex-maps
Description: Yandex.Maps API bindings for React
Latest version: 1.2.5

# React Yandex Maps

[![npm](https://img.shields.io/npm/v/@pbe/react-yandex-maps)](https://www.npmjs.com/package/@pbe/react-yandex-maps)
[![npm bundle size](https://img.shields.io/bundlephobia/minzip/@pbe/react-yandex-maps)](https://bundlephobia.com/package/@pbe/react-yandex-maps)

[Yandex Maps API][ymaps-api] bindings for React

[ymaps-api]:
  https://tech.yandex.com/maps/doc/jsapi/2.1/quick-start/index-docpage/

### Features

- Supports TypeScript out of the box
- Automatic yamps api and modules loading
- Declarative rendering

### Installation

npm:

```
npm install @pbe/react-yandex-maps
```

yarn:

```
yarn add @pbe/react-yandex-maps
```

### Getting Started

Try running a simple example:

```jsx
import React from 'react';
import { YMaps, Map, Placemark } from '@pbe/react-yandex-maps';

export default function App() {
  const defaultState = {
    center: [55.751574, 37.573856],
    zoom: 5,
  };

  return (
    <YMaps>
      <Map defaultState={defaultState}>
        <Placemark geometry={[55.684758, 37.738521]} />
      </Map>
    </YMaps>
  );
}
```

### Documentation

The React Yandex Maps docs are located at
[website](https://pbe-react-yandex-maps.vercel.app)

- [Getting Started](https://pbe-react-yandex-maps.vercel.app/)
- [Core Principles](https://pbe-react-yandex-maps.vercel.app/core-principles/)
- [API Reference](https://pbe-react-yandex-maps.vercel.app/category/api-reference/)

### Contribution

We appreciate your help!

To contribute, please read our [contributing instructions](./CONTRIBUTING.md).

### License

[MIT](./LICENSE)
npm package: @pberganza/fedi-comments
Description: A web component that displays comments based on replies on the fediverse.
Author: Pablo Berganza
Latest version: 0.1.4

# fedi-comments

A web component that displays comments based on replies on the fediverse.

## Installation

```bash
npm add @pberganza/fedi-comments

# OR

pnpm add @pberganza/fedi-comments
```

## Usage

This component is naive. It will _just_ display the replies to a status with a specific ID.

It is intended to be used by first sharing a link of your post to your Fediverse account, grabbing the ID from
it and using it in this component to display replies to that status as replies to your article.

```html
<script type="module">
    import '@pberganza/fedi-comments'
</script>
<fedi-comments id="1234567890" instance="mastodon.social"></fedi-comments>
```
npm package: @pberganza/html-code-editor
Description: An HTML code editor made with code mirror for live coding
Author: html-code-editor
Latest version: 0.0.6

# \<html-code-editor>

This webcomponent follows the [open-wc](https://github.com/open-wc/open-wc) recommendation.

## Installation

```bash
npm i @pberganza/html-code-editor
```

## Usage

```html
<script type="module">
  import '@pberganza/html-code-editor/html-code-editor.js';
</script>

<html-code-editor></html-code-editor>
```

## Linting and formatting

To scan the project for linting and formatting errors, run

```bash
npm run lint
```

To automatically fix linting and formatting errors, run

```bash
npm run format
```


## Tooling configs

For most of the tools, the configuration is in the `package.json` to reduce the amount of files in your project.

If you customize the configuration a lot, you can consider moving them to individual files.

## Local Demo with `web-dev-server`

```bash
npm start
```

To run a local development server that serves the basic demo located in `demo/index.html`
npm package: @pberganza/nestjs-dataloader
Description: A NestJS decorator for dataloader
Author: Kris Lefeber
Latest version: 7.0.1

# NestJS Dataloader

NestJS dataloader simplifies adding [graphql/dataloader](https://github.com/graphql/dataloader) to your NestJS project. DataLoader aims to solve the common N+1 loading problem.

## Installation

Install with yarn

```bash
yarn add nestjs-dataloader
```

Install with npm

```bash
npm install --save nestjs-dataloader
```

## Usage

### NestDataLoader Creation

We start by implementing the `NestDataLoader` interface. This tells `DataLoader` how to load our objects.

```typescript
import * as DataLoader from 'dataloader';
import { Injectable } from '@nestjs/common';
import { NestDataLoader } from 'nestjs-dataloader';
...

@Injectable()
export class AccountLoader implements NestDataLoader<string, Account> {
  constructor(private readonly accountService: AccountService) { }

  generateDataLoader(): DataLoader<string, Account> {
    return new DataLoader<string, Account>(keys => this.accountService.findByIds(keys));
  }
}
```

The first generic of the interface is the type of ID the datastore uses. The second generic is the type of object that will be returned. In the above instance, we want `DataLoader` to return instances of the `Account` class.

### Providing the NestDataLoader

For each NestDataLoader we create, we need to provide it to our module.

```typescript
import { Module } from '@nestjs/common';
import { APP_INTERCEPTOR } from '@nestjs/core';
import {DataLoaderInterceptor} from 'nestjs-dataloader'
...

@Module({
  providers: [
    AccountResolver,
    AccountLoader,
    {
      provide: APP_INTERCEPTOR,
      useClass: DataLoaderInterceptor,
    },
  ],

})
export class ResolversModule { }
```

### Using the NestDataLoader

Now that we have a dataloader and our module is aware of it, we need to pass it as a parameter to an endpoint in our graphQL resolver.

```typescript
import * as DataLoader from 'dataloader';
import { Loader } from 'nestjs-dataloader';
...

@Resolver(Account)
export class AccountResolver {

    @Query(() => [Account])
    public getAccounts(
        @Args({ name: 'ids', type: () => [String] }) ids: string[],
        @Loader(AccountLoader.name) accountLoader: DataLoader<Account['id'], Account>): Promise<Account[]> {
        return accountLoader.loadMany(ids);
    }
}
```

The important thing to note is that the parameter of the `@Loader` decorator is the name of the `NestDataLoader` class we want to be injected to the method. The DataLoader library will handle bulk retrieval and caching of our requests. Note that the caching is stored on a per-request basis.

## Contributing

Pull requests are always welcome. For major changes, please open an issue first to discuss what you would like to change.
npm package: @pbes/audic
Description: Play some audio.
Author: Richie Bendall
Latest version: 2.1.1

# Audic [![Travis CI Build Status](https://img.shields.io/travis/com/Richienb/audic/master.svg?style=for-the-badge)](https://travis-ci.com/Richienb/audic)

Play some audio.

[![NPM Badge](https://nodei.co/npm/audic.png)](https://npmjs.com/package/audic)

## Install

```sh
npm install audic
```

## Usage

```js
const Audic = require("audic")

new Audic("audio.mp3").play()
```

## API

See the [documentation](https://richienb.github.io/audic).
npm package: @pbgov-ds/core
Description: Padrão Digital do Governo da Paraíba da Paraíba
Author: CODATA
Latest version: 2.0.0

# Padrão Digital do Governo da Paraíba

## Objetivo

O [Padrão Digital do Governo da Paraíba](https://www.gov.br/ds/ 'Acesse a página do Padrão Digital do Governo da Paraíba') apresenta os padrões de interface que devem ser seguidos por designers e desenvolvedores para garantir a experiência única na interação dos usuários com os sistemas interativos do Governo.

## Tecnologias

Esse projeto é desenvolvido usando:

1. Javascript
1. [SASS](https://sass-lang.com/ 'Acesse a página do SASS')
1. [PUG](https://pugjs.org/ 'Acesse a página do PUG')

## Dependências

As principais dependências do projeto são:

1. [Font Awesome](https://fontawesome.com/ 'Acesse para realizar o download da Font Awesome')

1. [Fonte Rawline](https://www.cdnfonts.com/rawline.font/ 'Acesse para realizar o download da Fonte Rawline')

> O fontawesome e a fonte rawline podem ser importadas de um CDN. Consulte a documentação no site do [Padrão Digital do Governo da Paraíba](https://www.gov.br/ds/ 'Acesse o site do Padrão Digital do Governo da Paraíba') para mais detalhes.
>
## Como usar nossa biblioteca em seu projeto?

### Instalação da biblioteca

Você pode instalar a nossa biblioteca de Web Components no seu projeto usando:

```node
npm install --save @pbgov-ds/core
```

### Como começar

Criamos um [tutorial no nosso site](https://gov.br/ds/como-comecar/instalacao 'Acesse o Guia de Instalação do Padrão Digital do Governo da Paraíba') explicando como começar a utilizar nosso Design System.

## Lints

Nesse projeto usamos diversos tipos de lints para automaticamente verificar o código antes de enviar para review. Para executá-los e obter os resultados execute o comando:

```node
npm run lint
```

## Precisa de ajuda?

> Por favor **não** crie issues para fazer perguntas...

Use nossos canais abaixo para obter tirar suas dúvidas:

-   Site do Design System GOV.BR <https://www.gov.br/ds/>

-   Web Components <https://gitlab.com/govbr-ds/wbc/govbr-ds-wbc/>

-   Pelo nosso email <govbr-ds@serpro.gov.br>

-   Usando nosso canal no discord <https://discord.gg/NkaVZERAT7>

## Como contribuir?

Por favor verifique nossos guias de [como contribuir](https://gov.br/ds/wiki/comunidade/contribuindo-com-o-ds/ 'Acesse a página como contribuir?').

### Commits

Nesse projeto usamos um padrão para branches e commits. Por favor observe a documentação na nossa [wiki](https://gov.br/ds/wiki/ 'Acesse a Wiki do Padrão Digital do Governo da Paraíba') para aprender sobre os nossos padrões.

## Créditos

O Design System  é criado pelo [SERPRO](https://www.serpro.gov.br/ 'Acesse a página do SERPRO | Serviço Federal de Processamento de Dados') juntamente com a participação da comunidade.

## Licença

Nesse projeto usamos a licença MIT.
npm package: @pbinj/pbj-visualization
Description: A lightweight Dependency Injection (DI) framework for Node.js, based on proxies.
Author: Justin Spears
Latest version: 4.0.5

# pbj-visualization

This provides a view of your PBinJ context. Both in network and table form.

see [docs](https://pbinj.github.io/pbj/plugins/visualization)

## Project Setup

```sh
pnpm install
```

### Compile and Hot-Reload for Development

```sh
pnpm dev
```

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

```sh
pnpm build
```

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

```sh
pnpm test:unit
```
npm package: @pbip-tools/core
Description: Core types and constants for pbip-tools
Latest version: 0.3.0

# @pbip-tools/core

Core types and constants for the [pbip-tools](https://github.com/iamahlramz/pbip-tools) monorepo.

## Installation

```bash
npm install @pbip-tools/core
```

## Usage

```typescript
import type { PbipProject, TmdlTable, TmdlMeasure } from '@pbip-tools/core';
```

This package is a types-only dependency used by all other `@pbip-tools/*` packages. It defines the shared data model for PBIP projects, tables, measures, relationships, roles, and visual bindings.

## Exports

### Types

- `PbipProject` — Top-level project with model, tables, relationships
- `TmdlModel` — Model with tables, relationships, cultures, roles, expressions
- `TmdlTable` — Table with columns, measures, partitions, hierarchies
- `TmdlMeasure` — Measure with DAX expression, format string, display folder
- `TmdlColumn` — Column with data type, sort by, data category
- `TmdlRelationship` — Relationship with cardinality and cross-filter direction
- `TmdlRole` — RLS role with table permissions and DAX filters
- `VisualBinding` — Visual field binding with entity/property references
- `TmdlCalculationGroup` — Calculation group with items and precedence

### Constants

- `TMDL_FILE_TYPES` — Enum of TMDL file types (table, relationship, expression, culture, role)

## License

MIT
npm package: @pbip-tools/dax-formatter
Description: DAX expression formatter and validator for Power BI — DaxFormatter.com API client + offline validation
Latest version: 0.2.2

# @pbip-tools/dax-formatter

DAX expression formatter and validator for Power BI — DaxFormatter.com API client + offline validation.

Part of the [pbip-tools](https://github.com/iamahlramz/pbip-tools) monorepo.

## Installation

```bash
npm install @pbip-tools/dax-formatter
```

## Usage

```typescript
import { formatDax, validateDax } from '@pbip-tools/dax-formatter';

// Format via DaxFormatter.com API (requires internet)
const result = await formatDax('CALCULATE(SUM(Sales[Amount]),FILTER(Sales,Sales[Year]=2024))');
console.log(result.formatted);

// Validate offline (no API needed)
const validation = validateDax('SUM(Table[Column)');
console.log(validation.issues); // Reports unmatched bracket
```

## Features

- **Online formatting** via DaxFormatter.com REST API (industry standard used by Tabular Editor and DAX Studio)
- **Batch formatting** with configurable batch size (default 50)
- **Offline validation** — bracket/string balance, unknown function detection
- **400+ known DAX functions** for validation
- Configurable list/decimal separators, line style, spacing style
- Structured error handling (never throws on network errors)
- 30s default timeout with AbortController

## API

### Formatter (requires internet)

- `formatDax(expression, options?)` — Format a single DAX expression
- `formatDaxBatch(expressions, options?)` — Batch format multiple expressions

### Validator (offline)

- `validateDax(expression)` — Validate DAX syntax locally

### Constants

- `DAX_FUNCTIONS` — `ReadonlySet<string>` of 400+ known DAX function names

### Types

- `DaxFormatOptions` — Formatting options (separators, line style, spacing)
- `DaxFormatResult` — Format result with `formatted` string or `errors`
- `DaxValidationResult` — Validation result with `valid` flag and `issues`

## License

MIT
npm package: @pbip-tools/project-discovery
Description: PBIP project discovery, loading, and security filtering
Latest version: 0.3.1

# @pbip-tools/project-discovery

PBIP project discovery, loading, and security filtering.

Part of the [pbip-tools](https://github.com/iamahlramz/pbip-tools) monorepo.

## Installation

```bash
npm install @pbip-tools/project-discovery
```

## Usage

```typescript
import { discoverProjects, loadProject, applySecurityFilter } from '@pbip-tools/project-discovery';

// Auto-discover .pbip projects in a directory
const projects = await discoverProjects('/path/to/workspace');

// Load and parse a full project
const project = await loadProject(projects[0].pbipPath);

// Apply security filter before sending to AI
const filtered = applySecurityFilter(project);
```

## Features

- Auto-discovers `.pbip` project files in a workspace directory
- Loads and parses complete PBIP projects (TMDL model + report)
- Security filter strips M-code and connection strings before AI context
- Configuration via `.pbip-tools.json`
- Write support for tables, measures, and RLS roles

## API

### Discovery

- `discoverProjects(directory)` — Find all `.pbip` projects
- `loadConfig(directory)` — Load `.pbip-tools.json` configuration
- `resolveSecurityConfig(config)` — Resolve security settings with defaults

### Loading

- `loadProject(pbipPath)` — Load and parse a complete PBIP project

### Security

- `applySecurityFilter(project)` — Redact M-code and connection strings

### Writing

- `writeTableFile(project, table)` — Write a table back to TMDL
- `deleteTableFile(project, tableName)` — Delete a table's TMDL file
- `writeRoleFile(project, role)` — Write an RLS role to TMDL
- `deleteRoleFile(project, roleName)` — Delete a role's TMDL file

## License

MIT
npm package: @pbip-tools/tmdl-parser
Description: TMDL file parser and serializer for Power BI PBIP projects
Latest version: 0.2.1

# @pbip-tools/tmdl-parser

Full TMDL (Tabular Model Definition Language) parser and serializer for Power BI PBIP projects.

Part of the [pbip-tools](https://github.com/iamahlramz/pbip-tools) monorepo.

## Installation

```bash
npm install @pbip-tools/tmdl-parser
```

## Usage

```typescript
import { parseTmdl, serializeTable } from '@pbip-tools/tmdl-parser';

// Parse a TMDL file
const result = parseTmdl(tmdlContent, 'table');
console.log(result.tables[0].measures);

// Serialize back to TMDL
const tmdl = serializeTable(table);
```

## Features

- All 3 DAX expression forms: inline, multi-line indent-based, backtick-delimited
- Database/model metadata, tables, columns, measures, partitions, hierarchies
- Calculation groups with precedence and format string expressions
- Relationships (GUID-named and descriptive-named, many-to-many, bi-directional)
- Expressions with M-code and `meta` parameters
- Cultures with `linguisticMetadata` JSON blobs
- RLS roles with `tablePermission` DAX filters
- Forward compatibility — unknown syntax captured as `UnknownNode`

## API

### Parser

- `parseTmdl(content, fileType)` — Parse TMDL content into structured objects
- `detectFileType(content)` — Auto-detect the TMDL file type

### Lexer

- `tokenize(content)` — Tokenize TMDL content into tokens
- `unquoteName(name)` — Remove quotes from TMDL identifiers

### Serializer

- `serializeDatabase(database)` — Serialize database metadata
- `serializeModel(model)` — Serialize model metadata
- `serializeTable(table)` — Serialize a table with all children
- `serializeRelationships(relationships)` — Serialize relationships
- `serializeExpressions(expressions)` — Serialize expressions
- `serializeCulture(culture)` — Serialize a culture
- `serializeRole(role)` — Serialize an RLS role

## License

MIT
npm package: @pbip-tools/visual-handler
Description: Visual.json handler for Power BI PBIP reports — binding extraction, updating, and auditing
Latest version: 0.2.1

# @pbip-tools/visual-handler

Visual.json handler for Power BI PBIP reports — binding extraction, updating, and auditing.

Part of the [pbip-tools](https://github.com/iamahlramz/pbip-tools) monorepo.

## Installation

```bash
npm install @pbip-tools/visual-handler
```

## Usage

```typescript
import { scanReportPages, extractBindings, updateBindingsInJson } from '@pbip-tools/visual-handler';

// Scan all pages and visuals in a report
const pages = await scanReportPages(reportPath);

// Extract bindings from a visual.json file
const bindings = extractBindings(visualJson);

// Update bindings after a measure move
const updated = updateBindingsInJson(visualJson, [
  {
    oldEntity: 'OldTable',
    oldProperty: 'MyMeasure',
    newEntity: 'NewTable',
    newProperty: 'MyMeasure',
  },
]);
```

## Features

- Recursive binding extractor covering all 6 binding locations:
  - Projections, sort, objects, container objects, reference lines, filters
- Handles all visual types including Deneb and custom visuals
- Batch binding updates for measure moves and table renames
- Report page scanner for discovering all visuals

## API

- `scanReportPages(reportPath)` — Discover all pages and visual files in a report
- `findVisualFiles(reportPath)` — Find all visual.json file paths
- `extractBindings(visualJson)` — Extract measure/column bindings from visual JSON
- `updateBindingsInJson(json, updates)` — Apply binding updates to visual JSON
- `parseVisualFile(filePath)` — Parse a visual.json file with type guards

## License

MIT
npm package: @pbji/piper-tts-web
Description: Fork of @diffusion-studio/vits-web for easier built-in PiperTTS use.
Author: pbji
Latest version: 1.0.4

> This is a fork of [@diffusion-studio/vits-web](https://github.com/diffusion-studio/vits-web) for use
> of PiperTTS modules inside of a browser/Electron for AnythingLLM.
> A big shout-out goes to [Rhasspy Piper](https://github.com/rhasspy/piper), who open-sourced all the currently available models > (MIT License) and to [@jozefchutka](https://github.com/jozefchutka) who came up with the wasm build steps.

# Run PiperTTS based text-to-speech in the browser powered by the [ONNX Runtime](https://onnxruntime.ai/)

## Difference from the original

### Caching for client

You can leverage `TTSSessions` for a faster inference. (see index.js for implementation)
Credit to [this PR](https://github.com/diffusion-studio/vits-web/pull/5) for the starting point.

### Local WASM/Loading

You can define local WASM paths for the `ort` wasm as well as the phenomizer wasm and data file for faster local loading
since the client could be offline.

### Note:

This is a frontend library and will not work with NodeJS.

## Usage
First of all, you need to install the library:
```bash
yarn add @mintplex-labs/piper-tts-web
```

Then you're able to import the library like this (ES only)
```typescript
import * as tts from '@mintplex-labs/piper-tts-web';
```

Now you can start synthesizing speech!
```typescript
const wav = await tts.predict({
  text: "Text to speech in the browser is amazing!",
  voiceId: 'en_US-hfc_female-medium',
});

const audio = new Audio();
audio.src = URL.createObjectURL(wav);
audio.play();

// as seen in /example with Web Worker
```


With the initial run of the predict function you will download the model which will then be stored in your [Origin private file system](https://developer.mozilla.org/en-US/docs/Web/API/File_System_API/Origin_private_file_system). You can also do this manually in advance *(recommended)*, as follows:
```typescript
await tts.download('en_US-hfc_female-medium', (progress) => {
  console.log(`Downloading ${progress.url} - ${Math.round(progress.loaded * 100 / progress.total)}%`);
});
```

The predict function also accepts a download progress callback as the second argument (`tts.predict(..., console.log)`). <br>

If you want to know which models have already been stored, do the following
```typescript
console.log(await tts.stored());

// will log ['en_US-hfc_female-medium']
```

You can remove models from opfs by calling
```typescript
await tts.remove('en_US-hfc_female-medium');

// alternatively delete all

await tts.flush();
```

And last but not least use this snippet if you would like to retrieve all available voices:
```typescript
console.log(await tts.voices());

// Hint: the key can be used as voiceId
```

### **That's it!** Happy coding :)
npm package: @pbjlive/live.js
Description: PBJ Live Javascript SDK (Currently Docs only)
Author: pbjlive
Latest version: 0.1.3

# live.js
PBJ Live Javascript SDK (Currently Docs only)


## Usage
Import javascript file
```
<script src="https://js.pbj.live/v1/sdk.js"></script>
```

This script will expose a global `Live` class. Initiate the class with your organization api key:

```
const live = new Live("pk_....")
```

When the `Live` class is initiated you will be able to do several things:

- Render a PBJ Live stream to a HTML element
- Retrieve information from our APIs

## Elements

### Embed element
*Currently our recommended way to integrate with PBJ Live.*

In your html, create a `div` tag with your preferred naming, we use `live-element` in these examples. 

So in your html, add:
```html
<html>
  <body>
    <!--- Add Live element here ---!>
    <div id="live-element"></div>
    
    <script src="https://js.pbj.live/v1/sdk.js"></script>
    <script type="text/javascript">
      var live = new Live("<Your API Key>");
      
      // Create instance of the iframe embed
      var embedPlayer = live.elements.embed()
       
      // Mount the player to the div#live-element in our html
      embedPlayer.mount("#live-element")
    </script>
  </body>
</html>
```

In the background, this `embed()` method will create an iFrame that will injected into your html element, we also offer a lower level solution via the `live.elements.video()` method.



### Video Element
```
const episode = live.elements.video();
```

#### Mount to HTML object

Then mount this element to your HTML element:
```js
const videoElement = live.elements.video({
  episode: id
});

videoElement.mount("#live-video")
```

#### Start video
```
videoElement.start();
```

#### Stop video
```
videoElement.stop();
```

#### Remove video element
```
videoElement.dispose();
```

#### Change volume
```
videoElement.volume(0.5)
```

A number from 0 to 1

#### Open full screen programatically
```
videoElement.openFullscreen()
```

#### Close full screen programatically
```
videoElement.closeFullscreen()
```

#### Get episode schedule
```
live.episodes.schedule()
  .then((episodes) => {
    const = nextEpisode = episodes[0]
 })
```

## Get episodes for show
```
live.episodes.list({
  show: "..."
})
  .then(...)
```

## Get current organization
```
live.organizations.current()
```


```
live.episodes.schedule()
live.episodes.detail({ id })

live.shows.detail()
live.shows.list()

live.organizations.current()

live.users.login()
live.users.register()
```


## Event changes
```
live.events.on('episode-status-update', () => ...)
```


## Realtime sockets

### Subscribing
Sockets are added to the `Live` instance through the `socket` property, subscribing to a specific event can be done by using:
```js
live.sockets.subscribeToEvent(live.sockets.commandTypes.EPISODE_STATUS_UPDATE,(message)=>{
    console.log('EPISODE_STATUS_UPDATE', message)
})
```

### Get Episode Command Types
The different command types that are available can be found here:

```
 live.sockets.commandTypes
```
npm package: @pbkware/astro-main-menu
Description: Responsive Main Menu and Hamburger components for Astro
Author: Paul Klink
Latest version: 4.0.0

# Astro Main Menu

[![NPM version](https://img.shields.io/npm/v/@pbkware/astro-main-menu)](https://www.npmjs.com/package/@pbkware/astro-main-menu) [![License](https://img.shields.io/github/license/pbkware/astro-main-menu)](https://github.com/pbkware/astro-main-menu?tab=MIT-1-ov-file#readme)

Responsive Main Menu and Hamburger components for [Astro](https://astro.build)

## Install

```
npm install @pbkware/astro-main-menu
```

## Features

- 2 levels of menu items.
- Wide and narrow to support desktop and mobile.
- Configurable breakpoint to switch between wide and narrow.
- Menus specified by array of menu items passed as an attribute to MainMenu component.
- Easy formatting of menu CSS with settings object passed as an attribute to MainMenu and Hamburger components.
- Flexible formatting of menu CSS with access to scoped classes within menu HTML.
- Menu Item can also run JavaScript or TypeScript code (instead of navigating).
- Separate MainMenu and Hamburger components to provide flexibility in setting up navigation UI.
- Supports deactivating main menu when document is clicked outside of menu.
- Supports Astro View Transitions.

## Demo and More information

[https://pbkware.klink.au/astro-main-menu/](https://pbkware.klink.au/astro-main-menu/)

## Sponsored by

[Xilytix](https://xilytix.com)
npm package: @pbkware/js-utils
Description: Javascript utility types, constants and functions
Author: Paul Klink
Latest version: 0.9.1

# PBKware JS Utils

[![NPM version](https://img.shields.io/npm/v/@pbkware/js-utils)](https://www.npmjs.com/package/@pbkware/js-utils) [![License](https://img.shields.io/github/license/pbkware/js-utils)](https://github.com/pbkware/js-utils/blob/main/LICENSE)

Contains JavaScript utility types, constants and functions
npm package: @pbkware/ui-action
Description: Classes to process UI actions
Author: Paul Klink
Latest version: 0.9.4

# UI Action

[![NPM version](https://img.shields.io/npm/v/@pbkware/ui-action)](https://www.npmjs.com/package/@pbkware/ui-action) [![License](https://img.shields.io/github/license/pbkware/ui-action)](https://github.com/pbkware/ui-action/blob/main/LICENSE)

Classes that process actions from HTML controls.  More than one HTML control can be bound to an UiAction.
npm package: @pblead0508/conology-ui-library
Description: A reusable Vue 3 components library using Vuetify & storybook
Author: Pooja bhardwaj
Latest version: 1.0.17

# Vue 3 + TypeScript + Vite

This template should help get you started developing with Vue 3 and TypeScript in Vite. The template uses Vue 3 `<script setup>` SFCs, check out the [script setup docs](https://v3.vuejs.org/api/sfc-script-setup.html#sfc-script-setup) to learn more.

Learn more about the recommended Project Setup and IDE Support in the [Vue Docs TypeScript Guide](https://vuejs.org/guide/typescript/overview.html#project-setup).
npm package: @pbnjs/cli
Description: CLI for pbnj.sh - A minimal pastebin for code snippets
Author: Bhavnick Minhas
Latest version: 0.1.4

<div align="center">

![pbnj logo](../assets/pbnj_logo.png)

# @pbnjs/cli

[![npm version](https://img.shields.io/npm/v/@pbnjs/cli?color=cb3837)](https://www.npmjs.com/package/@pbnjs/cli)
[![npm downloads](https://img.shields.io/npm/dm/@pbnjs/cli?color=blue)](https://www.npmjs.com/package/@pbnjs/cli)
[![License](https://img.shields.io/github/license/bhavnicksm/pbnj)](../LICENSE)

_The official CLI for [pbnj](https://github.com/bhavnicksm/pbnj) - paste code from your terminal_

</div>

## Installation

```bash
npm install -g @pbnjs/cli
```

Or use without installing:

```bash
npx @pbnjs/cli myfile.py
```

## Quick Start

```bash
# Configure your pbnj instance
pbnj --init

# Show current configuration
pbnj --show-config

# Paste a file
pbnj script.py
# → https://pbnj.sh/crunchy-peanut-butter-toast (copied to clipboard)

# Pipe content
cat error.log | pbnj

# List your pastes
pbnj -l

# Update an existing paste
pbnj -u crunchy-peanut-butter-toast newfile.py

# Delete a paste
pbnj -d crunchy-peanut-butter-toast
```

## Setup

Configure your pbnj instance:

```bash
pbnj --init
```

This will prompt you for:
- **Host URL**: Your pbnj instance URL
- **Auth Key**: Your secret key for creating pastes

Configuration is saved to `~/.pbnj`.

Alternatively, use environment variables:

```bash
export PBNJ_HOST=https://your-instance.workers.dev
export PBNJ_AUTH_KEY=your-secret-key
```

## Commands

### Create a paste

```bash
# From a file
pbnj script.py

# From stdin
cat error.log | pbnj
echo "console.log('hello')" | pbnj -L javascript

# With custom filename
pbnj -f "app.js" - < code.txt
```

### Update a paste

```bash
# Update with new file content
pbnj -u <paste-id> newfile.py

# Update from stdin
cat updated.log | pbnj -u <paste-id>
```

### List pastes

```bash
# List recent pastes (default: 10)
pbnj -l

# List more pastes
pbnj -l 20
```

### Delete a paste

```bash
pbnj -d <paste-id>
```

## Options

| Option | Description |
|--------|-------------|
| `-L, --language <lang>` | Override automatic language detection |
| `-f, --filename <name>` | Set filename for the paste |
| `-u, --update <id>` | Update an existing paste |
| `-d, --delete <id>` | Delete a paste by ID |
| `-l, --list [n]` | List recent pastes (default: 10, or specify count) |
| `-n, --no-copy` | Don't copy URL to clipboard after creating paste |
| `-p, --private` | Create a private (unlisted) paste |
| `-s, --secret <key>` | Set a secret key for private paste |
| `-h, --help` | Show help |
| `-v, --version` | Show version |
| `--init` | Configure your pbnj instance |
| `--show-config` | Show current host URL configuration |

## Supported Languages

The CLI automatically detects language from file extensions:

- JavaScript (`.js`, `.jsx`)
- TypeScript (`.ts`, `.tsx`)
- Python (`.py`)
- Rust (`.rs`)
- Go (`.go`)
- Ruby (`.rb`)
- And 30+ more...

## License

MIT
npm package: @pbots/nrc
Description: A simple CLI for creating functional react components
Author: Parker Botsford
Latest version: 2.3.2

# `nrc`

Simple CLI to create a functional react component

<br>

## Quickstart

```bash
npm i -g @pbots/nrc
```

<br>

## Usage

```bash
nrc <component-name>
```

nrc looks for the `src/components` and `components` directories by default

<br>

#### Output:

```tree
./src/components/<component-name>
├──index.js
└──<component-name>.js
```

<br>

## Importing

The `index.js` file allows the component to be imported by its directory name.

### Example

1.  Create the component:

    ```bash
    nrc Button
    ```

2.  Import the component into another component:

    ```js
    // OtherComponent.js

    import Button from '../Button';
    ```

    Or if using **absolute imports**:

    ```js
    // OtherComponent.js

    import Button from 'components/Button';
    ```

<br>

## To specify a different directory, use `-d` or `--dir`

```bash
nrc <component-name> -d /path/to/dir
nrc <component-name> -dir /path/to/dir
```

#### Output:

```tree
./path/to/dir/<component-name>
├──index.js
└──<component-name>.js
```

<br>

## Using Typescript

```bash
nrc <component-name> -t
nrc <component-name> --typescript
```

Creates `.tsx` files instead of `.js`.

<br>

#### Output:

```tree
./src/components/<component-name>
├──index.tsx
└──<component-name>.tsx
```

<br>

## Using CSS modules

```bash
nrc <component-name> -m
nrc <component-name> --module
```

Creates a `<component-name>.module.css` file and imports it into `<component-name>.js`.

<br>

#### Output:

```tree
./src/components/<component-name>
├──index.js
├──<component-name>.js
└──<component-name>.module.css
```

<br>

## Example Usage

```bash
nrc Button -m -t
```

#### Output

```tsx
// Button.tsx

import styles from './Button.module.css';
import React from 'react';

const Button = () => {
    return (
        <div>
            <h1>Button</h1>
        </div>
    );
};

export default Button;
```

```tsx
// index.tsx
export { default } from './Button.tsx';
```

```css
/* Button.module.css */
/* This file is left blank so you can add your own styles */
```

Inspired by [joshwcomeau/new-component](https://github.com/joshwcomeau/new-component).
npm package: @pbr1111/vite-plugin-biome
Description: Vite plugin to run biome.js
Author: pbr1111
Latest version: 1.1.3

# @pbr1111/vite-plugin-biome

[![npm version](https://badge.fury.io/js/%40pbr1111%2Fvite-plugin-biome.svg)](https://badge.fury.io/js/%40pbr1111%2Fvite-plugin-biome)
![NPM Downloads](https://img.shields.io/npm/dm/%40pbr1111%2Fvite-plugin-biome)


This Vite plugin seamlessly integrates the Biome linter, formatter, and checker into your development workflow, providing lightning-fast code analysis and formatting directly within the build process.

## Features

- **Blazing-Fast Linting**: Experience significantly faster linting compared to traditional linters like ESLint.
- **Versatile Modes**: Choose between linting (lint), formatting (format), and checking (check) Biome to tailor the plugin to your needs.
- **Streamlined Configuration**: Define options for mode, path, applying fixes, and error handling for a customized setup.
- **Hot Reload Support**: The plugin automatically re-runs Biome when file changes occur during hot module replacement

## Installation

1. Install the plugin using npm/yarn/pnpm:
- npm: `npm install -D @pbr1111/vite-plugin-biome`
- yarn: `yarn add @pbr1111/vite-plugin-biome -D`
- pnpm: `pnpm add -D @pbr1111/vite-plugin-biome`

2. Add the plugin to your vite.config.js/ts file:
```ts
import { defineConfig } from 'vite';
import { biomePlugin } from '@pbr1111/vite-plugin-biome';

export default defineConfig({
  plugins: [biomePlugin()],
});
```

## Usage

By default, the plugin runs Biome in linting mode (lint) on your entire project. You can customize its behavior using options:

- `mode`: Specify the Biome mode (`lint`, `format`, or `check`). Defaults to `lint`.
- `path`: Define the path to the files or directories you want to process. Defaults to the current working directory (`.`).
- `applyFixes`: Set to `true` to apply Biome's formatting or fixing suggestions (depends on mode). Defaults to `false`.
- `errorOnWarnings`: Set to `true` to threat warnings as errors. Defaults to `false`.
- `failOnError`: Set to `true` to throw an error when Biome encounters issues. Defaults to `process.env.NODE_ENV === 'production'`.
- `useServer`: Set to `true` to reuse the LSP proxy server in each execution. Defaults to `false`.
- `verbose`: Set to `true` to print additional diagnostics and some diagnostics show more information. Defaults to `false`.
- `args`: Pass extra arguments to the command (https://biomejs.dev/reference/cli/).  Check Defaults to `''`.