open-index/open-npm huggingface dataset:
npm package: @hiveio/hivescript
Description: An open standard for Hive based apps.
Latest version: 1.3.4

# Hivescript

An open standard for Hive based apps.

- `Apps` - URL format and canonical linking schemes
- `BadActors` - accounts mischiefs or phishing attempts
- `BadDomains` - phishing domains

# How to use this package

`yarn add @hiveio/hivescript`

## Canonical linking

On Hive, content is stored in blockchain and same information is accessible via different websites and services built on Hive. Canonical linking to origin of post is important for entire ecosystem to thrive. 

Here is an example on how to do it in few simple lines: 

```
  import apps from "@hiveio/hivescript/apps.json";

  let scheme = `${default_domain}/{category}/@{username}/{permlink}`;

  // get app information from post json
  const app = post.json_metadata.app;

  if (app) {
    const identifier = app.split("/")[0];

    if (apps[identifier]) {
      scheme = apps[identifier].url_scheme;
    }
  }
  // return proper canonical link for post
  const canonicalLink = scheme
    .replace("{category}", entry.category)
    .replace("{username}", entry.author)
    .replace("{permlink}", entry.permlink);
    
```

## Bad actors

Bad actors, list of account that is mostly created with intention to take advantage of user mistype. Sometimes simple misspell can direct funds into wrong accounts, this list contain those reported accounts.

This section could be part of wallet page in your Dapp where user enters account name to transfer funds to.

```
  import badActors from '@hiveio/hivescript/bad-actors.json';

  if (badActors.includes(to_account)) {
    console.warn("Use caution sending to this account. Please double check your spelling for possible phishing.");
  }

```


## Bad domains

Phishing domains, list of phishing domains, we recommend Dapp/frontend developers check external link clicks and warn users about potential phishing domains.

This section could be part of content rendering or external link clicking event listener in your web/mobile/desktop apps.

```
  import badDomains from '@hiveio/hivescript/bad-domains.json';

  const regex = /^(?:https?:\/\/)?(?:[^@\/\n]+@)?(?:www\.)?([^:\/?\n]+)/

  external_link = external_link.match(regex)[1]

  if (badDomains.includes(external_link)) {
    console.warn("Security alert! Site ahead contains malware / Suspected phishing page.");
  }

```

# Contributors

[Hive community](https://hive.io)
npm package: @hiveio/honeycomb-react
Description: React components for Hive Blockchain applications
Author: KKocot
Latest version: 1.0.0

# Honeycomb React

[![npm version](https://img.shields.io/npm/v/@hiveio/honeycomb-react)](https://www.npmjs.com/package/@hiveio/honeycomb-react) [![license](https://img.shields.io/npm/l/@hiveio/honeycomb-react)](https://github.com/KKocot/honeycomb/blob/main/LICENSE)

React components and hooks for Hive Blockchain applications. Read-only (passive) - displays blockchain data without auth or transaction signing. SSR-compatible, works with Next.js App Router.

[Documentation](https://honeycomb.bard-dev.com/docs/react/introduction) | [GitHub](https://github.com/KKocot/honeycomb) | [npm](https://www.npmjs.com/package/@hiveio/honeycomb-react)

## Installation

```bash
npm install @hiveio/honeycomb-react
# or
pnpm add @hiveio/honeycomb-react
# or
yarn add @hiveio/honeycomb-react
# or
bun add @hiveio/honeycomb-react
```

### Peer Dependencies

```bash
npm install @hiveio/wax @radix-ui/react-popover react react-dom
# or
pnpm add @hiveio/wax @radix-ui/react-popover react react-dom
# or
yarn add @hiveio/wax @radix-ui/react-popover react react-dom
# or
bun add @hiveio/wax @radix-ui/react-popover react react-dom
```

`@radix-ui/react-popover` is only required if you use the `ApiTracker` component.

### Styles

Import the bundled stylesheet in your entry file (e.g. `main.tsx`, `layout.tsx`):

```tsx
import "@hiveio/honeycomb-react/styles.css";
```

Includes CSS variables, component styles, Tailwind utilities, and theme tokens.

## Quick Start

```tsx
// app/layout.tsx (Next.js App Router)
import { HiveProvider } from "@hiveio/honeycomb-react";
import "@hiveio/honeycomb-react/styles.css";

export default function RootLayout({ children }: { children: React.ReactNode }) {
  return (
    <html>
      <body>
        <HiveProvider>{children}</HiveProvider>
      </body>
    </html>
  );
}
```

```tsx
// app/page.tsx
"use client";

import { useHive, HiveAvatar, UserCard } from "@hiveio/honeycomb-react";

export default function Page() {
  const { chain, is_loading, error, status } = useHive();

  if (is_loading) return <div>Connecting to Hive...</div>;
  if (error) return <div>Error: {error}</div>;

  return (
    <div>
      <p>Status: {status}</p>
      <HiveAvatar username="blocktrades" size="lg" />
      <UserCard username="blocktrades" variant="expanded" />
    </div>
  );
}
```

## Documentation

Full API reference, live examples, and guides:

**[honeycomb.bard-dev.com/docs/react/introduction](https://honeycomb.bard-dev.com/docs/react/introduction)**

- HiveProvider configuration
- Hooks API
- Components (HiveAvatar, UserCard, BalanceCard, ApiTracker, HiveManabar, HivePostCard, HivePostList, HiveContentRenderer)
- SSR compatibility
- TypeScript types

## License

MIT
npm package: @hiveio/honeycomb-vue
Description: Vue 3 composables for Hive Blockchain applications
Author: KKocot
Latest version: 1.0.0

# Honeycomb Vue

[![npm version](https://img.shields.io/npm/v/@hiveio/honeycomb-vue)](https://www.npmjs.com/package/@hiveio/honeycomb-vue) [![license](https://img.shields.io/npm/l/@hiveio/honeycomb-vue)](https://github.com/KKocot/honeycomb/blob/main/LICENSE)

Vue 3 composables and components for Hive Blockchain applications. Read-only (passive) - displays blockchain data without auth or transaction signing.

[Documentation](https://honeycomb.bard-dev.com/docs/vue/introduction) | [GitHub](https://github.com/KKocot/honeycomb) | [npm](https://www.npmjs.com/package/@hiveio/honeycomb-vue)

## Installation

```bash
npm install @hiveio/honeycomb-vue
# or
pnpm add @hiveio/honeycomb-vue
# or
yarn add @hiveio/honeycomb-vue
# or
bun add @hiveio/honeycomb-vue
```

### Peer Dependencies

```bash
npm install @hiveio/wax radix-vue vue
# or
pnpm add @hiveio/wax radix-vue vue
# or
yarn add @hiveio/wax radix-vue vue
# or
bun add @hiveio/wax radix-vue vue
```

`radix-vue` is only required if you use the `ApiTracker` component (optional peer dependency).

### Styles

Import the bundled stylesheet in your entry file (e.g. `main.ts`):

```ts
import "@hiveio/honeycomb-vue/styles.css";
```

Includes CSS variables, component styles, Tailwind utilities, and theme tokens.

## Quick Start

```vue
<!-- App.vue -->
<script setup lang="ts">
import { HiveProvider } from "@hiveio/honeycomb-vue";
import "@hiveio/honeycomb-vue/styles.css";
</script>

<template>
  <HiveProvider>
    <router-view />
  </HiveProvider>
</template>
```

```vue
<!-- Page.vue -->
<script setup lang="ts">
import { useHive, HiveAvatar, UserCard } from "@hiveio/honeycomb-vue";

const { chain, isLoading, error, status } = useHive();
</script>

<template>
  <div v-if="isLoading">Connecting to Hive...</div>
  <div v-else-if="error">Error: {{ error }}</div>
  <div v-else>
    <p>Status: {{ status }}</p>
    <HiveAvatar username="blocktrades" size="lg" />
    <UserCard username="blocktrades" variant="expanded" />
  </div>
</template>
```

## Documentation

Full API reference, live examples, and guides:

**[honeycomb.bard-dev.com/docs/vue/introduction](https://honeycomb.bard-dev.com/docs/vue/introduction)**

- HiveProvider configuration
- Composables API
- Components (HiveAvatar, UserCard, BalanceCard, ApiTracker, HiveManabar, HivePostCard, HivePostList, HiveContentRenderer)
- SSR compatibility
- TypeScript types

## License

MIT
npm package: @hiveio/keychain
Description: This module makes it easy to add Keychain support within the browser. It also includes helpful functions to check whether Keychain was used before.
Author: therealwolf
Latest version: 1.0.7

This module makes it easy to add Keychain support within the browser. It also includes helpful functions to check whether Keychain was used before.

```
import {keychain, isKeychainInstalled, hasKeychainBeenUsed} from '@hiveio/keychain'

const {success, msg, cancel, notInstalled, notActive} = await keychain(window, 'requestTransfer', 'test', 'therealwolf', 5,  test memo', 'HIVE')

// All good
if(success) {
 // do your thing
}
// User didn't cancel, so something must have happened
else if(!cancel) {
  if(notActive) {
    // alert('Please allow Keychain to access this website')
  } else if(notInstalled) {
    // alert('Please install Keychain')
  } else {
    // error happened - check msg
  }
}
```
npm package: @hivekit/client-js
Description: The browser/node client for the Hivekit platform and server
Author: Hivekit Inc.
Latest version: 1.11.1

# Hivekit Client for Browsers/NodeJS

The javascript/node client SDK for **[Hivekit](https://hivekit.io)**

Please find the full documentation for the client library at [https://hivekit.io/docs/js-client-sdk/client/](https://hivekit.io/docs/js-client-sdk/client/)

## Installation
Install via yarn or npm
```sh
npm install @hivekit/client-js --save-dev

yarn add @hivekit/client-js
```

## Basic Usage Example
```js
import HivekitClient from '@hivekit/client-js'

// Use a token issued via the Hivekit account interface
// or sign your own with a Hivekit provided secret.
// import jwt from 'jsonwebtoken'
// const token = jwt.sign({ sub: 'username' }, 'CHANGE_ME')

const client = new HivekitClient();

// Let's track the client's connection status below. If everything
// goes well, we should see:
// - connecting
// - connected
// - authenticated (that's when the client is ready to use)
client.on('connectionStatusChanged', () => {
    console.log(client.connectionStatus)
})
await client.connect('wss://api.hivekit.io/v1/ws');
await client.authenticate(token);

// A realm is a space within which something happens, e.g.
// a city or a factory hall. If we don't have one yet, we need
// to create it first using: 
await client.realm.create('test-realm'); // !!!this will throw an error if the realm already exists

// Most concepts within Hivekit exist within the scope
// of a realm
const realm = await client.realm.get('test-realm');

// Objects can represent vehicles, people, machines or
// other datasources. Let's create one:
await realm.object.create('rider/12', {
    label: 'Delivery Rider 12',
    location: {
        latitude: 52.5241175089,
        longitude: 13.3975679517
    },
    data: {
        charge: 0.6
    }
});

// This will return the object's data, e.g.:
// {
//     label: 'Delivery Rider 12',
//     location: {
//         coordinateSystem: '',
//         longitude: 13.3975679517,
//         latitude: 52.5241175089,
//         accuracy: 0,
//         speed: 0,
//         heading: 0,
//         altitude: 0,
//         altitudeAccuracy: 0,
//         time: '2023-03-29T10:08:55.4061132+02:00'
//     },
//     data: { charge: 0.6 },
//     connectionStatus: 'disconnected'
// }
const rider = await realm.object.get('rider/12');

// Use a subscription to get a realtime feed of object updates.
// Subscriptions can be scoped and filtered in lots of ways, but
// lets keep things simple for now.
const subscription = await realm.object.subscribe()
subscription.on('update', data => {
    console.log(data);
});

// Let's update the object to trigger the subscription above.
realm.object.update('rider/12', {
    location: {
        latitude: 52.52826383714,
        longitude: 13.38901541951
    }
});
```
npm package: @hivekit/external-app-control
Description: An API that enables third party apps to control the Hivekit app
Author: Hivekit Inc.
Latest version: 0.0.3

# Hivekit External App Control
This library allows you to interact with [Hivekit](https://hivekit.io/) applications running in an iFrame or with a parent Hivekit application if your app is running in an iFrame within Hivekit.

## Installation
```bash
npm install @hivekit/external-app-control
yarn add @hivekit/external-app-control
```

## Usage
```javascript
import { ExternalAppControl } from '@hivekit/external-app-control';

const hivekitApp = new ExternalAppControl(document.getElementById('hivekit-iframe'));

// pan map to lat, lon
hivekitApp.map.panTo(51.5079, -0.1280);

// select an object with id rider/213
hivekitApp.selection.select('rider/213','object');

// listen to selection changes in the Hivekit app
hivekitApp.selection.on('change', (id, type) => {
  console.log(`Selected ${type} with id ${id}`);
});
```

## API
### Constructor
#### `const ctrl = new ExternalAppControl(frameElement)`
If frame element is omitted, the library will assume that it is running in an iFrame within Hivekit or a window opened by Hivekit and will try to communicate with `window.opener || window.parent`.

### Map
#### `ctrl.map.panTo(lat, lon)`
Pan the map to the given latitude and longitude.

#### `ctrl.map.panToEntity(type, id)`
Pan the map to the entity with the given type and id. Type can be `'object'`, `'area'` or `'task'`.

### Selection
#### `ctrl.selection.select(id, type)`
Select the entity with the given type and id. Type can be `'object'`, `'area'`, `'instruction'` or `'task'`.

#### `ctrl.selection.deselect()`
Deselect the currently selected entity.

#### `async ctrl.selection.get()`
Get the currently selected entity. Returns an object with `id` and `type` properties.

#### `ctrl.selection.on('change', (id, type) => {})`
Listen to selection changes in the Hivekit app.

### Object
#### `ctrl.object.showPath(objectId, settings)`
Show the path an object has taken. Settings is an object with the following properties:
```javascript
{
    // 'arrow' or 'line'
    type: 'arrow', 

    // the timespan in milliseconds before now
    timespan: 1000 * 60 * 60 * 24, // one day

    // the following settings only apply if type==='arrow'

    // how the color of the path is determined. Options are:
    // - 'speed'  color is determined by the speed of the object ranging red-yellow-green
    // - 'category' color is based on the object's category color
    colorType: 'speed', 

    // If colorType==='speed', the following settings determines the range of speeds for the coloring
    speed: { min: 0, max: 10 }
}
```

#### `ctrl.object.hidePath(objectId)`
Hide the path of an object.

#### `async ctrl.object.isPathVisible(objectId)`
Returns true if there is a path visible for the object with the given id.
npm package: @hivelocity/formify
Description: ``` const LoginForm = Formify({ first: '', last: '', contacts: [{ first: 'Barney', last: 'Calhoun' }] }, ({error, fields}) => ( <> <Error message={error} /> <TextField {...fields.first} /> <TextField {...fields.last} type="password" /> {fields.contacts &&
Latest version: 0.0.6

Formify
======================

Formify makes an attempt to simplify forms in react and move away from redux-form.

Below is a simple example of how to use Formify

## Declaration
```
const LoginForm = Formify({
    first: '',
    last: '',
    contacts: [{
        first: 'Barney',
        last: 'Calhoun'
    }]
}, ({error, fields}) => (
    <>
        <Error message={error} />
        <TextField {...fields.first} />
        <TextField {...fields.last} type="password" />
        {fields.contacts && fields.contacts.map((contact, index) => <TextField key={index} {...contact.first} />)}
        <FormButton mods={['green', 'padded', 'right']}>Login</FormButton>
    </>
));
```

`Formify` is a function that takes an object (fields) and a React Component then returns a Higher Order Component to properly pass
the fields to the form.

## Easy Implementations
```
<LoginForm onSubmit={async (fields) => {
    ...do whatever submit logic you need
}}>
```

If you have an errors go ahead and throw an error in this structure

```
{
    _error: '',
    fields: {
        first: '',
        last: ''
    }
}
```

if you `throw 'This is an error'` on the submit, that string will appear at the top of the form
npm package: @hivem/js
Description: Pure TypeScript SDK for Hivem - auth-based KV service with sync support
Latest version: 0.1.3

# @hivem/js
- Pure typescript client
- default supports all js runtimes
- sse has support for all pure js clients plus reactnative specific tooling.

### Methods
- This is the entire interface
- Each key gets identity scoping, so dont reinclude some identity prefix again.
- Backends API keys dont need signature, so just use empty fields
```typescript
import { HivemClient } from '@hivem/js';

const client = new HivemClient({
  baseUrl: 'https://api.example.com',
  apiKey: 'BACKEND_API_KEY or FRONTEND_API_KEY'
});

// Sign an identity - (on your backend or authoritative server)
const { identity, signature } = await client.sign('user123');


// Get a value (frontend/backend)
const { key, value } = await client.get(identity, signature, 'my-key');

// Set a value (frontend/backend)
await client.set(identity, signature, 'my-key', 'my-value');

// Subscribe to changes (frontend/backend)
const { close } = client.subscribe(identity, signature, {
  onMessage: (msg) => console.log(msg),
  onError: (err) => console.error(err)
});
```
npm package: @hivem/react
Description: React SDK for Hivem - auth-based KV service with sync support
Latest version: 0.3.3

# @hivem/react

React abstractions ontop of the js client.
- exposes hooks with all the normal js work taken care of.
- all you pass is the config and start using.
- only exports these 3 interfaces, 
  - if you need to do anything advanced(unlikely) - you can access the client directly to do it.
- this works with with react-native as well - the underlying ts sdk has compatibility for the sse feature.
- Updates have been made to curtail constant reactivity - especially in react native where stack based routing can cause re-instantiation effects & usecase in providers can create issues.

```typescript
import { HivemProvider, useKey, useClient } from '@hivem/react';

function App() {
  // children is hidden until getAuth resolves
  // recommend you preload that, cache or server side sign & pass the auth object
  return (
    <HivemProvider 
      apiKey="FRONTEND_API_KEY"
      baseUrl="https://api.example.com"
      getAuth={async () => {
        // Your auth logic - fetch from your backend etc.
        return { identity: 'user123', signature: '...' };
      }}>
      <MyComponent />
    </HivemProvider>
  );
}

function MyComponent() {
  const { value, set, isReady, error, refresh } = useKey('my-key', {
    default: 'default-value', // optional: fallback if key not found
    debug: true // optional: log operations
  });
  // const client = useClient();

  if (isReady) return <div>Loading...</div>;
  if (error) return <div>Error: {error.message}</div>;

  return (
    <div>
      <p>Value: {value}</p>
      <button onClick={() => set('new-value')}>Update</button>
      <button onClick={refresh}>Refresh</button>
    </div>
  );
}
```
npm package: @hivem/react-native
Description: React Native SDK for Hivem - auth-based KV service with sync support
Latest version: 0.1.3

# @hivem/react

React abstractions ontop of the js client.
- exposes hooks with all the normal js work taken care of.
- all you pass is the config and start using.
- only exports these 3 interfaces, 
  - if you need to do anything advanced(unlikely) - you can access the client directly to do it.
- this works with with react-native as well - the underlying ts sdk has compatibility for the sse feature.
- Updates have been made to curtail constant reactivity - especially in react native where stack based routing can cause re-instantiation effects & usecase in providers can create issues.

```typescript
import { HivemProvider, useKey, useClient } from '@hivem/react';

function App() {
  // children is hidden until getAuth resolves
  // recommend you preload that, cache or server side sign & pass the auth object
  return (
    <HivemProvider 
      apiKey="FRONTEND_API_KEY"
      baseUrl="https://api.example.com"
      getAuth={async () => {
        // Your auth logic - fetch from your backend etc.
        return { identity: 'user123', signature: '...' };
      }}>
      <MyComponent />
    </HivemProvider>
  );
}

function MyComponent() {
  const { value, set, isReady, error, refresh } = useKey('my-key', {
    default: 'default-value', // optional: fallback if key not found
    debug: true // optional: log operations
  });
  // const client = useClient();

  if (isReady) return <div>Loading...</div>;
  if (error) return <div>Error: {error.message}</div>;

  return (
    <div>
      <p>Value: {value}</p>
      <button onClick={() => set('new-value')}>Update</button>
      <button onClick={refresh}>Refresh</button>
    </div>
  );
}
```
npm package: @hivemap/eslint-config-df
Description: Hivemap ESLint config
Author: David Betteridge
Latest version: 7.0.0

ESLint rules adapted from https://github.com/airbnb/javascript

The main adaptation we've made is to downgrade non-critical rules to 'warn' level, to prevent linting recommendations from blocking app development (eg. in Create React App projects, where any error results in a red screen).

Pre-commit hooks and CI processes should use ESLint's `--max-warnings=0` flag to ensure that lint warnings don't make it into production code.

## Using the lint rules in a new package

1. Run the following:

    ```sh
    (
      export PKG=@dangerfarms/eslint-config-df;
      npm info "$PKG@latest" peerDependencies --json | command sed 's/[\{\},]//g ; s/: /@/g' | xargs yarn add "$PKG@latest"
    )
    ```

    Note: this produces and runs a command like the following: `yarn add @dangerfarms/eslint-config-df eslint@^#.#.# eslint-plugin-jsx-a11y@^#.#.# eslint-plugin-import@^#.#.# eslint-plugin-react@^#.#.#`, pinning the versions to the supported ones.

2. Add `"@dangerfarms/eslint-config-df"` to your project's ESLint config `.eslintrc`, under the `extends` property.

    ```json
    {
      "extends": "@dangerfarms/eslint-config-df"
    }
    ```

3. Add the `eslint` script to your `package.json`.

    ```json
    {
      "scripts": {
        "eslint": "eslint src"
      }
    }
    ```

## Usage with git hooks

1. `yarn add husky lint-staged`
2. Update `package.json` with the following root keys.

    ```json
    {
      "husky": {
        "hooks": {
          "pre-commit": "lint-staged"
        }
      },
      "lint-staged": {
        "*.js": [
          "eslint --max-warnings=0 --fix",
          "git add"
        ]
      }
    }
    ```

TODO: maybe we can automate this, and have a single bootstrapping command to install default ESLint config, git hooks, etc on a new project.

## Modifying the rules

You can clone this project if you'd like to update the rules.

For local development with `yarn` the following might be helpful.

```
cd ~/Code/dangerfarms/javascript/packages/eslint-config-df
yarn link
cd ~/Code/dangerfarms/javascript/packages/eslint-config-df-base
yarn link
cd ~/Code/dangerfarms/project
yarn link "@dangerfarms/eslint-config-df"
yarn link "@dangerfarms/eslint-config-df-base"
```

Now you can modify `eslint-config-df` and `eslint-config-df-base` in place, and run ESLint against `project` to see the effects. This allows manual testing of the ESLint rules against a particular project without having to publish a new version.
npm package: @hivemap/eslint-config-df-base
Description: Hivemap base JS ESLint config
Author: David Betteridge
Latest version: 1.0.0

ESLint rules adapted from https://github.com/airbnb/javascript

The main adaptation we've made is to downgrade non-critical rules to 'warn' level, to prevent linting recommendations from blocking app development (eg. in Create React App projects, where any error results in a red screen).

Pre-commit hooks and CI processes should use ESLint's `--max-warnings=0` flag to ensure that lint warnings don't make it into production code.

## Using the lint rules in a new package

1. Run the following:

    ```sh
    (
      export PKG=@hivemap/eslint-config-df-base;
      npm info "$PKG@latest" peerDependencies --json | command sed 's/[\{\},]//g ; s/: /@/g' | xargs yarn add "$PKG@latest"
    )
    ```

    Note: this produces and runs a command like the following: `yarn add @hivemap/eslint-config-df-base eslint@^#.#.# eslint-plugin-jsx-a11y@^#.#.# eslint-plugin-import@^#.#.# eslint-plugin-react@^#.#.#`, pinning the versions to the supported ones.

2. Add `"@hivemap/eslint-config-df-base"` to your project's ESLint config, under the `extends` property.

    ```json
    {
      "extends": "@hivemap/eslint-config-df-base"
    }
    ```

3. Add the `eslint` script to your `package.json`.

    ```json
    {
      "scripts": {
        "eslint": "eslint src"
      }
    }
    ```

## Usage with git hooks

1. `yarn add husky lint-staged`
2. Update `package.json` with the following root keys.

    ```json
    {
      "husky": {
        "hooks": {
          "pre-commit": "lint-staged"
        }
      },
      "lint-staged": {
        "*.js": [
          "eslint --max-warnings=0 --fix",
          "git add"
        ]
      }
    }
    ```

TODO: maybe we can automate this, and have a single bootstrapping command to install default ESLint config, git hooks, etc on a new project.

## Modifying the rules

You can clone this project if you'd like to update the rules.

For local development with `yarn` the following might be helpful.

```
cd ~/Code/hivemap/javascript/packages/eslint-config-df
yarn link
cd ~/Code/hivemap/javascript/packages/eslint-config-df-base
yarn link
cd ~/Code/hivemap/project
yarn link "@hivemap/eslint-config-df"
yarn link "@hivemap/eslint-config-df-base"
```

Now you can modify `eslint-config-df` and `eslint-config-df-base` in place, and run ESLint against `project` to see the effects. This allows manual testing of the ESLint rules against a particular project without having to publish a new version.