open-index/open-npm huggingface dataset:
npm package: @kqraze/vue
Description: A lightweight Vue 3 library for managing API requests with caching, state management, reactivity, and event hooks.
Author: KQraze
Latest version: 2.2.9

# @kqraze/vue

---
#### ⚡ A set of functions, methods, and hooks for Vue 3 written with strict TypeScript typing.

## 💎 Installation

To install the library, use the following command:

```bash
npm install -D @kqraze/vue
```

## ✅ Active Functions List

>🔹 **[useApi()](https://github.com/KQraze/kqraze-vue/tree/main/src/use-api/index.md)**  
  A composable for handling API requests with caching, state management, and data adaptation.

>🔹 **[createEventHook()](https://github.com/KQraze/kqraze-vue/blob/main/src/create-event-hook/index.md)**  
  A utility for managing events, allowing you to subscribe, unsubscribe, and trigger handlers.

>🔹 **[useAwaitingEvent()](https://github.com/KQraze/kqraze-vue/blob/main/src/use-awaiting-event/index.md)**  
A composable utility for managing delayed execution with a waiting state. It allows you to execute an event with a specified timeout, track its progress, cancel it, and dynamically update the timeout.

>🔹 **[deepClone()](https://github.com/KQraze/kqraze-vue/blob/main/src/deep-clone)**  
A utility to clone a JSON Like object and get rid of the reference (the same as the same as `JSON.parse(JSON.stringify(data))`)

## 🎯 Usage

Here's an example of how to use `createEventHook()`:

```ts
import { createEventHook } from '@kqraze/vue'

const messageHook = createEventHook<string>();

// Subscribe to the event
messageHook.on((message) => {
    console.log("Message received:", message);
});

// Trigger the event
messageHook.trigger("Hello world!"); // The console will display: Message received: Hello world!
```
npm package: @kr-yeon/kisa-seed
Description: Typescript implementation of the KISA SEED encryption and decryption
Author: kr-yeon
Latest version: 1.0.5

# kisa-seed

Typescript implementation of the KISA SEED encryption and decryption

[KISA SEED Algorithm](https://seed.kisa.or.kr/kisa/algorithm/EgovSeedInfo.do)

This is a typescript conversion of the Java class mentioned in the above website.

Since it is almost a direct translation, it will not follow typescript standards and best practices.

Thank you for https://github.com/predict-woo/kisa-seed

## Installation
```
npm install @kryeon/kisa-seed
```

## Usage

You can use it in the following way.

```ts
import { KISA_SEED_CBC } from "../src";

const enc = KISA_SEED_CBC.encrypt(
  "gONPjwgQcPHp85Q3CtQFiQ==",
  "II1mpzCoGoFvutn6NhAlAQ==",
  "Hello World"
);

const dec = KISA_SEED_CBC.decrypt(
  "gONPjwgQcPHp85Q3CtQFiQ==",
  "II1mpzCoGoFvutn6NhAlAQ==",
  enc
);

console.log(dec);
```

You can also access an inner method if you want to directly encrypt/decrypt a Uint8Array

```ts
import { KISA_SEED_CBC } from "../src";

function stringToUint8Array(str: string): Uint8Array {
  const encoder = new TextEncoder(); // TextEncoder encodes into UTF-8 by default
  const uint8Array = encoder.encode(str);
  return uint8Array;
}

function uint8ArrayToString(uint8Array: Uint8Array): string {
  const decoder = new TextDecoder("utf-8");
  return decoder.decode(uint8Array);
}

function base64ToUint8Array(base64: string): Uint8Array {
  return new Uint8Array(Buffer.from(base64, "base64"));
}

const pbUserKey = base64ToUint8Array("gONPjwgQcPHp85Q3CtQFiQ==");
const bszIV = base64ToUint8Array("II1mpzCoGoFvutn6NhAlAQ==");
const encStr = stringToUint8Array("Hello World");

const enc = KISA_SEED_CBC.SEED_CBC_Encrypt(
  pbUserKey,
  bszIV,
  encStr,
  0,
  encStr.length
);

const dec = KISA_SEED_CBC.SEED_CBC_Decrypt(
  pbUserKey,
  bszIV,
  enc,
  0,
  enc.length
);

console.log(uint8ArrayToString(dec));
```
npm package: @kr05/simple-stepper
Description: Stepper component that (mostly) adheres to Material Design.
Author: Kevin Rivera
Latest version: 1.1.0

# \<simple-stepper>

> This component is a WIP. Please read the [disclaimer](#Disclaimer) for more context.

Stepper component that (mostly) adheres to Material Design. Built with [lit-element](https://lit-element.polymer-project.org/) and [open-wc](https://github.com/open-wc/open-wc). Built on top off the amazing [l2t-paper-stepper](https://github.com/Link2Twenty/l2t-paper-stepper).

## Installation
```bash
npm i @kr05/simple-stepper
```

## Usage
```html
<script type="module">
  import 'simple-stepper/simple-stepper.js';
  import 'simple-stepper/simple-step.js';
</script>

<simple-stepper>
  <simple-step label="First step" subtitle="Edit me!" editable></simple-step>
  <simple-step label="Second step" subtitle="Please don't skip me." optional></simple-step>
  <simple-step label="Third step" subtitle="I am locked, try opening me." locked></simple-step>
  <simple-step label="Last step" lastStep></simple-step>
</simple-stepper>
```

## Roadmap
There are various milestones I would like to achieve with this component. Currently, these are:
- [ ] Replace mwc-button and mwc-icon with with simple components.

- [ ] Expose as much css as possible.

- [ ] Align implementation as much as possible with the [Gold Standard](https://github.com/webcomponents/gold-standard/wiki) document.

## Disclaimer
This is very much a work in progress, so take precautions if you plan on using ```<simple-stepper>``` in production. That being said, I depend on this component for my business needs, which means that I will continue to update and support this package for the foreseeable future. If you find that it's not working as expected or wish to see some feature added, please submit an issue and I will get right on it.
npm package: @krab/isuseableobject
Description: A simple function to check if given variable can be used as an object
Author: Kapil Verma
Latest version: 1.0.1

### isuseableobject

#### v1.0.1

#### We follow [breaking].[feature].[fix] versioning

`npm install --save @krab/isuseableobject`

This module provides a simple function that can be used to check that whether a given variable can be used
as an object. Usage given below.

```js
import isuseableobject from '@krab/isuseableobject'; // in projects with ES7 modules
const isuseableobject = require('@krab/isuseableobject/common'); // in projects with common JS modules

isuseableobject({}); // returns true
isuseableobject(1); // returns false
```
npm package: @krab/op
Description: Basic building block of domain logic
Author: Kapil Verma
Latest version: 1.0.1

### op

### v1.0.0

#### We follow [breaking].[feature].[fix] versioning

`npm install --save @krab/op`

This module provides a building-block for domain logic.
Any software can be writtent using `op` in such a way that
all of the domain logic in the software will be completely unit-testable.
Usage given below.

##### Usage
```js
import Op from '@krab/op'; // in projects with ES7 modules
const  Op = require('@krab/op/common'); // in projects with common JS modules

const domainOp = new Op(({db, api}) => {
  return db.getResults() // returns a promise
    .then((dbResults) => api.processData(dbResults))
  ;
});

// OR

const domainOp = new Op(async ({db, api}) => {
  const dbResults = await db.getResults();
  const apiResults = await api.processData(dbResults);

  return apiResults;
}, { // this param is optional
  doc: 'Does somthing with db and api',
  types: {
    db: (db) => db instanceof Db,
    api: (api) => api instanceof Api
  }
});

domainOp.mount({db: new Db(config.db), api: new Api(config.api)});
const results = await domainOp.run();
domainOp.run().then((results) => {});

// OR

domainOp.run({db: new Db(config.db), api: new Api(config.api)});
```

##### Features
1. An `op` is either async, or returns a Promise.
2. Failure to comply with `1.` will result in a runtime-error.
3. An `op` can have a `doc` string attached to it.
4. An `op` can have `types` associated with it, which will be used to validate the params supplied to the `op`.
5. An `op` can be run in 2 ways: `op.run(params)` or `op.mount(params).run()`.
6. `op.mount` mounts a set of `params` in the op, so that `op.run` can be called without any arguments.
7. An `op` can be cloned using `op.clone()`.
8. An `op.vent` is an event-aggregator on which the events `'start'`, `'err'`, `'done'`, and `'end'` are emitted at appropriate times in the lifecyclt of the `op`.

##### Op Events
`op` uses `@krab/vent`([link](https://github.com/kapv89/vent)). Each instance of class `Op` has a property `vent`, which is an event aggregator attached to that instance.
Usage of `op.vent` given below.

```js
const op = new Op(...);

op.vent.on('start', ({op, params}) => {...});
op.vent.on('err', ({op, err, params}) => {...});
op.vent.on('done', ({op, result, params}) => {...});
op.vent.on('end', ({op, success, params}) => {...});
```
npm package: @krab/shape
Description: An isomorphic & async object-validation library
Author: Kapil Verma
Latest version: 1.0.0

## `shape`
#### Isomorphic and Async object validation library.

##### `npm install --save @krab/shape'`
##### `import Shape from '@krab/shape'`
##### `const Shape = require('@krab/shape/common')`

`shape` is used to vaidate data in an async manner. Doesn't matter if your checks are all synchronous, `shape` will check them in an async manner. This is very useful for validating data against external data sources. Example below:

```js
import Shape from '@krab/shape';

// using async-await
async function createUser(data={}) {
  const validation = new Shape({
    username: async (username) => {
      if (isString(username) && username.length > 0) {
        const existing = await findUserByUsername(username);
        return existing ? 'username taken' : null;
      } else {
        return 'invalid';
      }
    },

    password: (password) => {
      return isString(password) && password.length >= 7 ? null : 'invalid';
    },

    repeat_password: (repeat_password, {password}) => {
      return repeat_password === password ? null : 'invalid';
    }
  });

  const errors = await validation.errors(data);
  // Errors will be 'null' if all checks pass.
  // If any check fails, errors will be an object that contains error messages.
  // Validation will also fail for keys in data which are not specified when
  // defining a validation

  if (errors) {
    throw errors;
  } else {
    return await insertNewPostInDB(data);
  }
}

// using promises
function createPost(data={}) {
  const validation = new Shape({
    author_id: async (authorId) => {
      const author = await findUserById(authorId);
      return author ? null : `invalid author_id: ${authorId}`;
    },

    title: (title) => {
      return isString(title) ? findPostByTitle(title).then((existing) => {
        return (
          existing ? 'title already taken' : (
            title.length === 0 ? 'title cannot be empty' : null
          )
        );
      }) : 'title must be string';
    },

    body: (body) => {
      if (!isArray(body) || body.filter((p) => isString(p)).length < body.length) {
        return 'body must be a list of paragraph strings';
      } else if (body.length === 0) {
        return 'body cannot be empty';
      } else {
        return null;
      }
    }
  });

  return validation.errors(data).then((errors) => {
    if (errors) {
      return Promise.reject(errors);
    } else {
      return insertNewPostInDB(data);
    }
  });
}
```
npm package: @krab/vent
Description: An isomorphic event-aggregator
Author: Kapil Verma
Latest version: 2.0.0

### vent

### v2.0.0

#### We follow [breaking].[feature].[fix] versioning

`npm install --save @krab/vent`

This module provides a simple-to-use and context-aware event-aggregator.
Usage given below:

##### Importing
```js
import Vent from '@krab/vent'; // in projects with ES7 modules
const Vent = require('@krab/vent/common'); // in projects with common JS modules

const vent = new Vent();

```

##### Basic Usage
```js
const fooListener = () => console.log('foo');

vent.on('foo', fooListener); // attaches 'fooListener' to event 'foo'
vent.emit('foo'); // emits 'foo' and runs all attached listeners
vent.off('foo'); // removes all listeners attached to event 'foo'
vent.off('foo', fooListener); // removes 'fooListener' from event 'foo'

```

##### Once Listener
```js
const onceListener = () => {
  if (onceListener.hasRun) {
    throw new Error('onceListener has run');
  }

  onceListener.hasRun = true;
};
onceListener.hasRun = false;

vent.once('once', onceListener); // 'onceListener' will be run only once for event 'once'
vent.emit('once'); // 'onceListener' will run and will be removed
vent.emit('once'); // 'onceListener' won't run again
```

##### Context Awareness

Event listeners can also be registered in context of an object. This gives us more control over the listeners.
```js
const foo = () => console.log('foo');
const bar = () => console.log('bar');
const baz = () => console.log('baz');

const ctx = {};

vent.on('foo', foo, ctx);
vent.on('bar', bar, ctx);
vent.once('baz', baz, ctx);

vent.emit(ctx, 'foo'); // will run listener 'foo'
vent.emit('bar'); // will NOT run listener 'bar'

vent.off('foo', foo, ctx); // will remove listener 'foo' from the event for context 'ctx'
vent.off('foo', ctx); // will remove all listeners for event 'foo' for context 'ctx'

vent.off(ctx); // will remove all listeners for context 'ctx'
```
npm package: @krad/plainview
Description: HTML5 video player
Author: iam@krad.io
Latest version: 1.3.28

plainview
=========

[![Build Status](https://travis-ci.org/krad/plainview.svg?branch=master)](https://travis-ci.org/krad/plainview)

plainview is a no frills HTML5 video player for HLS content.

It is designed to behave like a standard video/audio tag (Hence the name 'plain view').

It relies on the slugline library for consuming playlists and parsing their media segments.  plainview isn't quite a polyfill, but if you squint it may resemble one.

Customizing plainview is incredibly easy.
It provides a number of functions for controlling playback and a number of events to hook into.  This lends itself to it being useful in a number of environments.  If you just need a vanilla plugin, it will work.  If you're using react, it will also work.

Here is a react component demonstrating how you can skin the player: ** COMING SOON **

Here is a vanilla example showing how plainview can play different types of HLS playlists:  ** COMING SOON **


Testing
=======

plainview uses `tape`, `tap-spec` `browserify`, `babelify`, and `testling` to run a suite of in browser tests.

`tape`, `tap-spec`, and `babelify` are the only libraries packaged as development dependencies.  The other tools need to be available on the system.

To setup an environment for testing, run the following:
```
npm install
npm install browserify testling -g
```

After the above commands have successfully completed you can then run:
```
npm t
```
npm package: @krad/slugline
Description: A library for parsing HLS playlists
Author: krad.tv
Latest version: 1.2.24

slugline
========

[![Build Status](https://travis-ci.com/krad/slugline.svg?branch=master)](https://travis-ci.com/krad/slugline)
[![Coverage Status](https://coveralls.io/repos/github/krad/slugline/badge.svg?branch=master)](https://coveralls.io/github/krad/slugline?branch=master)

slugline is a library for consuming HLS playlists.

It can be used in node.js and in the browser.

### Features

  * ✅ Fetching playlists
  * ✅ Fetching media segments
  * ✅ Parsing Media Playlists
  * ✅ Parsing Master Playlists
  * ✅ Retry logic (timeout, 500, network error, etc)
  * ✅ Parsing Media Segments
    * ✅ Fragmented MP4
    * ✅ Transport Stream
      * ✅ PAT  
      * ✅ PMT
      * ✅ Packetized Elementary Streams
      * ✅ ADTS Streams
  * ✅ Transmuxing transport streams to fragmented mp4
  * ✅ Periodic fetching of event & live playlists
  * ❎ Range Requests

# Usage

*COMING SOON*

# Demos

*COMING SOON*

# Development setup

Dependencies for setting up a development environment are managed with npm.
One needs to simply clone the repo and run `npm install` like so:

```
$ git clone https://github.com/krad/slugline.git slugline
$ cd slugline
$ npm install
```

# Testing

## Preparation

The test suite relies on some fixtures that are too large to be distributed along with the library.
A fetch script is included and relies on [wget](https://www.gnu.org/software/wget/) to retrieve assets.

To prepare the environment simply run:
```
$ ./tests/fixtures/fetch.sh
```

And wait for all the assets to download.

## Running tests

### Unit tests

`npm run test`

### Autotesting

`npm run autotest`
npm package: @kradihsoy/lt-schematics
Description: A schematics for NestJS to generate mongoose models from Libertech
Latest version: 1.0.13

# Presentation

This project was generated with [Angular CLI]

## Requirements

- [Node.js](https://nodejs.org/en/) (>= 10.13.0)
- [Nest CLI](https://docs.nestjs.com/cli/overview) (>= 7.0.0)

## Publish

Commit the changes and run `npm run publish:<option>` or `yarn publish:<option>` to publish the schematics.

<option> can be `patch`, `minor` or `major`.

## Install

Run `npm install @kradihsoy/lt-schematics` to install the schematics.

Yarn : `yarn add @kradihsoy/lt-schematics`

## Usage

Run `nest generate -c @kradihsoy/lt-schematics mongoose <name> <path> <spec> <dto> <skipImport>` to generate a new component.

## Options

| Option | Type | Default | Description | Required |
| ------ | ---- | ------- | ----------- | -------- |
| name | string |  | The name of the component. | true |
| path | string | src | The path to create the component. | false |
| spec | boolean | true | Specifies if a spec file is generated. | false |
| dto | boolean | true | Specifies if a dto file is generated. | false |
| skipImport | boolean | false | Specifies if the module imports are skipped. | false |
npm package: @kraekke/agent-docs
Description: Documentation framework for AI-assisted development with Claude Code
Author: lex
Latest version: 1.0.8

# Agent Docs

A documentation framework for AI-assisted software development with Claude Code.

## Install

```bash
npx @kraekke/agent-docs
```

After installing, run `/deploy` to set up the agent docs in your project

## Update

```bash
npx @kraekke/agent-docs@latest --update
```

## Usage

Each fresh session run `/boot` to start working with the framework.

## What It Does

Provides structure for AI agents to understand your project through:
- Knowledge files that capture decisions and context
- Skills that extend agent capabilities
- Workspace for active iterations

The `.agent/` directory contains the framework internals. Start there with `boot-context.md` if you're an AI agent reading this.