open-index/open-npm huggingface dataset:
npm package: @jckimble/github-graph-background
Description: A toy program for getting your GitHub Contributions and creating a background image from it with many themes
Author: James C Kimble Jr
Latest version: 1.0.4

# Welcome to GitHub Graph Background 👋

[![semantic-release: angular](https://img.shields.io/badge/semantic--release-angular-e10079?logo=semantic-release)](https://github.com/semantic-release/semantic-release)
![build status](https://github.com/jckimble/github-graph-background/actions/workflows/release.yml/badge.svg?branch=master)
[![npm version](https://img.shields.io/npm/v/@jckimble/github-graph-background)](https://www.npmjs.com/package/@jckimble/github-graph-background)
[![Documentation](https://img.shields.io/badge/documentation-yes-brightgreen.svg)](https://github.com/jckimble/Github-Graph-Background#readme)
[![License: MIT](https://img.shields.io/github/license/jckimble/github-graph-background)](https://github.com/jckimble/Github-Graph-Background/blob/master/LICENSE)

> A toy program for getting your GitHub Contributions and creating a background image from it with many themes.

## Install

```sh
npm install @jckimble/github-graph-background
```

## Usage

```sh
github-graph-background
```

## Options

> Github Token can be read from the GITHUB_TOKEN Environment Variable

| Option   | Description            | Default          |
| -------- | ---------------------- | ---------------- |
| --output | Image Output           | ./background.png |
| --width  | Image Width            | 1366             |
| --height | Image Height           | 768              |
| --margin | Spacing Between Blocks | 2                |
| --token  | GitHub Token           | N/A              |
| --theme  | Color Theme            | green            |

## Themes

> Small Images of themes are in [releases](https://github.com/jckimble/github-graph-background/releases/latest) named by the theme option.
> Special value of random picks a theme at random. Default theme is green.
> Current themes are: green, blue, red, rose, fullrandom and random along with their dark variants.
> Adding :dark after a theme name generates the dark version.

## Run tests

```sh
npm run test
```

## Author

👤 **James C Kimble Jr**

- Website: https://jckimble.com
- Twitter: [@jckimble601](https://twitter.com/jckimble601)
- Github: [@jckimble](https://github.com/jckimble)
- LinkedIn: [@james-kimble-865092212](https://linkedin.com/in/james-kimble-865092212)

## 🤝 Contributing

Contributions, issues and feature requests are welcome!

Feel free to check [issues page](https://github.com/jckimble/Github-Graph-Background/issues). You can also take a look at the [contributing guide](https://github.com/jckimble/Github-Graph-Background/blob/master/CONTRIBUTING.md).

## Show your support

Give a ⭐️ if this project helped you!

## Donations

[!["Buy Me A Coffee"](https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png)](https://www.buymeacoffee.com/jckimble)

## 📝 License

Copyright © 2023 [James C Kimble Jr](https://github.com/jckimble).

This project is [MIT](https://github.com/jckimble/Github-Graph-Background/blob/master/LICENSE) licensed.
npm package: @jcl12138/form-create-designer-custom
Description: 基于@form-create/designer修改的自测表单设计器组件
Author: xaboy
Latest version: 1.0.1

<p align="center">
    <a href="http://www.form-create.com">
        <img width="200" src="http://file.lotkk.com/form-create.png">
    </a>
</p>

# 基于 form-create-designer v3 修改的自用测试版本
npm package: @jclem/assert
Description: A collection of commonly-used assertion functions
Author: Jonathan Clem
Latest version: 3.1.0

# @jclem/assert

Provides a set of TypeScript-friendly functions for asserting values and types
of values.

## Installation

```shell
bun add @jclem/assert
```

## Usage

This package works by making assertions about a value, and then _returning_ the
value. This means that it works differently from other type assertions in
TypeScript such as `asserts value is Type` or `value is Type`. In order to make
use of the type-constrained value, you must use the returned value.

```typescript
import {
  assert,
  assertString,
  assertType,
  assertInstance,
} from "@jclem/assert";

class Foo {
  name = "foo";
}

function maybeValue<T>(value: T): T | null {
  return Math.random() > 0.5 ? value : null;
}

// Assert that a value is non-null and is defined.
const value = assert(maybeValue("Hello"));
value.length; // => 5

// Note that the returned value must be used.
const maybeString = maybeValue("Hello");
const definitelyString = assert(maybeString);
definitelyString.length; // => 5
// @ts-expect-error
maybeString.length; // => Error: Object is possibly 'null'.

// Assert that a value is a string
const str = assertString(maybeValue("Hello"));
str.length; // => 5

// Assert that a value is of a specific type
const bigint = assertType(maybeValue(1n), "bigint");
bigint.length; // => 1n

// Assert that a value is an instance of a class
const foo = assertInstance(maybeValue(new Foo()), Foo);
foo.name; // => 'foo'
```
npm package: @jclem/cli
Description: A utility for parsing command-line arguments
Author: Jonathan Clem
Latest version: 1.0.9

# @jclem/cli

Parses command-line arguments into a set of positional args and a map of flags.

## Usage

First, you can parse arguments into separate positional and named flags. All
flags are parsed into arrays of `(string | true)` (value-less flags are parsed
as `true`).

```typescript
import { parseArgs } from "@jclem/cli";

// Bun.args = ["bun", "run-script", "--foo=foo", "--foo=foo2", "bar", "baz"]
const parsed = parseArgs(Bun.args.slice(2));

// {
//   positional: ["bar", "baz"],
//   flags: { foo: ["foo", "foo2"] }
// }
```

Although this package has no direct dependency on [Zod](https://zod.dev), it is
easy to use Zod to parse the flags into a more structured format.

```typescript
import { z } from "zod";

const string = z.tuple([z.string()]).transform(([v]) => v);
const boolean = z.tuple([z.boolean()]).transform(([v]) => v);

const mySchema = z.object({
  positional: z.tuple([z.string(), z.coerce.number()]),
  flags: z.object({
    foo: string,
    t: boolean,
  }),
});

// Bun.args = ["bun", "run-script", "--foo=bar", "-t", "abc", "123"]
const parsedArgs = parseArgs(Bun.args.slice(2));
const result = mySchema.parse(parsedArgs);

// {
//   positional: ["abc", 123],
//   flags: { foo: "bar", t: true },
// }
```
npm package: @jclem/event-emitter
Description: An event emitter implementation
Author: Jonathan Clem
Latest version: 3.0.1

# @jclem/event-emitter

Provides a set of TypeScript-friendly event emitter.

## Installation

```shell
npm install @jclem/event-emitter
```

## Usage

This package exposes a simple EventEmitter class that can be extended with a
custom set of type-friendly event names and parameter tuples.

```typescript
import {EventEmitter} from '@jclem/event-emitter'

class MyEmitter extends EventEmitter<{foo: [string, number]}> {}

const emitter = new MyEmitter()

const listener = (a: string, b: number) => console.log(a, b)

const off = emitter.on('foo', listener)
emitter.emit('foo', ['Hello', 5]) // => 'Hello' 5
off() // Or `emitter.off('foo', listener)`
```
npm package: @jclem/get-in
Description: A function for getting deeply nested values
Author: Jonathan Clem
Latest version: 2.0.1

# getIn

This package provides a function `getIn`, which allows null-error and type-safe traversal of objects.

The `getIn` function works by wrapping a value in a function that returns that value, and then wrapping that function in a `Proxy`. To use it, call `getIn` on the object you want to traverse (e.g. `getIn(object)`) and get properties as you normally would, but when you want an actual value, call the property like a function (e.g. `getIn(object).foo.bar[0][1].baz()`). The return value will be `null` or the value itself.

## Limitations

- There are likely edge cases here. I've mostly experimented with simple arrays and plain JavaScript objects.
- Even if a type is non-nullable (such as `firstName` in the below example), the type will be nullable when gotten through `getIn`, and you'll need to perform a check for the type checker to be happy. I haven't found a way around this, yet.

## Example

```ts
type Person = {
  firstName: string
  middleName?: string
  lastName: string
  
  address?: Address
}

type Address = {
  streets: string[]
  city: string
  state: string
  zip: string
}

const p1: Person = {
  firstName: 'Jonathan',
  lastName: 'Clem',
  
  address: {
    streets: ['123 Main St.'],
    city: 'Juneau',
    state: 'Alaska',
    zip: '11111'
  }
}

const p2: Person = {
  firstName: 'Bob',
  lastName: 'Clem'
}

getIn(p1).firstName() // Type is string | null
getIn(p1).address.state() // Type is string | null, value is `'Alaska'`.
getIn(p1).address.streets[0]() // Type is string | null, value is `'123 Main St.'`.
getIn(p2).address.streets[1]() // Type is string | null, value is `null`.
```
npm package: @jclem/logfmt2
Description: Parses logs and stringifies logs into the logfmt format
Author: Jonathan Clem
Latest version: 2.4.3

# logfmt2

[![](https://github.com/jclem/logfmt2/workflows/Test%20%26%20Benchmark/badge.svg)](https://github.com/jclem/logfmt2/actions)

logfmt2 (which is based on the original [logfmt](https://github.com/csquared/node-logfmt) and the original [blog post](https://brandur.org/logfmt)) is a module for encoding objects into the logfmt format and decoding them again.

## Install

```
npm install @jclem/logfmt2
```

## Build

```
script/build
```

## Publish

The `script/publish` script cleans the build directory, builds the project, and then runs `npm publish`.

```
script/publish
```

## Usage

```javascript
const {Logger, encode, decode} = require('@jclem/logfmt2')

console.log(encode({foo: 'bar'})) // foo=bar
console.log(decode('foo=bar')) // {foo: 'bar'}

// Use the static `Logger.log` to stdout
Logger.log({foo: 'bar'}) // logs "foo=bar"

// Create a logger to maintain a logging context
const logger = new Logger({ns: 'my-app'})
logger.log({foo: 'bar'}) // logs "ns=my-app foo=bar"

// Add timers
logger.time('elapsedMs')
// Wait 50ms
logger.log({foo: 'bar'}) // logs "ns=my-app elapsedMs=50 foo=bar"
// Wait 50ms
logger.log({foo: 'bar'}) // logs "ns=my-app elapsedMs=100 foo=bar"

// Add (mutate) the logger context
logger.appendContext({new_context: 'hello'})
logger.log({foo: 'bar'}) // logs "ns=my-app new_context=hello elapsedMs=100 foo=bar"
```
npm package: @jclem/omap
Description: An ordered map
Author: Jonathan Clem
Latest version: 1.1.1

# OMap [![CI](https://github.com/jclem/omap/workflows/CI/badge.svg?event=push&branch=main)](https://github.com/jclem/omap/actions?query=workflow%3ACI+event%3Apush+branch%3Amain)

A map whose values are ordered.
npm package: @jclem/result
Description: A utility for safely handling errors without try/catch
Author: Jonathan Clem
Latest version: 4.0.0

# @jclem/cli

Parses command-line arguments into a set of positional args and a map of flags.

## Usage

First, you can parse arguments into separate positional and named flags. All
flags are parsed into arrays of `(string | true)` (value-less flags are parsed
as `true`).

```typescript
import { parseArgs } from "@jclem/cli";

// Bun.args = ["bun", "run-script", "--foo=foo", "--foo=foo2", "bar", "baz"]
const parsed = parseArgs(Bun.args.slice(2));

// {
//   positional: ["bar", "baz"],
//   flags: { foo: ["foo", "foo2"] }
// }
```

Although this package has no direct dependency on [Zod](https://zod.dev), it is
easy to use Zod to parse the flags into a more structured format.

```typescript
import { z } from "zod";

const string = z.tuple([z.string()]).transform(([v]) => v);
const boolean = z.tuple([z.boolean()]).transform(([v]) => v);

const mySchema = z.object({
  positional: z.tuple([z.string(), z.coerce.number()]),
  flags: z.object({
    foo: string,
    t: boolean,
  }),
});

// Bun.args = ["bun", "run-script", "--foo=bar", "-t", "abc", "123"]
const parsedArgs = parseArgs(Bun.args.slice(2));
const result = mySchema.parse(parsedArgs);

// {
//   positional: ["abc", 123],
//   flags: { foo: "bar", t: true },
// }
```
npm package: @jclem/toolbox
Description: A collection of utilities for TypeScript. This library provides robust types and helpers for working with optional values, error handling, and functional patterns.
Latest version: 0.0.3

# Toolbox

A collection of utilities for TypeScript. This library provides robust types and
helpers for working with optional values, error handling, and functional
patterns.

## Modules Overview

### `Function`

Helpers for working with functions.

### `Tagged`

Utility for creating tagged union types, used throughout the library.

### Core Types

#### `Option`

Implements the `Option` type for optional values.

#### `Either`

Implements the `Either` type for values that can be one of two types.

#### `Result`

Implements the `Result` type for success or failure.

## Testing

Comprehensive tests are provided for all modules. Run with:

```bash
bun test
```
npm package: @jclem/topbar
Description: Tiny & beautiful site-wide progress indicator
Author: Jonathan Clem
Latest version: 1.1.2

# topbar

This is a fork of [buunguyen/topbar](https://github.com/buunguyen/topbar) with
the following changes:

- Export ESM and CJS
- TypeScript
- Delayed show contribution from Phoenix

Site-wide progress indicator that is:

- Tiny (1KB minified and gzipped), no dependency
- Perfect for single-page applications
- Responsive

Check out [demo & usages](http://buunguyen.github.io/topbar).

MIT license. Copyright 2021 Buu Nguyen.