open-index/open-npm huggingface dataset:
npm package: @jessitronica/honeycomb-trace-spans
Description: A command-line tool to retrieve all spans in a trace from Honeycomb
Author: Jessica Kerr
Latest version: 1.0.0

# honeycomb-trace-spans

A command-line tool to retrieve all spans in a trace from Honeycomb.

## Installation

You can install this package globally:

```bash
npm install -g honeycomb-trace-spans
```

Or use it with npx:

```bash
npx honeycomb-trace-spans --trace-id <trace_id>
```

## Usage

[Get a Honeycomb API Key for your team and environment.](https://docs.honeycomb.io/configure/environments/manage-api-keys/#find-api-keys)

```bash
export HONEYCOMB_API_KEY=your_api_key
honeycomb-trace-spans --trace-id <trace_id> [--time-range <seconds>]
honeycomb-trace-spans --trace-id <trace_id> --start-time <unix_timestamp> --end-time <unix_timestamp>
```

### Parameters

- `--trace-id`: The trace ID to retrieve spans for (required)
- `--time-range`: Time range in seconds to look for spans (optional, default: 3600 seconds/1 hour)
- `--start-time`: Start time as Unix timestamp in seconds (optional, must be used with --end-time)
- `--end-time`: End time as Unix timestamp in seconds (optional, must be used with --start-time)

### Environment Variables

- `HONEYCOMB_API_KEY`: Your Honeycomb API key (required)
- `HONEYCOMB_API_ENDPOINT`: Custom API endpoint (optional, default: https://api.honeycomb.io)

## Examples

```bash
# Set your Honeycomb API key
export HONEYCOMB_API_KEY=your_api_key

# Retrieve spans for a trace with default time range (1 hour)
honeycomb-trace-spans --trace-id abcd1234efgh5678

# Retrieve spans for a trace with a custom time range (last 24 hours)
honeycomb-trace-spans --trace-id abcd1234efgh5678 --time-range 86400

# Retrieve spans for a trace with an absolute time range
honeycomb-trace-spans --trace-id abcd1234efgh5678 --start-time 1617235200 --end-time 1617321600

# With an absolute time range from yesterday to now
honeycomb-trace-spans --trace-id abcd1234efgh5678 --start-time $(date -v-1d +%s) --end-time $(date +%s)
```

## Output

The script outputs structured JSON data that's optimized for agent consumption, while still providing the trace URL for human use.

Example output:

```json
{
  "summary": {
    "traceId": "abcd1234efgh5678",
    "spanCount": 16,
    "services": ["service-a", "service-b", "service-c"],
    "rootSpans": 1,
    "timeRange": {
      "start": 1617235200,
      "end": 1617321600
    },
    "traceUrl": "https://ui.honeycomb.io/team/environments/env/trace?trace_id=abcd1234efgh5678&trace_start_ts=1617235200&trace_end_ts=1617321600"
  },
  "spans": [
    {
      "spanId": "span1",
      "parentId": "ROOT",
      "name": "request",
      "service": "service-a",
      "duration": 100.5,
      "attributes": {}
    }
    // ... more spans ...
  ]
}
```

## License

MIT
npm package: @jesstelford/react-components-kit
Description: Collection of reusable React components
Author: Taito United Oy
Latest version: 4.2.2

# react-components-kit
A collection of reusable and themable React UI components built with [styled-components](https://styled-components.com).

[![travis build](https://img.shields.io/travis/TaitoUnited/react-components-kit.svg)](https://travis-ci.org/TaitoUnited/rreact-components-kit)
[![version](https://img.shields.io/npm/v/react-components-kit.svg)](https://www.npmjs.com/package/react-components-kit)
[![MIT License](https://img.shields.io/npm/l/react-components-kit.svg)](https://opensource.org/licenses/MIT)

## Install
```
npm install --save react-components-kit
```

## Component showcase
Live demo available: https://taitounited.github.io/react-components-kit/

You can also test the components locally by cloning this repo and doing the following steps:
```
cd docs
npm install
npm start
```
And then open localhost:3000 in a browser.

## Usage
```javascript
import React from 'react';

// Import some components
import { Tooltip, Spinner } from 'react-components-kit';

const Example = () => {
  return (
    <Tooltip content="Hello World" />
    <Spinner color="tomato" lg />
  );
}
```

Check out the more detailed [documentation](src/README.md) describing the individual components
in more detail.

## Development
In order to get **react-components-kit** UI components to work in the docs project
you have to link the local npm package by first doing:

```
npm link
```

in the root of the project and then cd to `/docs` and do:

```
npm link react-components-kit
```
to add the package to node_modules in docs' create-react-app project.

Then you can start developing and continuously building your changes by running:

```
npm run watch:build:lib
```

This way you can easily test your changes in the docs pages.

After done with changes add them with:
```
git add .
```

and commit with
```
npm run commit
```

which uses [commitizen](https://github.com/commitizen/cz-cli)
helper to format the commit messages partly based on these [rules](https://gist.github.com/stephenparish/9941e89d80e2bc58a153).

This way [semantic-release](https://github.com/semantic-release/semantic-release)
knows how to bumb up the version number correctly when we finally push the code to master and Travis CI builds our package.

**Do not** force push to the repo, since that may break semantic-release.

You can see the Travis CI builds [here](https://travis-ci.org/TaitoUnited/react-components-kit)
npm package: @jesstelford/react-pose
Description: A declarative animation library for React
Author: Matt Perry
Latest version: 1.4.0-anycomponent

# <a href="https://popmotion.io"><img src="https://user-images.githubusercontent.com/7850794/37059519-9a190c14-2185-11e8-894f-e82a99f45171.png" width="243" alt="React Pose" /></a>

## React components for the Pose animation system

[![npm version](https://img.shields.io/npm/v/react-pose.svg?style=flat-square)](https://www.npmjs.com/package/react-pose)
[![npm downloads](https://img.shields.io/npm/dm/react-pose.svg?style=flat-square)](https://www.npmjs.com/package/react-pose)
[![Twitter Follow](https://img.shields.io/twitter/follow/espadrine.svg?style=social&label=Follow)](http://twitter.com/popmotionjs)
[![Join the community on Spectrum](https://withspectrum.github.io/badge/badge.svg)](https://spectrum.chat/popmotion)

- [Homepage](https://popmotion.io/pose)
- [API](https://popmotion.io/pose/api)
- [Get started](https://popmotion.io/pose/learn/get-started)
npm package: @jesstelford/react-sane-contenteditable
Description: React component with sane defaults to make any element contentEditable
Author: Ashley Williams
Latest version: 1.6.1-pr73

# react-sane-contenteditable

[![npm version](https://badge.fury.io/js/react-sane-contenteditable.svg)](https://badge.fury.io/js/react-sane-contenteditable)

React component with sane defaults to make any element contentEditable

### **DEMO:** https://jsfiddle.net/zp2v824s/show

## Why?

ContentEditable has some well known issues, and the purpose of this component is to deal with them in a sane manner so we don't have to continue re-inventing the wheel! 🔥

- Clean and sanitise the output
- Remove rich text formatting when pasting
- Prevent the cursor from jumping around

## Example

```jsx
import React, { Component } from 'react';
import ContentEditable from 'react-sane-contenteditable';

class App extends Component {
  constructor(props) {
    super(props);

    this.state = {
      title: 'Title here',
    };
  }

  handleChange = (ev, value) => {
    this.setState({ title: value });
  };

  render() {
    return (
      <div className="App">
        <ContentEditable
          tagName="h1"
          className="my-class"
          content={this.state.title}
          editable={true}
          maxLength={140}
          multiLine={false}
          onChange={this.handleChange}
        />
      </div>
    );
  }
}
```

### Develop

### Tests

`yarn test`

### Linting

`yarn run lint`

### Dev

Runs the rollup dev server with file watching on both the src and demo

`yarn run dev`
npm package: @jesster2k10/rn-progress-hud
Description: Imperative Progress HUD for React Native, inspired by SVProgressHUD on iOS
Author: Jesse Onolememen
Latest version: 0.2.0

# rn-progress-hud

Imperative Progress HUD for React Native, inspired by SVProgressHUD on iOS. Works on both iOS and Android.

![iOS Example](./progress_hud_ios_30.gif)

## Installation

```sh
npm install @jesster2k10/rn-progress-hud
```

## Usage

```js
import ProgressHUD from '@jesster2k10/rn-progress-hud';

// ...

ProgressHUD.show();
```

TODO: Add more to README.md

## License

MIT
npm package: @jessupwall02/sdk
Description: 🛠 An SDK for building applications on top of Uniswap.
Latest version: 3.0.12

# Uniswap SDK

[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
[![Actions Status](https://github.com/Uniswap/uniswap-sdk/workflows/CI/badge.svg)](https://github.com/Uniswap/uniswap-sdk)
[![npm version](https://img.shields.io/npm/v/@uniswap/sdk/latest.svg)](https://www.npmjs.com/package/@uniswap/sdk/v/latest)
[![npm bundle size (scoped version)](https://img.shields.io/bundlephobia/minzip/@uniswap/sdk/latest.svg)](https://bundlephobia.com/result?p=@uniswap/sdk@latest)

In-depth documentation on this SDK is available at [uniswap.org](https://uniswap.org/docs/v2/SDK/getting-started/).

## Running tests

To run the tests, follow these steps. You must have at least node v10 and [yarn](https://yarnpkg.com/) installed.

First clone the repository:

```sh
git clone https://github.com/Uniswap/uniswap-sdk.git
```

Move into the uniswap-sdk working directory

```sh
cd uniswap-sdk/
```

Install dependencies

```sh
yarn install
```

Run tests

```sh
yarn test
```

You should see output like the following:

```sh
yarn run v1.22.4
$ tsdx test
 PASS  test/constants.test.ts
 PASS  test/pair.test.ts
 PASS  test/fraction.test.ts
 PASS  test/miscellaneous.test.ts
 PASS  test/entities.test.ts
 PASS  test/trade.test.ts

Test Suites: 1 skipped, 6 passed, 6 of 7 total
Tests:       3 skipped, 82 passed, 85 total
Snapshots:   0 total
Time:        5.091s
Ran all test suites.
✨  Done in 6.61s.
```
npm package: @jest-automation/console
Description: This package allows the console object to be reconfigured to support groups, which are disabled by default in node.
Latest version: 0.0.9
Deprecated: This package has been moved to https://www.npmjs.com/package/@autometa/logging

# Console

This package allows the console object to be reconfigured to
support groups, which are disabled by default in node.

Grouping can be enabled by calling `useConsoleGroups`, and disabled
with `disableConsoleGroups`.

To start a console group call `console.group('some title here')`,
and to end it call `console.groupEnd()`.

For example take the following code:

```ts
console.group('Outer Group');
console.group('Inner Group');
console.log('Http Request Sent');
console.log('Http Response Received');  
console.groupEnd();
console.groupEnd();
```

Which will produce the following output

```
Outer Group
  Inner Group
     [Log]
     Http Request Sent
     /path/to/file:8:11

     [Log]
     Http Response Received
     /path/to/file:9:11

```

## Checked Grouping

To confirm groups are being ended when expected, the `startGroup` and `endGroup`
functions can be used.

`startGroup` takes a `ConsoleGroupToken` or a string and begins a console group.
`endGroup` also takes a ConsoleGroupToken or a string, and will raise
a warning message if groups are being ended in the wrong order.

### ConsoleGroupToken

The `ConsoleGroupToken` is an empty enum. It can be replaced by custom
enum values by declaring the type somewhere in your project.

```ts
// in 'typings.d.ts' or similar file
declare module "@jest-automation/console" {
    export enum ConsoleGroupToken {
        Scenario = 'Scenario',
        Test = 'Test'
    }
}
```
Which can now be used directly

```ts
startGroup(ConsoleGroupToken.Scenario)
```

`startGroup` can also accept additional values which will be displayed in the group title

```ts
startGroup(ConsoleGroupToken.Scenario, 'first', 1)
// prints 
// Scenario: first, 1
```

## Grouping

Alternatively the `grouping` function can be used. `grouping` takes
a title and an action. The action is executed and the group is closed again before the error is propagated.

Grouping will return the value of an action directly. If the action returns
a promise, then `grouping` can be `await`ed

```ts
grouping('a group', ()=>{
    doStuff()
})

await grouping('an async group', async ()=>{
    return someAsyncJob()
})
```

## Async

Grouping only makes sense in a synchronous context. Groups
should only be written outside of async functions which
are not immediately awaited.

However async actions can be run within a group - just be sure they're
all completed before ending it.
npm package: @jest-automation/cucumber
Description: **Full Documentation/Getting Started can be [found here](https://bendat.github.io/jest-automation/docs/cucumber/intro)**
Latest version: 0.0.3
Deprecated: This package has been moved to https://www.npmjs.com/package/@autometa/cucumber

# Jest Automation Cucumber

**Full Documentation/Getting Started can be [found here](https://bendat.github.io/jest-automation/docs/cucumber/intro)**

Jest Automation is an Cucumber alternative inspired by [jest-cucumber](https://github.com/bencompton/jest-cucumber) using structured tests that closely resemble their original feature file counterpart.

## Preview

Assuming the following feature file:

```gherkin title='Create a feature file'
Feature: Registering

    Background: Provide password
        Given a provided password 'password1234'

    Scenario: A user registers
        Given a provided username 'frankie2'
        When the user registers
        Then they are shown their profile

    Rule: A username cannot contain special characters
        Scenario Outline: A user cannot register with a special character
            Given a provided username '<username>'
            When the user registers
            Then they are displayed an error
                | message                                      |
                | A username cannot contain special characters |

            Examples:
                | username  |
                | frankie2; |
                | frankie2, |
                | frankie2" |
```

We can create our test:

```ts title="Step Definitions"
import {UserDriver} from '../fugazi-ui-drivers';
import {Feature} from '@jest-automation/cucumber'

Feature(({ Background, Scenario, Rule }) => {
  let user: UserDriver;
  beforeEach(() => {
    user = new UserDriver();
  });

  Background(({ Given, When }) => {
    Given('a provided password {string}', (password: string) => {
      user.setPassword(password);
    });

    // steps can be run in background even if not defined so
    // in gherkin. This way we can take advantage of cucumber
    // expressions and/or regex
    Given('a provided username {string}', (username: string) => {
      user.setUsername(username);
    });

    When('the user registers', async () => {
      await user.performRegistration();
    });
  });

  Scenario('A user registers', ({ Then }) => {
    Then('they are shown their profile', () => {
      user.verifyProfile();
    });
  });

  Rule(
    'A username cannot contain special characters',
    ({ ScenarioOutline }) => {
      ScenarioOutline(
        'A user cannot register with a special character',
        ({ Then }) => {
          Then('they are displayed an error', (table: GherkinTable) => {
            user.verifyError(table);
          });
        }
      );
    }
  );
}, './sample.feature');
```
npm package: @jest-automation/dto
Description: This library provides functionality to help create data types and builder classes for them.
Latest version: 0.0.9
Deprecated: This package has been moved to https://www.npmjs.com/package/@autometa/dto-builder


# DTO & Builder Pattern

This library provides functionality to help create data types and builder classes for them.

A DTO is a class with the `@Property` decorator applied to at least one property.

For example:

```ts
import { Property } from '@jest-automation/dto';

export class CreateUserDto {
  @Property
  username!: string;

  @Property
  password!: string;

  @Property
  email?: string;
}
```

Now it's possible to generate a builder for this DTO. By passing a
DTO Class to the `Builder` function, a new class will be created with
builder functions corresponding to the DTO properties.

```ts
import { CreateUserDto } from './somewhere';
import { Builder } from '@jest-automation/dto';

const CreateUserBuilder = Builder(CreateUserDTO);

const builder = new CreateUserBuilder();
```

The builder will share property names with the underlying DTO, which
will be methods that take a value to fill in the DTO, and which return the builder instance to allow for chaining.

```ts
builder.username('fredici').password('1234');
```

Type information is generated preventing the wrong type being used for a
param unless explicitely bypassed

```ts
builder.username(1); // tsc error
builder.username(1 as unknown as string); // ok
```

To retrieve the underlying DTO, call the `build` method.

```ts
const result = builder.build();
```

If the package `class-validators` is being used, then their validation
will be executed by the build method. To disable validaton, pass `false` to the `build` method.

```ts
const result = builder.build(false);
```