open-index/open-npm huggingface dataset:
npm package: @quillai-network/mandate-verification-sdk
Description: A complete SDK for building, signing, verifying, and validating Mandates in the ERC-8004 agent ecosystem
Author: QuillAINetwork
Latest version: 0.1.0

# Mandate Verification SDK

Lightweight TypeScript SDK for submitting mandate validation requests through QuillAI Validation Router. The package currently exposes a single entry point:

- `ValidationClient` – pins proof data to Pinata and calls the Validation Registry contract.

## Installation

```bash
npm install @quillai-network/mandate-verification-sdk ethers
```

The published artifact targets modern ESM runtimes (Node.js ≥ 18) and ships compiled JS plus type definitions.

## Quick start

```ts
import { ValidationClient } from '@quillai-network/mandate-verification-sdk';
import { swapV1 } from '@quillai-network/primitives';

const validationClient = new ValidationClient({
  pinataJwt: process.env.PINATA_JWT!,
  pinataGateway: 'https://gateway.pinata.cloud',
  privateKey: process.env.PRIVATE_KEY!,
  rpcUrl: process.env.SEPOLIA_RPC!,
  chain: 'ethereum-sepolia',
});

const proof = await validationClient.uploadProof({
  agentId: '1475',
  timestamp: Date.now(),
  result: 'Swap executed successfully.',
  executionId: 'execution_123',
  txHash: '0xabc...',
  actionDetails: swapV1({
    chainId: 11155111,
    tokenIn: '0x...',
    tokenOut: '0x...',
    amountIn: '1000000000000000000',
    minOut: '950000000000000000',
    recipient: '0x...',
    deadline: '0',
  }),
  mandate: mandateJson,
});

const { requestUri, hashBytes, transactionHash } =
  await validationClient.requestValidation(proof.cid);

console.log({ requestUri, hashBytes, transactionHash });
```

Chain defaults include the validator address and agent ID for Ethereum Sepolia. Override `validatorAddress`, `agentId`, or `validationContractAddress` in the config when targeting a different deployment. You can also supply a custom `requestHashSeed` to `requestValidation` if the hash must be computed externally.

## Development

```bash
npm install
npm test    # runs the simple ValidationClient integration smoke test
npm run build
```

`npm run build` compiles sources to `dist/` and emits declaration files. `npm publish` automatically runs clean/test/build via `prepublishOnly`.

## License

MIT © QuillAI-Network
npm package: @quillai-network/primitives
Description: Builders for Mandate primitives. No runtime validation yet — just ergonomic helpers to construct { kind, payload } cores.
Author: QuillAINetwork
Latest version: 0.1.1

# Primitives


The repository defines reusable task templates (called *Primitives*) for building Mandates in the [ERC-8004 agent ecosystem](https://eips.ethereum.org/EIPS/eip-8004).
Each Primitive represents a structured task body (`core`) that can be embedded inside a Mandate.

---

## Purpose

* Provide common, shareable payload definitions for agent-to-agent tasks
* Keep Mandates lightweight while standardizing common types like `swap@1` or `bridge@1`
* Enable developers to create and extend primitives with minimal boilerplate

---

## Example Usage

```ts
import { swapV1 } from "@quillai/primitives";
import { Mandate } from "@quillai/mandates-core";

const primitive = swapV1.core({
  chainId: 1,
  tokenIn: "0xA0b8...6eB48",
  tokenOut: "0x2260...C599",
  amountIn: "100000000",
  minOut: "165000",
  recipient: "0x0000000000000000000000000000000000000001",
  deadline: "2025-12-31T00:00:00Z"
});

const mandate = new Mandate({
  client: "eip155:1:0xCLIENT...",
  server: "eip155:1:0xSERVER...",
  intent: "Swap 100 USDC for WBTC on mainnet",
  core: primitive
});
```

---

## Structure

```
primitives-registry/
├─ src/
│  ├─ primitives/
│  │  └─ swap/
│  │     └─ swap@1.ts
│  ├─ index.ts
│  └─ types.ts
├─ tests/
│  └─ swap.test.ts
├─ README.md
├─ LICENSE
└─ package.json
```

---

## License

Released under the **MIT License**.

---

Would you like me to extend this README with a short “Contributing” section (similar to your other repo) to make it consistent across both?
npm package: @quillmeetings/manus-mcp
Description: MCP server for the Manus AI Agent API
Latest version: 1.0.0

# @quillmeetings/manus-mcp

MCP server for the [Manus AI Agent API](https://open.manus.im/docs). Exposes Manus tasks, projects, and files as tools for Claude and other MCP clients.

## Setup

### 1. Get an API key

Generate one at https://manus.im/app#settings/integrations/api

### 2. Configure your MCP client

**Claude Code:**

```bash
claude mcp add manus -e MANUS_API_KEY=your-key-here -- npx @quillmeetings/manus-mcp
```

**MCP settings JSON:**

```json
{
  "mcpServers": {
    "manus": {
      "command": "npx",
      "args": ["@quillmeetings/manus-mcp"],
      "env": {
        "MANUS_API_KEY": "your-key-here"
      }
    }
  }
}
```

## Tools (12)

### Tasks (6)

| Tool | Description |
|------|-------------|
| `create_task` | Create a new Manus AI agent task. Returns immediately — poll with `get_task`. Optionally attach a file via `file_url`. |
| `get_task` | Get task status, output, and credit usage. Poll until `completed` or `failed`. |
| `list_tasks` | List tasks with filters (status, date range, project, query). Supports cursor pagination. |
| `update_task` | Update task title, sharing, or visibility. |
| `delete_task` | Permanently delete a task. |
| `continue_task` | Send a follow-up message for multi-turn conversation on a completed task. |

### Projects (2)

| Tool | Description |
|------|-------------|
| `create_project` | Create a project to organize tasks with optional default instructions. |
| `list_projects` | List all projects. |

### Files (4)

| Tool | Description |
|------|-------------|
| `create_file` | Create a file record and get a presigned S3 upload URL. |
| `list_files` | List recently uploaded files. |
| `get_file` | Get file details by ID. |
| `delete_file` | Delete a file. |

## Typical workflow

```
User: "Use Manus to research competitor pricing for Acme Corp"

1. create_task({ prompt: "Research competitor pricing..." })
   → { task_id: "abc123", task_url: "https://manus.im/app/abc123" }

2. Share task_url with user, wait ~1-5 minutes

3. get_task({ task_id: "abc123" })
   → { status: "completed", output: [...], credit_usage: 200 }

4. Present results to user
```

## Environment variables

| Variable | Required | Description |
|----------|----------|-------------|
| `MANUS_API_KEY` | Yes | API key from Manus settings |

## Development

```bash
npm install
npm test          # watch mode
npm run test:run  # single run
npm run build     # compile TypeScript
npm run inspector # MCP inspector
```
npm package: @quillsql/components
Description: Quill React Component Library
Author: quill-sql
Latest version: 1.1.2

# Quill Components

Quill React Component Library

## Install

```bash
npm i @quillsql/components
```

## Basic usage

```jsx
import React, { useState } from 'react'
import { QuillProvider, Dashboard } from '@quillsql/components'

function App() {
  const [user] = useState(null)
  return (
    <QuillProvider
      publicKey={API_KEY}
      theme={THEME}
      authToken={user.jwt}
      userId={user.id}
    >
      <Dashboard
        name='spend_insights'
        containerStyle={{
          height: '100vh',
          width: '100vw',
          background: 'white'
        }}
      />
    </QuillProvider>
  )
}
```
npm package: @quilt/install
Description: This repo contains a Node.js package for easily installing [Quilt](http://quilt.io) using npm.
Latest version: 0.4.2

This repo contains a Node.js package for easily installing
[Quilt](http://quilt.io) using npm.

To pull the compiled binaries off GitHub, and install them:
```
$ npm install -g @quilt/install
```
Note that the `-g` flag is necessary to install the binaries globally (i.e. so
that `quilt` can be invoked from anywhere).

If installing as root, the `--unsafe-perm` flag is required:
```console
$ sudo npm install -g @quilt/install --unsafe-perm
```
npm package: @quilted/create
Description: This package provides a command line tool for generating new Quilt projects.
Latest version: 0.3.5

# `@quilted/create`

This package provides a command line tool for generating new Quilt projects.

When run inside an existing [Quilt workspace](../../documentation/projects.md), this command will add additional [apps](../../documentation/projects/apps) or [packages](../../documentation/projects.md#packages) to the same workspace.

You can also run it outside an existing repository, and it will create a new repository with a Quilt app or package. This new repo can be configured either as a “monorepo”, with room for additional projects, or as a repo just focused on a single project.

The best way to use this command is to run the `create` command in your favorite package manager. Quilt supports [npm](https://docs.npmjs.com/about-npm), [yarn](https://yarnpkg.com), and [pnpm](https://pnpm.io).

```bash
pnpm create @quilted # for pnpm
npm create @quilted # for npm
yarn create @quilted # for yarn
```

> **Note:** If you don’t already have a favorite package manager, we recommend [pnpm](https://pnpm.io). pnpm is fast, takes up less space on disk, and produces a strict package installation that enforces dependency management best practices.

This command will ask you what type of project you want to create. If you want to jump right to creating a particular kind of project, you can pass it as an additional argument to this command:

```bash
pnpm create @quilted app # create an app with pnpm
npm create @quilted package # create a package with npm
```

This command also accepts many command-line flags to pre-answer the questions you will be asked when creating your project. To learn more about these flags, run the command with the `--help` flag:

```bash
pnpm create @quilted --help
```
npm package: @quilted/htmx
Description: Handy utilities for writing htmx servers using JavaScript
Latest version: 0.2.0

# `@quilted/htmx`

Handy utilities for writing [htmx](https://htmx.org) servers using JavaScript.

## Installation

```bash
# npm
npm install @quilted/htmx --save
# pnpm
pnpm install @quilted/htmx --save
# yarn
yarn add @quilted/htmx
```

## Usage

### `parseHTMXRequestHeaders()`

Parses the [HTMX request headers](https://htmx.org/docs/#request-headers) into an easy-to-use JavaScript object. If the request does not contain the mandatory HTMX headers, this function will return `undefined`.

```ts
import {parseHTMXRequestHeaders} from '@quilted/htmx';

const headers = new Headers();
headers.set('HX-Request', 'true');
headers.set('HX-Current-URL', 'https://my-website.com');
headers.set('HX-Trigger', 'my-button');

const parsed = parseHTMXRequestHeaders(headers);
// {currentURL: new URL('https://my-website.com'), trigger: 'my-button'}
```

### `HTMXRequest`

`HTMXRequest` is a subclass of the `Request` constructor and Quilt’s `EnhancedRequest`, which adds automatic parsing of the cookie header and request URL. This request constructor automatically parses the headers using `parseHTMXRequestHeaders()`, and stores the result in the `htmx` property. If this request does not have the necessary headers, `HTMXRequest` will throw.

```ts
export default function fetch(request: Request) {
  const htmxRequest = new HTMXRequest(request);
  const {trigger} = htmxRequest.htmx;

  if (trigger == null) {
    return new Response('No trigger found', {status: 400});
  }

  return new Response(`Trigger: ${trigger}`);
}
```

### `setHTMXResponseHeaders()`

Applies the [HTMX response headers](https://htmx.org/docs/#response-headers) from an easy-to-use JavaScript object.

```ts
import {setHTMXResponseHeaders} from '@quilted/htmx';

const headers = new Headers();

const parsed = setHTMXResponseHeaders(headers, {
  target: 'body',
  trigger: ['my-event'],
  triggerAfterSettle: [
    {
      event: 'my-after-settle-event',
      detail: {foo: 'bar'},
    },
  ],
});
```

### `HTMXResponse`

`HTMXResponse` is a subclass of the `Response` constructor and Quilt’s `EnhancedResponse`, which adds cookie-related utilities. This request constructor automatically sets the HTMX headers using `setHTMXResponseHeaders()`.

```ts
import {HTMXResponse} from '@quilted/htmx';

export default function fetch() {
  return new HTMXResponse('Here’s your new content!', {
    htmx: {
      target: 'body',
      trigger: ['my-event'],
      triggerAfterSettle: [
        {
          event: 'my-after-settle-event',
          detail: {foo: 'bar'},
        },
      ],
    },
  });
}
```
npm package: @quilted/http
Description: Provides a collection of HTTP-related types and utilities.
Latest version: 0.3.0

# `@quilted/http`

This library provides a collection of HTTP-related types and utilities.

## Getting the library

> **Note:** `@quilted/quilt/http` and `@quilted/react-http` re-export all of the types from this library. If you already have either `@quilted/quilt` or `@quilted/react-http`, you can use the exports from those libraries instead of `@quilted/http`.

Install this library as a dependency by running the following command:

```zsh
yarn add @quilted/http
```

## Using the library

This library provides the following helper types, which each represent some aspect of interacting with HTTP:

- `HttpMethod`, an enum representing [the allowed HTTP methods](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods)
- `StatusCode`, an enum representing the [standard response status codes](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status)
- `ResponseType`, an enum representing the [standard response status code classes](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status)
- `ReadonlyHeaders`, which is a subset of the `Headers` type that represents headers that can’t be mutated (like those on some `Request` objects).
- `Cookies`, `ReadonlyCookies`, and `CookieOptions`, a set of interfaces that provide an isomorphic pattern for getting and setting [cookies](https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies)
- `ContentSecurityPolicyDirective`, `ContentSecurityPolicySandboxAllow`, and `ContentSecurityPolicySpecialSource`, enums that provide friendly names for creating a [content security policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP)
- `PermissionsPolicyDirective` and `PermissionsPolicySpecialSource`, enums that provide friendly names for creating a [permissions policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Feature-Policy)

### Using this library as types

Many of the types in this library are provided as enums. Enums are convenient for developers, because they let you avoid having plain strings or numbers all over the codebase; that is, many developers prefer:

```ts
import {StatusCode} from '@quilted/http';

const statusCode = StatusCode.NotFound;
```

Over:

```ts
const statusCode = 404;
```

While enums are convenient, they have a runtime cost, because the whole enum is included in the output bundles even if only a single enum value is used. For this reason, we recommend any library that uses `@quilted/http` use type imports to reference the enums in this package:

```ts
import type {StatusCode} from '@quilted/http';
// instead of
// import {StatusCode} from '@quilted/http';

export function myFunctionThatUsesStatusCode(code: StatusCode) {}
```

This allows consumers of your library to get type safety on the allowed values, but without forcing consumers to include the entire enum in their bundle if they’d prefer to use these types exclusively as types.

```ts
import {StatusCode} from '@quilted/http';

// Works when using the enum...
myFunctionThatUsesStatusCode(StatusCode.NotFound);

// And when using static values:
myFunctionThatUsesStatusCode(404);
```
npm package: @quilted/preact-router
Description: A universal router for React with first-class support for the [WHATWG `URL`](https://developer.mozilla.org/en-US/docs/Web/API/URL) and preloading.
Latest version: 0.2.18

# `@quilted/react-router`

A universal router for React with first-class support for the [WHATWG `URL`](https://developer.mozilla.org/en-US/docs/Web/API/URL) and preloading.
npm package: @quilted/react-async
Description: ```tsx import {useAsync} from '@quilted/react-async';
Latest version: 0.4.2

# `@quilted/react-async`

```tsx
import {useAsync} from '@quilted/react-async';

function MyComponent() {
  const result = useAsync(
    async () => {
      const response = await fetch('https://api.example.com/data');
      return response.json();
    },
    {
      server: true,
    },
  );

  if (result.pending) {
    return <LoadingSpinner />;
  }

  if (result.error) {
    return <ErrorMessage error={result.error} />;
  }

  return <DataDisplay data={result.value} />;
}
```

```tsx
import {useAsyncModule, AsyncModule} from '@quilted/react-async';

const asyncModule = new AsyncModule(() => import('./my-module.ts'));

console.log(asyncModule.status);
console.log(asyncModule.imported);
console.log(asyncModule.reason);
console.log(asyncModule.url.href);
const loaded = await asyncModule.import();
const loaded2 = await asyncModule.promise;

function MyComponent() {
  const {moduleMethod} = useAsyncModule(asyncModule);

  return <DataDisplay data={moduleMethod()} />;
}

function MyComponent2() {
  if (asyncModule.status !== 'fulfilled') {
    return <button onClick={() => asyncModule.import()}>Load it!</button>;
  }

  const {moduleMethod} = asyncModule.imported!;

  return <DataDisplay data={moduleMethod()} />;
}
```

```tsx
import {AsyncModule, AsyncComponent} from '@quilted/react-async';

const module = new AsyncModule(() => import('./MyComponent.tsx'));

<AsyncComponent
  module={module}
  render={({default: Component}) => <Component />}
/>;

const MyComponent = AsyncComponent.from(module, {
  renderLoading: <LoadingSpinner />,
});

<MyComponent />;
```
npm package: @quilted/react-router
Description: A universal router for React with first-class support for the [WHATWG `URL`](https://developer.mozilla.org/en-US/docs/Web/API/URL) and preloading.
Latest version: 0.4.1

# `@quilted/react-router`

A universal router for React with first-class support for the [WHATWG `URL`](https://developer.mozilla.org/en-US/docs/Web/API/URL) and preloading.
npm package: @quilted/use-subscription
Description: > **Note:** This package is deprecated in favor of `useSyncExternalStore` from React.
Latest version: 0.3.0
Deprecated: Use React/ Preact’s built-in useSyncExternalStore

# `@quilted/use-subscription`

> **Note:** This package is deprecated in favor of `useSyncExternalStore` from React.

Fork of https://github.com/facebook/react/tree/master/packages/use-subscription that can be used as a module.
npm package: @quilted/useful-react-types
Description: A collection of useful TypeScript types for React projects
Latest version: 2.0.0
Deprecated: Use React types directly

# `@quilted/useful-react-types`

A collection of useful TypeScript types for React projects.

## Installation

```bash
# npm
npm install @quilted/useful-react-types --save-dev
# pnpm
pnpm install @quilted/useful-react-types --save-dev
# yarn
yarn add @quilted/useful-react-types --dev
```

## Usage

Please refer to the inline documentation for explanations of how to use each helper type provided by this module.
npm package: @quilted/useful-types
Description: A collection of useful TypeScript types
Latest version: 2.0.0

# `@quilted/useful-types`

A collection of useful TypeScript types.

## Installation

```bash
# npm
npm install @quilted/useful-types --save-dev
# pnpm
pnpm install @quilted/useful-types --save-dev
# yarn
yarn add @quilted/useful-types --dev
```

## Usage

Please refer to the inline documentation for explanations of how to use each helper type provided by this module.
npm package: @quim80/use-socketio
Description: React hooks for https://socket.io/
Author: Marvin Frachet
Latest version: 3.0.2

Use [socket.io v4](https://socket.io/) with React, in hooks (React v16.8+).

# Usage

## Installation

```sh
$ yarn add @tomas2387/use-socketio
```

## In your code

### useSocket hook

Listen to a specific event and trigger the according callback every time there's one. **This hooks doesn't trigger a re-render. You have to manage it yourself.**

```jsx
import { SocketIOProvider, useSocket } from "use-socketio";

const Twitter = () => {
  const [tweets, setTweet] = useState([]);

  const { socket, subscribe, unsubscribe } = useSocket("tweet", (newTweet) =>
    setTweet([newTweet, ...tweets])
  );

  return tweets.length ? (
    <ul>
      {tweets.map((tweet) => (
        <li key={tweet.id}>{tweet.text}</li>
      ))}
    </ul>
  ) : (
    <p>Actually waiting for the websocket server...</p>
  );
};

const App = () => (
  <SocketIOProvider url="http://localhost:3000" opts={socketIoOptions}>
    <Twitter />
  </SocketIOProvider>
);
```

_The socketio options to pass to the provider are available here: https://socket.io/docs/client-api/#new-Manager-url-options._

### useLastMessage hook

Listen to the latest message received on a specific event name. **This hook triggers a re-render so you don't have to.**

```jsx
import { SocketIOProvider, useLastMessage } from "use-socketio";

const Twitter = () => {
  const { data: lastMessage, socket, subscribe, unsubscribe } = useLastMessage(
    "tweet"
  );

  return <p>{lastMessage || "Waiting for some tweets"}</p>;
};

const App = () => (
  <SocketIOProvider url="http://localhost:3000">
    <Twitter />
  </SocketIOProvider>
);
```

## Notes

For example on how to implement a Socket.io server, you can take a look at the [socket.io the example folder](../../example/socketio/socketio-server.js).
npm package: @quimiweb/ui-kit
Description: ## How to start:
Author: Quimiweb
Latest version: 1.0.5

# Nubler UIKit

## How to start:

- Run "yarn";
- Run "yarn storybook";

## Requirements library:

- [x] Enable EsLint;
- [x] Enable Prettier;
- [x] Enable Storybook;

## Generic requirements for components:

- [x] Support themes;

## Components:

- [x] Input:
  - [x] Multiple sizes(sm, md and lg);
  - [x] Multiple variants(bordered and solid);
  - [x] Multiple states(error, success and info);
    - [x] With label;
  - [x] Can insert icon;
  - [x] Can have label;
  - [x] Can have top button with action;
- [ ] Select:
  - [ ] Multiple sizes(sm, md and lg);
  - [ ] Multiple variants(bordered and solid);
  - [ ] Multiple states(error, success and info);
    - [ ] With label;
  - [ ] Can have label;
  - [ ] Can have top button with action;
- [x] TextArea:
  - [x] Multiple variants(bordered and solid);
  - [x] Multiple states(error, success and info);
    - [x] With label;
  - [x] Can have label;
- [x] Checkbox:
  - [x] Multiple states(error, success and info);
    - [x] With label;
  - [x] Can have label;
- [x] RadioButton:
  - [x] Multiple states(error, success and info);
    - [x] With label;
  - [x] Can have label;
- [x] Button and Link:
  - [x] Multiple sizes(sm, md and lg);
  - [x] Multiple variants(bordered, solid and text);
  - [x] Loading state;
  - [x] Can have icon;
  - [x] Can have label;
- [x] Text:
  - [x] Multiple sizes(sm, md and lg);
  - [x] Can receive as “component”;
- [x] Tooltip:
  - [x] Can have position for change tooltip location;
  - [x] Can have label;
- [x] Modal:
  - [x] Can have state(opened or not);
- [x] Tag:
  - [x] Can have icon;
  - [x] Can have label;
- [x] Drawer;
- [x] Spinner;
- [x] Grid;
- [x] Wrapper;
- [x] Skeleton;
npm package: @quinaryio/react-native-doc-viewer
Description: React Native Native Module Bridge Quicklock Document Viewer for IOS + Android supports pdf, png, jpg, xls, ppt, doc, docx, pptx, xlx + Video Player mp4 supported 
Author: Philipp Hecht
Latest version: 1.1.0

https://github.com/g-ioannidi5/react-native-doc-viewer/blob/master/README.md
npm package: @quincarter/test-js-component
Description: ## Install
Latest version: 0.0.2

# TestJsComponent Web Component

## Install

```bash
npm i -s @quincarter-components/test-js-component
```

or with `yarn`

```bash
yarn add @quincarter-components/test-js-component
```

## Usage

```html
<test-js-component></test-js-component>
```

### Development

- Update package.json with scripts needed for testing or additional functions
npm package: @quincyx/deploy-toolkit
Description: Quincy's sftp deploy toolkit
Author: likequincy@outlook.com
Latest version: 0.1.1

# quincy's sftp deploy tool

## Usage

- 引入依赖

```javascript
npm i @quincyx/deploy-toolkit -D
```

- 创建脚本

在项目根目录下创建文件 `deploy.js`

```javascript
const path = require('path')
const deployTool = require('@quincyx/deploy-toolkit')

const option = {
  server: {
    host: '0.0.0.0',
    port: '22',
    username: '',
    password: '',
    privateKey:'',
    remotePath: '/www/web',
    localPath: path.resolve(__dirname, './dist'),
  },
  project: {
    name: config.name,
    version: config.version,
    url: 'https://www.null.com'
  },
  git: {
    enable: true,
    version: 'patch'
  },
  webhook: {
    enable: true,
    type: 'work_wx',
    key: 'work_wx_bot_key'
  }
}

deployTool.start(option)

```

- 添加到 npm script

在 package.json 中添加部署脚本

```json
"scripts": {
  "build:test": "vue-cli-service build --mode test",
  "deploy:test": "vue-cli-service build --mode test && node deploy.js"
}
```
npm package: @quincyx/less-toolkit
Description: Quincy's less toolkit
Author: QuincyX
Latest version: 0.1.0

# less-toolkit
> Quincy's less 工具包

## 使用方法

### 安装
```shell
npm i @quincyx/less-toolkit -D
```

### 修改 vue.config.js

```javascript
const path = require('path')
function resolve(dir) {
  return path.join(__dirname, dir)
}
const qLessToolkit = require('@quincyx/less-toolkit')

module.exports = {
  css: {
    loaderOptions: {
      less: {
        plugins: [
          new qLessToolkit({
            extend: [
              resolve('./src/style/theme.less'),
              resolve('./src/style/mixin.less')
            ]
          })
        ],
        javascriptEnabled: true
      }
    }
  }
}
```
### 配置

`extend`可添加自定义变量和mixin，将覆盖系统默认值
npm package: @quincyx/prettier-config
Description: QuincyXu Prettier config
Author: QuincyXu
Latest version: 1.0.0

# `@QuincyX/prettier-config`

> QuincyXu [Prettier](https://prettier.io) config.

## Usage

**Install**:

```bash
$ pnpm i -D @QuincyX/prettier-config
```

**Edit `package.json`**:

```jsonc
{
  // ...
  "prettier": "@QuincyX/prettier-config"
}
```
npm package: @quincyx/tinymce-vue-q
Description: > simple, fast, all in one
Author: QuincyX
Latest version: 0.1.17

# TinyMCE Vue Q

> simple, fast, all in one


### Installation

```
npm i @quincyx/tinymce-vue-q
```

### Quick Example

import
```
// src/main.js

import tinyMceQ from '@quincyx/tinymce-vue-q'
import '@quincyx/tinymce-vue-q/dist/style.css'

app.use(tinyMceQ)
```

usage
```
// src/App.vue

<template>
  <TinyMceQ v-model="editorValue" />
</template>

<script setup>
import { ref } from 'vue'
const editorValue = ref('')
</script>
```

### Options

change default language
```
app.use(tinyMceVueQ, { language: 'en' })
```


### Dependency

- vite >= 4.0
- vue >= 3.0

### Includes

- tinyMCE official release (by npm)
- tinyMCE official plugin
- default theme config
- default locale: zh_CN
- some optimize config
- allow multiple instance

### Current

- tinymce v6.8

### TODO

- [ ] optimize content-css
- [ ] optimize icons
- [ ] image upload handler
- [ ] powerPaste
npm package: @quinhas/config-eslint
Description: ESLint configuration used by Lucas Santana
Author: Lucas Santana
Latest version: 1.0.5

# Quinhas ESLint configuration

## Whats included?

- Standard config base;
- React plugin;
- React Hooks plugin;
- JSX a11y plugin;
- Prettier;

## Setup

1. Install this package as devDependency

```sh
# with Yarn
$ yarn add -D @quinhas/config-eslint

# with npm
$ npm i -D @quinhas/config-eslint

# with pnpm
$ pnpm add -D @quinhas/config-eslint
```

2. Create a `.eslintrc.js` file in project root with the following content:

```js
module.exports = {
  extends: ['@quinhas/config-eslint/react'],
  // extends: ["@quinhas/config-eslint/node"],
};
```

> You can also use a `.eslintrc.json` instead of js if you prefer.
npm package: @quinhas/config-prettier
Description: Prettier configuration used by Lucas Santana
Author: Lucas Santana
Latest version: 1.0.3

# Quinhas Prettier configuration

## Setup

1. Install this package as devDependency

```sh
# with Yarn
$ yarn add -D @quinhas/config-prettier

# with npm
$ npm i -D @quinhas/config-prettier

# with pnpm
$ pnpm add -D @quinhas/config-prettier
```

2. Create a `.prettierrc` file in project root with the following content:

```
"@quinhas/config-prettier"
```
npm package: @quinico/cardmake
Description: cardmake
Author: Matthew J. Melendez
Latest version: 0.2.1

# cardmake

A command line tool to turn a collection of images into print-and-play poker cards. 

## Installation

1. Install Node.JS
2. Run the following command in the command line:

```
npm install -g @quinico/cardmake
```

### Updating Cardmake

If you ever want to update your copy of cardmake on your computer, run the following command:

```
npm update -g @quinico/cardmake
```

### Uninstall Cardmake

Run the following command in the command line:

```
npm uninstall -g cardmake
```

## Using Cardmake

> Note: Cardmake only supports **PNG** and **JPG** files. Any other files in the folder (.gif, .pdf, .docx, etc.) will be ignored.

1. Place the images (png or jpg) you want to use into one folder.
2. Open the command prompt and navigate to the folder.
3. Run cardmake
4. Party!
npm package: @quinninc/pixi-transformer
Description: Works with pixi.js v8 and above.
Author: Rohit Kaushal
Latest version: 0.1.8

# Free Transform Tool for PIXI.js

Works with pixi.js v8 and above.

![preview](https://cdn.quinn.live/transformer-image.png)

### ✨ Features

- Translate - Drag to move anywhere
- Scale - Scale on X, Y or both axis'
- Rotate - drag to rotate
- Anchor point - update anchor point of transforms (AltLeft + Click or Drag)
- Snapping - snap rotation at 45degrees, snap anchor point to edges and corners (hold ShiftLeft).
- Theming - custom border color, control size and color, and anchor point graphic

> Note - all transformations are applied wrt the pivot point, update pivot point to achieve the desired result.

## Installation

```bash
npm install @quinninc/pixi-transformer
```

## Usage

```tsx
const root = new Container();
app.stage.addChild(root);

// create tool and add to stage
const selectTool = new FreeTransformTool();
selectTool.label = "transform-tool";
root.addChild(selectTool);

const obj = new Sprite({
  texture: Texture.from("lenna"),
  label: "lenna",
  eventMode: "static",
});

root.addChild(obj);

obj.on("pointertap", (ev) => {
  console.log("select - ", ev.currentTarget.label);
  selectTool.select(ev.currentTarget);
});
```

## API

### `FreeTransformTool` (class)

**Constructor Parameter Object:**

- `lineColor` - border line color. default - `0x66cfff`
- `handleColor` - (`number`) - handles' fill color. default - `0xffffff`
- `controlsSize` - (`number`) - handles' size in pixels. default - `10`
- `debug` - (`boolean`) - show scaling distance debug lines. default - `false`
- `generateAnchorMark` - a function to generate your custom anchor mark. default - `undefined` (uses default anchor mark)
- `pivotKeys` - (`string[]`) - keys to hold to change pivot point. default - `['AltLeft']` - [List of KeyCodes](https://www.freecodecamp.org/news/javascript-keycode-list-keypress-event-key-codes#a-full-list-of-key-event-values)
- `snapKeys` - (`string[]`) - keys to hold to snap to grid. default - `['ShiftLeft']`

**returns:** `PIXI.Container` (the select tool)
npm package: @quinnlive/shoppable-videos
Description: A react component to render products as swiper cards with videos
Author: Shubhankar Das
Latest version: 1.4.0

# @quinnlive/shopable-videos

> Made with create-react-library

[![NPM](https://img.shields.io/npm/v/@quinnlive/shopable-videos.svg)](https://www.npmjs.com/package/@quinnlive/shopable-videos) [![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

## Install

```bash
npm install --save @quinnlive/shopable-videos
```

## Usage

```jsx
import {useState} from "react";
import {ProductSwiper} from "@quinnlive/shopable-videos";

function App() {
  const [cartItems, setCartItems] = useState([]);

  const handleAddtoCart = (product) => {
    console.log(product);
  };

  return (
    <ProductSwiper
      apiKey=""
      cartItems={cartItems}
      onAddToCart={handleAddtoCart}
      config={{
        cartUrl: "/cart"
        swiperMargin: 50,
      }}
    />
  );
}

export default App;
```

## License

MIT © [razbotics](https://github.com/razbotics)
npm package: @quinnvoker/babel-preset-react-app
Description: Babel preset used by Create React App, forked by quinnvoker for LHL use with webpack 4
Latest version: 10.0.0

# babel-preset-react-app

This package includes the Babel preset 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.

## Usage in Create React App Projects

The easiest way to use this configuration is with [Create React App](https://github.com/facebook/create-react-app), which includes it by default. **You don’t need to install it separately in Create React App projects.**

## Usage Outside of Create React App

If you want to use this Babel preset in a project not built with Create React App, you can install it with the following steps.

First, [install Babel](https://babeljs.io/docs/setup/).

Then install babel-preset-react-app.

```sh
npm install babel-preset-react-app --save-dev
```

Then create a file named `.babelrc` with following contents in the root folder of your project:

```json
{
  "presets": ["react-app"]
}
```

This preset uses the `useBuiltIns` option with [transform-object-rest-spread](https://babeljs.io/docs/plugins/transform-object-rest-spread/) and [transform-react-jsx](https://babeljs.io/docs/plugins/transform-react-jsx/), which assumes that `Object.assign` is available or polyfilled.

## Usage with Flow

Make sure you have a `.flowconfig` file at the root directory. You can also use the `flow` option on `.babelrc`:

```json
{
  "presets": [["react-app", { "flow": true, "typescript": false }]]
}
```

## Usage with TypeScript

Make sure you have a `tsconfig.json` file at the root directory. You can also use the `typescript` option on `.babelrc`:

```json
{
  "presets": [["react-app", { "flow": false, "typescript": true }]]
}
```

## Absolute Runtime Paths

Absolute paths are enabled by default for imports. To use relative paths instead, set the `absoluteRuntime` option in `.babelrc` to `false`:

```
{
  "presets": [["react-app", { "absoluteRuntime": false }]]
}
```