open-index/open-npm huggingface dataset:
npm package: @jmscarpa/briefly
Description: A simple CLI to generate and publish product changelogs from git commits and send them to Discord
Author: João Mateus Scarpa
Latest version: 0.1.2

# Briefly

**briefly** is a simple CLI tool to generate and publish concise product changelogs from git commits.
It uses the OpenAI API to summarize commit logs into human-readable changelogs, and can publish them directly to Discord.

---

## ✨ Features

* Generate weekly product changelogs from git commit history.
* Summarize commits into clear, well-structured Markdown.
* Publish changelogs directly to a Discord channel (or thread) via webhook.
* Store API keys and defaults in a local `.briefly` config file inside each project.
* Works on macOS, Linux, and Windows (via Node.js / npm).

---

## 📦 Installation

```bash
npm install -g @jmscarpa/briefly
```

or use it without global install:

```bash
npx briefly <command>
```

Requirements:

* Node.js v18 or higher
* `git` and `jq` available in your system

---

## ⚙️ Setup

Run the setup command once in your project to store configuration (API key, webhook, defaults):

```bash
briefly setup
```

This will create a config file at:

* `<your-project>/.briefly`

The config file is a simple key=value format, for example:

```ini
OPENAI_API_KEY=sk-...
DISCORD_WEBHOOK=https://discord.com/api/webhooks/...
DEFAULT_MODEL=gpt-4o-mini
PROJECT_KIND=api
DEFAULT_ENV=staging
DEFAULT_APP_URL=https://staging.example.com
```

> 🔒 The file is created with restricted permissions (`chmod 600`) so only your user can read/write.

---

## 🚀 Usage

### Generate a changelog

```bash
briefly generate --date 2025-08-18
```

* Runs in the current git repository
* `--date`: optional; only include commits since this date (YYYY-MM-DD)
* `--out`: optional; output file (default: `briefly-summary.md`)

Example output saved to `briefly-summary.md`:

```markdown
# My Repo – Weekly Changelog

### Features
- Added new authentication flow
- Improved dashboard UI

### Fixes
- Fixed bug with user profile updates
```

---

### Publish a changelog to Discord

```bash
briefly publish briefly-summary.md --kind api
```

* `briefly-summary.md`: changelog file generated with `briefly generate`
* `--kind`: type of project (`api`, `frontend`, `backend`, etc.)
* `--thread-id`: optional; publish to an existing thread
* `--mention`: optional; mention a user or role (e.g. `<@&1234567890>`)

Example:

```bash
briefly publish briefly-summary.md --kind api --mention "<@&1386829090006503586>" --thread-id "123456789012345678"
```

---

## 🛠 Development

Clone this repo and link locally:

```bash
git clone https://github.com/your-user/briefly.git
cd briefly
npm link
```

Now you can run:

```bash
briefly setup
briefly generate
briefly publish briefly-summary.md --kind frontend
```

---

## 📄 License

MIT License © João Mateus Scarpa
npm package: @jmshal/back-off
Description: A simple backoff approach utility.
Author: Jacob Marshall
Latest version: 0.1.1

# @jmshal/back-off

A simple backoff approach utility.

## Example usage

```js
import { backOff } from '@jmshal/back-off';

function signJwt(digest) {
  const retry = backOff(1, 2, 4, 8, 16);
  while (true) {
    try {
      return await await keyVaultClient.sign(endpoint, kid, 'RS256', digest);
    } catch (err) {
      if (err.code === 'VaultOperationLimitReached') {
        // Azure Key Vault will throttle requests if there are considerable amount within a short
        // period of time. It may be worth notifying an error reporting system if this happens.
        await retry.wait();
      } else {
        throw err;
      }
    }
  }
}
```

## License

MIT ❤️
npm package: @jmshal/bugsnag-js-cloudflare-workers
Description: An un-official Bugsnag notifier for Cloudflare Workers.
Author: Jacob Marshall
Latest version: 1.0.0

# @jmshal/bugsnag-js-cloudflare-workers

An un-official Bugsnag notifier for Cloudflare Workers.

The notifier is injected into the `FetchEvent` object, and can be used to leave breadcrumbs or send error reports. Because of the nature of Cloudflare Workers, the response will wait until any Bugsnag errors have been reported. See the example below for more details.

## Example

```js
import bugsnag from '@jmshal/bugsnag-js-cloudflare-workers';

const bugsnagClient = bugsnag('API-KEY-HERE');
const { addEventListener } = bugsnagClient.getPlugin('cloudflare-workers');

addEventListener('fetch', (event) => {
  event.respondWith(handle());
});

async function handle(event) {
  const url = new URL(event.request.url);

  if (url.searchParams.has('leave-breadcrumb')) {
    // eg. ?leave-breadcrumb=Hello%20World
    event.bugsnag.leaveBreadcrumb(url.searchParams.get('leave-breadcrumb'));
  }

  switch (url.pathname) {
    case '/uncaught-error': {
      throw new Error('Uh oh! This error was not caught!');
    }
    case '/notify-error': {
      try {
        throw new Error('Catch me if you can!');
      } catch (err) {
        event.bugsnag.notify(err);
      }
      return new Response('There was an error, but I recovered.');
    }
    case '/': {
      return new Response('Hello World!');
    }
    default: {
      return new Response('Not Found', { status: 404 });
    }
  }
}
```

## License

MIT
npm package: @jmshal/bugsnag-js-plugin-azure-functions
Description: @bugsnag/js plugin for Azure Function apps
Author: Jacob Marshall
Latest version: 0.1.1

# @jmshal/bugsnag-js-plugin-azure-functions

@bugsnag/js plugin for Azure Function apps.

## Installation

```
$ npm i --save @bugsnag/js @jmshal/bugsnag-js-plugin-azure-functions
```

## Basic usage

```js
const bugsnag = require('@bugsnag/js'); // or "@bugsnag/node"
const azureFunctionsPlugin = require('@jmshal/bugsnag-js-plugin-azure-functions');
const { validateJWT, doSomethingBuggy } = require('./my-function-utilities');

const bugsnagClient = bugsnag('API-KEY');
bugsnagClient.use(azureFunctionsPlugin);

const { wrapFunction } = bugsnagClient.getPlugin('azure-functions');

module.exports = wrapFunction(async (context, req) => {
  // The validateJWT function can also leave breadcrumbs because it has access to
  // the underlying Bugsnag client (eg. context.bugsnag.leaveBreadcrumb).
  const claims = await validateJWT(context);

  context.bugsnag.user = {
    id: claims.sub,
    email: claims.email,
  };

  await doSomethingBuggy(); // Throws and automatically gets reported
});
```

## License

MIT ❤️
npm package: @jmshal/cloudflare-workers-router
Description: A Cloudflare Workers router, based on [`find-my-way`](https://github.com/delvedor/find-my-way).
Author: Jacob Marshall
Latest version: 1.0.0

# @jmshal/cloudflare-workers-router

A Cloudflare Workers router, based on [`find-my-way`](https://github.com/delvedor/find-my-way).

Until there's a proper readme, here's a little example of how to use this package.

```ts
import { Router } from '@jmshal/cloudflare-workers-router';

const router = new Router();

// GET /
router.get('/', async (request: Request) => {
  return new Response('Hello World');
});

// GET /
// accept-version: 2.x
router.get('/', { version: '2.0.0' }, async (request: Request) => {
  return new Response('Hello World v2');
});

// GET /hello/world
router.get('/hello/:message', async (request: Request, { message }) => {
  return new Response(`Hello, ${message}!`);
});

// POST /submit
// ...
// {"message":"world"}
router.post('/submit', async (request: Request) => {
  const body = await request.json();
  return new Response(`Hello, ${body.message}!`);
});

router.listen();
```
npm package: @jmshal/pfx
Description: This module is simply a wrapper around `openssl`.
Author: Jacob Marshall
Latest version: 0.1.0

# @jmshal/pfx

This module is simply a wrapper around `openssl`. 

It was created for one reason; to output a `.pfx` file containing the cert and key provided by `greenlock` (a Let's Encrypt module), so it could be used for an Azure Function App backed by Key Vault.

I intend to add some more helpers, like extracting the cert and key from a `.pfx` file. This is handy when you need to add a password to a pfx that is stored in Azure Key Vault (when purchasing an SSL cert via their Portal).

## Example usage

```js
import { create } from '@jmshal/pfx';

const pfx = await create({
  cert: `-----BEGIN CERTIFICATE-----\nMIIF4jCCBMqgAwIBA...`,
  privateKey: `-----BEGIN RSA PRIVATE KEY-----\nMIIEowI...`,
  password: 'p@ssw0rd', // optional
});

console.log(pfx.toString('base64')); // MIIMIQIBAzCCC+c...
```
npm package: @jmshal/react-inline-svg
Description: A simple and lightweight React component for loading SVG files so they can be styled with CSS.
Author: Jacob Marshall
Latest version: 4.0.0-rc.1

# @jmshal/react-inline-svg

A simple and lightweight React component for loading SVG files so they can be styled with CSS.

## Installation

```sh
$ npm install --save @jmshal/react-inline-svg
```

## Basic usage

```jsx
import { InlineSVG } from '@jmshal/react-inline-svg';

// ...

<InlineSVG
  src={require('./path/to/icon.svg')}
  className={css.Example}
/>
```

## Preloading

```js
import { preload } from '@jmshal/react-inline-svg';

preload('./path/to/icon.svg')
  .then(() => console.log('icon.svg has been preloaded'));
```

## License

MIT ❤️
npm package: @jmsheff/react-scripts
Description: Configuration and scripts for Create React App.
Latest version: 2.1.9

# react-scripts

This package includes scripts and configuration used by [Create React App](https://github.com/facebook/create-react-app).<br>
Please refer to its documentation:

- [Getting Started](https://facebook.github.io/create-react-app/docs/getting-started) – How to create a new app.
- [User Guide](https://facebook.github.io/create-react-app/) – How to develop apps bootstrapped with Create React App.
npm package: @jmsjtu/aria-reflection
Description: ARIA element reflection polyfill for strings
Latest version: 0.0.0-demo

# @jmsjtu/aria-reflection

Polyfill for [ARIA string reflection](https://wicg.github.io/aom/spec/aria-reflection.html) on Elements.
This is part of the [Accessibility Object Model](https://wicg.github.io/aom/explainer.html) (AOM).

For example:

```js
element.setAttribute('aria-pressed', 'true');
console.log(element.ariaPressed); // true
element.ariaPressed = false;
console.log(element.getAttribute('aria-pressed')); // false
```

Note that the attribute `aria-pressed` is reflected to the property `ariaPressed`, and vice versa.

## Usage

```shell
npm install @jmsjtu/aria-reflection
```

```js
import { applyAriaReflection } from '@jmsjtu/aria-reflection';

applyAriaReflection();
```

The polyfill is applied as soon as the function is executed.

Optionally, you can pass in a custom prototype:

```js
applyAriaReflection(MyCustomElement.prototype);
```

By default, the polyfill is applied to the global `Element.prototype`.

## Implementation

The polyfill patches these [standard](https://w3c.github.io/aria/#idl-interface) properties:

-   ariaAtomic
-   ariaAutoComplete
-   ariaBusy
-   ariaChecked
-   ariaColCount
-   ariaColIndex
-   ariaColSpan
-   ariaCurrent
-   ariaDisabled
-   ariaExpanded
-   ariaHasPopup
-   ariaHidden
-   ariaInvalid
-   ariaKeyShortcuts
-   ariaLabel
-   ariaLevel
-   ariaLive
-   ariaModal
-   ariaMultiLine
-   ariaMultiSelectable
-   ariaOrientation
-   ariaPlaceholder
-   ariaPosInSet
-   ariaPressed
-   ariaReadOnly
-   ariaRelevant
-   ariaRequired
-   ariaRoleDescription
-   ariaRowCount
-   ariaRowIndex
-   ariaRowSpan
-   ariaSelected
-   ariaSetSize
-   ariaSort
-   ariaValueMax
-   ariaValueMin
-   ariaValueNow
-   ariaValueText
-   role

As well as these [currently non-standard](https://github.com/w3c/aria/issues/1732) properties:

-   ariaActiveDescendant
-   ariaControls
-   ariaDescribedBy
-   ariaDetails
-   ariaErrorMessage
-   ariaFlowTo
-   ariaLabelledBy
-   ariaOwns

To determine which browsers already support ARIA reflection, see [this test](https://bl.ocks.org/nolanlawson/raw/66448a53df90680a81bda78ff8486014/).
npm package: @jmsjtu/babel-plugin-component
Description: Babel plugin to transform a LWC module
Latest version: 0.0.0-demo

# @jmsjtu/babel-plugin-component

This babel plugin does the following transform:

-   Global decorator transform:
    -   Transform `@api` decorator to `publicProperties` and `publicMethods` static properties.
    -   Transform `@wire` decorator to `wire` static property.
    -   Transform `@track` decorator to `track` static property.
-   LWC component class sugar syntax:
    -   Check for misspelled lifecycle hooks.
    -   Import and inject `render` from a collocated template if a component class doesn't already implement a `render` method.
-   Optimization:
    -   If the compiler inject the default template a component, it will also wire the template style to the component.
npm package: @jmsjtu/compiler
Description: LWC compiler
Latest version: 0.0.0-demo

# LWC Compiler

@jmsjtu/compiler is an open source project that enables developers to take full control of processing a single Lightning Web Components module for runtime consumption.

## Installation

```sh
yarn add --dev @jmsjtu/compiler
```

## APIs

### `transform`

Transform the content of individual file.

```js
import { transform } from '@jmsjtu/compiler';

const source = `
    import { LightningElement } from 'lwc';
    export default class App extends LightningElement {}
`;

const filename = 'app.js';

const options = {
    namespace: 'c',
    name: 'app',
};

const { code } = await transform(source, filename, options);
```

**Parameters:**

-   `source` (string, required) - the source to be transformed can be the content of javascript, HTML, CSS.
-   `filename` (string, required) - the source filename with extension.
-   `options` (object, required) - the transformation options. The `name` and the `namespace` of the component is a minimum required for transformation.

**Return**

-   `code` (string) - the compiled source code.
-   `map` (object) - the generated source map.
-   `warnings` (array, optional) - the array of diagnostic warnings, if any.

### `version`

```js
import { version } from '@jmsjtu/compiler';

console.log(version);
```

**Return**

-   `version` (string) - the current version of the compiler ex: `0.25.1`.
npm package: @jmsjtu/engine-core
Description: Core LWC engine APIs.
Latest version: 0.0.0-demo

# @jmsjtu/engine-core

This package contains the core logic shared by different runtime environments. Examples of this
include the rendering engine and the reactivity mechanism. Since this package only provides
internal APIs for building custom runtimes, it should never be consumed directly in an
application.

Usage of internal APIs are prevented by the compiler and are therefore not documented here.

## Supported APIs

This package supports the following APIs.

### @api

This decorator is used to mark the public fields and the public methods of an LWC component.

```js
import { LightningElement, api } from 'lwc';

class LightningHello extends LightningElement {
    @api
    hello = 'default hello';
}
```

### @track

This decorator should be used on private fields to track object mutations.

```js
import { LightningElement, api, track } from 'lwc';

class LightningHello extends LightningElement {
    @api
    get name() {
        return name.raw;
    }
    set name(value) {
        name.normalized = normalize(value);
    }

    @track
    name = {
        raw: 'Web components ',
        normalized: 'Web Components',
    };
}
```

### @wire

This decorator should be used to wire fields and methods to a wire adapter.

```js
import { LightningElement, wire } from 'lwc';
import { getRecord } from 'recordDataService';

export default class Test extends LightningElement {
    @wire(getRecord, { id: 1 })
    recordData;
}
```

### createContextProvider()

This function creates a context provider, given a wire adapter constructor.

### LightningElement

This class should be extended to create an LWC constructor.

```js
import { LightningElement } from 'lwc';

class LightningHello extends LightningElement {
    // component implementation
}
```

## Experimental APIs

Experimental APIs are subject to change, may be removed at any time, and should be used at your
own risk!

### getComponentDef()

This experimental API provides access to internal component metadata.

### isComponentConstructor()

This experimental API enables the identification of LWC constructors.

### readonly()

This experimental API enables the creation of a reactive readonly membrane around any object
value.

### register()

This experimental API enables the registration of 'services' in LWC by exposing hooks into the
component life-cycle.

### setHooks()

This experimental API allows setting overridable hooks with an application specific implementation.

List of overridable hooks:

1. `sanitizeHtmlContent`, see [sanitizeHtmlContent](#sanitizeHtmlContent).

### sanitizeAttribute()

This experimental API enables the sanitization of HTML attribute values by external services.

### sanitizeHtmlContent()

This experimental API enables the sanitization of HTML content by external services. The `lwc:inner-html` binding relies on this hook. This hook must be overridden (see [setHooks](#setHooks) ) as the default implementation is to throw an error.

### unwrap()

This experimental API enables the removal of an object's observable membrane proxy wrapper.
npm package: @jmsjtu/engine-dom
Description: Renders LWC components in a DOM environment.
Latest version: 0.0.0-demo

# @jmsjtu/engine-dom

This package can be used to render LWC components as DOM elements in a DOM environment.

## Supported APIs

This package supports the following APIs.

### createElement()

This function creates an LWC component, given a tag name and an LWC constructor.

```js
import { createElement } from 'lwc';
import LightningHello from 'lightning/hello';

const element = createElement('lightning-hello', { is: LightningHello });

document.body.appendChild(element);
```

## Experimental APIs

Experimental APIs are subject to change, may be removed at any time, and should be used at your
own risk!

### getComponentConstructor()

This experimental API provides access to the component constructor, given an `HTMLElement`.

### isNodeFromTemplate()

This experimental API enables the detection of whether a node was rendered from an LWC template.

## Deprecated APIs

### buildCustomElementConstructor() (deprecated as of v1.3.11)

This function can build a Web Component class that can be registered as a new element via
`customElements.define()`, given an LWC constructor.

Deprecated in favor of using the `CustomElementConstructor` property of an LWC constructor.

```js
import { LightningElement } from 'lwc';

class LightningHello extends LightningElement {}

// Don't do this.
customElements.define('lightning-hello', buildCustomElementConstructor(LightningHello));

// Do this instead.
customElements.define('lightning-hello', LightningHello.CustomElementConstructor);
```
npm package: @jmsjtu/engine-server
Description: Renders LWC components in a server environment.
Latest version: 0.0.0-demo

# @jmsjtu/engine-server

WARNING: This is an experimental package. It is subject to change, may be removed at any time,
and should be used at your own risk!

This package can be used to render LWC components as strings in a server environment.

## Supported APIs

This package supports the following APIs.

### renderComponent()

This function renders a string-representation of a serialized component tree, given a tag name
and an LWC constructor. The output format itself is aligned with the [current leading
proposal][explainer], but is subject to change.

```js
import { renderComponent } from 'lwc';
import LightningHello from 'lightning/hello';

const componentProps = {};
const serialized = renderComponent('lightning-hello', LightningHello, componentProps);
```

[explainer]: https://github.com/mfreed7/declarative-shadow-dom/blob/master/README.md
npm package: @jmsjtu/features
Description: LWC Features Flags
Latest version: 0.0.0-demo

# @jmsjtu/features

Runtime flags can be enabled or disabled by setting a boolean value for that
flag in `globalThis.lwcRuntimeFlags`, e.g.:

```js
lwcRuntimeFlags.ENABLE_SOME_FEATURE = true;
```

If the flag is not explicitly
set, the feature is disabled by default. The `lwcRuntimeFlags` object
must appear before the engine is initialized and should be defined at the
application layer.

Internally, LWC will reference runtime flags like so:

```js
if (lwcRuntimeFlags.ENABLE_SOME_FEATURE) {
    // etc.
}
```

This makes it possible for consumers to replace these flags at compile time, using something like [Rollup's `@rollup/plugin-replace`](https://www.npmjs.com/package/@rollup/plugin-replace) or [ESBuild's `define`](https://esbuild.github.io/api/#define).

Note that `@jmsjtu/features` is an internal package used by LWC and (most likely) should not be directly used by consumers.
npm package: @jmsjtu/style-compiler
Description: Transform style sheet to be consumed by the LWC engine
Latest version: 0.0.0-demo

# @jmsjtu/style-compiler

Transform style sheet to be consumed by the LWC engine.

## Features

-   Shadow DOM style scoping:
    -   transform `:host` pseudo-class selectors
    -   scope all the other selectors using CSS attribute selectors
-   Custom Properties: inline replacement of `var()` CSS function
-   Right-to-left: transform the `:dir` pseudo class selector to `[dir]` attribute selectors
-   CSS import: resolve imports via static ES module imports

## Installation

```sh
yarn add --dev @jmsjtu/style-compiler
```

## Usage

```js
const compile = require('@jmsjtu/style-compiler');

const source = `
    :host {
        opacity: 0.4;
    }

    span {
        text-transform: uppercase;
    }
`;

const { code } = compile(source, 'example.css');
```

### API

#### `compile(source, id, options)`

**Options:**

-   `source` (string, required) - the css source file to compiler
-   `id` (string, required) - the css source file path, used by the compiler to produce errors with the file name
-   `options` (object, optional)
    -   `customProperties` (object, optional)
        -   `resolverModule` (boolean, optional) - module name for the custom properties resolve
    -   `scoped` (boolean, optional) - true if the styles are scoped (via Light DOM style scoping)
    -   `disableSyntheticShadowSupport` (boolean, optional) - true if synthetic shadow DOM support is not needed, which can result in smaller output

**Return:**

-   `code` - the generated code

Note: The LWC style compiler doesn't preserve the authored format, and always produce compressed code.

## Selector scoping caveats

-   No support for [`::slotted`](https://drafts.csswg.org/css-scoping/#slotted-pseudo) pseudo-element.
-   No support for [`>>>`](https://drafts.csswg.org/css-scoping/#deep-combinator) deep combinator (spec still under consideration: [issue](https://github.com/w3c/webcomponents/issues/78)).
-   No support for [`:host-context`](https://drafts.csswg.org/css-scoping/#selectordef-host-context) pseudo-selector (browser vendors are not able to agree: [webkit](https://bugs.webkit.org/show_bug.cgi?id=160038), [gecko](https://bugzilla.mozilla.org/show_bug.cgi?id=1082060))
-   This transform duplicates the `:host` selector to able to use the generated style in both the synthetic and native shadow DOM. The duplication is necessary to support the functional form of `:host()`, `:host(.foo, .bar) {}` needs to get transformed into `.foo[x-btn-host], .bar[x-btn-host] {}` to work in the synthetic shadow DOM.
-   Scoped CSS has a non-negligeable performance impact:
    -   Each selector chain is scoped and each compound expression passed to the `:host()` need to be spread into multiple selectors. This transformation greatly increases the overall size and complexity of the generated CSS, leading to more bits on the wire, longer parsing time and longer style recalculation.
    -   In order to ensure CSS encapsulation, each element needs to add an extra attribute. This increases the actual rendering time.
npm package: @jmsjtu/synthetic-shadow
Description: Synthetic Shadow Root for LWC
Latest version: 0.0.0-demo

# Synthetic Shadow Root

## Summary

This is a polyfill for ShadowRoot that was tailor-made for LWC in order to meet the performance goals of the Lightning Platform. This doesn't mean that it cannot be used with any other framework, but we took shortcuts and made compromises that might not align well with other frameworks.

## Compromises

-   Default content for `<slot>` elements is always empty.
-   `slotchange` is only available directly on the `<slot>` (it doesn't bubble as in the case of the native implementation). This restriction is in place because implementing `slotchange` requires using `MutationObserver` which is expensive at runtime. By only supporting `slotchange` event applied directly on the `<slot>` element, the LWC engine receives a clear signal that the component author is interested in listening to this event. This avoids spending unnecessary CPU time when the `slotchange` event is never consumed.
-   If you use `MutationObserver` to watch changes in a DOM tree, disconnect it or you will cause a memory leak. Note that a component can observe mutations only in its own template. It can't observe mutations within the shadow tree of other custom elements.
npm package: @jmsjtu/wire-service
Description: @wire service
Latest version: 0.0.0-demo

# Wire Service

This code is the implementation of the Lightning Web Component wire service. The wire service enables declarative binding of data providers called _wire adapters_ to a Lightning web component using the `@wire` decorator. It fulfills the goals of the [data service proposal](https://github.com/salesforce/lwc-rfcs/blob/master/text/0000-data-service.md).

## Summary

Wire adapters simply provide data. A wire adapter doesn't know anything about the components that it provides data to.

In a component, declare its data needs by using the `@wire` decorator to connect (or wire) it to a wire adapter. In this example, the component is wired to the `getBook` wire adapter. This declarative technique makes component code easy to read and reason about.

```js
// bookItem.js
import { LightningElement } from 'lwc';

export default class WireExample extends {
    @api bookId;

    @wire(getBook, { id: '$bookId'})
    book;
}
```

Wire adapters are part of LWC's reactivity system. An `@wire` takes the name of a wire adapter and an optional configuration object, which is specific to the wire adapter. You can use a `$` to mark the property of a configuration object as reactive. When a reactive property’s value changes, the wire adapter's `update` method executes with the new value. When the wire adapter provisions new data, the component rerenders if necessary.

```js
// wire-adapter.js
import { bookEndpoint } from './server';

export class getBook {
    connected = false;
    bookId;

    constructor(dataCallback) {
        this.dataCallback = dataCallback;
    }

    connect() {
        this.connected = true;
        this.provideBookWithId(this.bookId);
    }

    disconnect() {
        this.connected = false;
    }

    update(config) {
        if (this.bookId !== config.id) {
            this.bookId = config.id;
            this.provideBookWithId(this.bookId);
        }
    }

    providBookWithId(id) {
        if (this.connected && this.bookId !== undefined) {
            const book = bookEndpoint.getById(id);

            if (book) {
                this.dataCallback(Object.assign({}, book));
            } else {
                this.dataCallback(null);
            }
        }
    }
}
```

## Syntax

For complete information about syntax, see [lwc.dev/guide/wire_adapter](https://lwc.dev/guide/wire_adapter#wire-adapters).

## Implementation Example

The RCast App is a PWA podcast player written with Lightning Web Components.

https://github.com/pmdartus/rcast
npm package: @jmsoffredi/ms-common
Description: AWS Serverless microservice common module
Author: Marcelo Soffredi
Latest version: 0.2.15

# AWS Serverless Microservice common module

This module provides basic common functions and types for an AWS Serverless Microservice project including Cloudformation base template to deploy common AWS services like Cognito and EventBridge.

## Installing the package

To install this module into your project you can do:

With npm:

```
$ npm install @jmsoffredi/ms-common
```

With yarn:

```
$ yarn add @jmsoffredi/ms-common
```

## Building a new version of the module

In order to build a new version of the module you need to commit your changes to your desired branch as usual ensuring you increment your npm module version every time you intent to publish to the npm repository ([npm-version](https://docs.npmjs.com/cli/v7/commands/npm-version))

After pushing your changes to the repository, you have to create a Pull Request (PR) from your branch to main. After accepting the PR, GitHub will publish your new module version to the npm repository using a GitHub action.
npm package: @jmsoffredi/ms-fast-api
Description: Npm module over ms-common to fast-build simple read-intensive APIs using the AWS Serverless approach
Author: Marcelo Soffredi
Latest version: 0.1.4

# AWS Serverless Microservice Fast API module

This module provides resources for fast-building read-intensive APIs using `ms-common` module. This implements AWS Serverless Serverless Microservice APIs which uses Cloudformation base template to deploy common AWS services when needed.

## Installing the package

To install this module into your project you can do:

With npm:

```
$ npm install @jmsoffredi/ms-fast-api
```

With yarn:

```
$ yarn add @jmsoffredi/ms-fast-api
```

## Building a new version of the module

In order to build a new version of the module you need to commit your changes to your desired branch as usual ensuring you increment your npm module version every time you intent to publish to the npm repository ([npm-version](https://docs.npmjs.com/cli/v7/commands/npm-version))

After pushing your changes to the repository, you have to create a Pull Request (PR) from your branch to main. After accepting the PR, GitHub will publish your new module version to the npm repository using a GitHub action.