open-index/open-npm huggingface dataset:
npm package: @pier-wallet/react-native-cloud-storage
Description: Save to & read from iCloud and Google Drive using React Native
Author: Kuatsu App Agency
Latest version: 1.2.0

# ☁️ react-native-cloud-storage

Save to & read from iCloud and Google Drive using React Native

![npm bundle size](https://img.shields.io/bundlephobia/min/react-native-cloud-storage?style=flat-square) ![GitHub](https://img.shields.io/github/license/kuatsu/react-native-cloud-storage?style=flat-square) ![GitHub last commit](https://img.shields.io/github/last-commit/kuatsu/react-native-cloud-storage?style=flat-square)

## Installation

```sh
npm install react-native-cloud-storage
# or
yarn add react-native-cloud-storage
```

## Documentation

The documentation is located [here](https://react-native-cloud-storage.oss.kuatsu.de/docs/intro).

## Contributing

See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.

## Example Project

There's a demo application available within the `example` directory. To use the Google Drive implementation for Android (and any other platforms except iOS), you'll need to provide a valid access token for the Google Drive API. You can create one using the [Google OAuth 2.0 Playground](https://developers.google.com/oauthplayground). If you're using an Android emulator, you can make your life easier by feeding the token into the emulator using `adb shell input text '{some_token}'`.

## License

MIT

---

Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)
npm package: @pier-wallet/trpc-10-client
Description: The tRPC client library
Author: KATT
Latest version: 10.37.1

<p align="center">
  <a href="https://trpc.io/"><img src="https://assets.trpc.io/icons/svgs/blue-bg-rounded.svg" alt="tRPC" height="75"/></a>
</p>

<h3 align="center">tRPC</h3>

<p align="center">
  <strong>End-to-end typesafe APIs made easy</strong>
</p>

<p align="center">
  <img src="https://assets.trpc.io/www/v10/v10-dark-landscape.gif" alt="Demo" />
</p>

# `@trpc/client`

> Communicate with a tRPC server on the client side.

## Documentation

Full documentation for `@trpc/client` can be found [here](https://trpc.io/docs/vanilla)

## Installation

```bash
# npm
npm install @trpc/client

# Yarn
yarn add @trpc/client

# pnpm
pnpm add @trpc/client

# Bun
bun add @trpc/client
```

## Basic Example

```ts
import { createTRPCProxyClient, httpBatchLink } from '@trpc/client';
// Importing the router type from the server file
import type { AppRouter } from './server';

// Initializing the tRPC client
const trpc = createTRPCProxyClient<AppRouter>({
  links: [
    httpBatchLink({
      url: 'http://localhost:3000/trpc',
    }),
  ],
});

async function main() {
  // Querying the greeting
  const helloResponse = await trpc.greeting.query({
    name: 'world',
  });

  console.log('helloResponse', helloResponse); // Hello world
}

main();
```
npm package: @pier-wallet/trpc-10-react-query
Description: The tRPC React library
Author: KATT
Latest version: 10.37.1

<p align="center">
  <a href="https://trpc.io/"><img src="https://assets.trpc.io/icons/svgs/blue-bg-rounded.svg" alt="tRPC" height="75"/></a>
</p>

<h3 align="center">tRPC</h3>

<p align="center">
  <strong>End-to-end typesafe APIs made easy</strong>
</p>

<p align="center">
  <img src="https://assets.trpc.io/www/v10/v10-dark-landscape.gif" alt="Demo" />
</p>

# `@trpc/react-query`

> A tRPC wrapper around react-query.

## Documentation

Full documentation for `@trpc/react-query` can be found [here](https://trpc.io/docs/react-query)

## Installation

```bash
# npm
npm install @trpc/react-query @tanstack/react-query

# Yarn
yarn add @trpc/react-query @tanstack/react-query

# pnpm
pnpm add @trpc/react-query @tanstack/react-query

# Bun
bun add @trpc/react-query @tanstack/react-query
```

## Basic Example

Create a utils file that exports tRPC hooks and providers.

```ts
import { createTRPCReact } from '@trpc/react-query';
import type { AppRouter } from './server';

export const trpc = createTRPCReact<AppRouter>();
```

Use the provider to connect to your API.

```ts
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import { trpc } from '~/utils/trpc';
import React, { useState } from 'react';

export function App() {
  const [queryClient] = useState(() => new QueryClient());
  const [trpcClient] = useState(() =>
    trpc.createClient({
      url: 'http://localhost:5000/trpc',
    }),
  );
  return (
    <trpc.Provider client={trpcClient} queryClient={queryClient}>
      <QueryClientProvider client={queryClient}>
        {/* Your app here */}
      </QueryClientProvider>
    </trpc.Provider>
  );
}
```

Now in any component, you can query your API using the proxy exported from the utils file.

```ts
import { trpc } from '~/utils/trpc';

export function Hello() {
  const { data, error, status } = trpc.greeting.useQuery({ name: 'tRPC' });

  if (error) {
    return <p>{error.message}</p>;
  }

  if (status !== 'success') {
    return <p>Loading...</p>;
  }

  return <div>{data && <p>{data.greeting}</p>}</div>;
}
```
npm package: @pier-wallet/trpc-10-server
Description: The tRPC server library
Author: KATT
Latest version: 10.37.1

<p align="center">
  <a href="https://trpc.io/"><img src="https://assets.trpc.io/icons/svgs/blue-bg-rounded.svg" alt="tRPC" height="75"/></a>
</p>

<h3 align="center">tRPC</h3>

<p align="center">
  <strong>End-to-end typesafe APIs made easy</strong>
</p>

<p align="center">
  <img src="https://assets.trpc.io/www/v10/v10-dark-landscape.gif" alt="Demo" />
</p>

# `@trpc/server`

> Create tRPC routers and connect them to a server.

## Documentation

Full documentation for `@trpc/server` can be found [here](https://trpc.io/docs/router)

## Installation

```bash
# npm
npm install @trpc/server

# Yarn
yarn add @trpc/server

# pnpm
pnpm add @trpc/server

# Bun
bun add @trpc/server
```

We also recommend installing `zod` to validate procedure inputs.

## Basic Example

```ts
import { inferAsyncReturnType, initTRPC } from '@trpc/server';
import {
  CreateHTTPContextOptions,
  createHTTPServer,
} from '@trpc/server/adapters/standalone';
import { z } from 'zod';

// Initialize a context for the server
function createContext(opts: CreateHTTPContextOptions) {
  return {};
}

// Get the context type
type Context = inferAsyncReturnType<typeof createContext>;

// Initialize tRPC
const t = initTRPC.context<Context>().create();

// Create main router
const appRouter = t.router({
  // Greeting procedure
  greeting: t.procedure
    .input(
      z.object({
        name: z.string(),
      }),
    )
    .query(({ input }) => `Hello, ${input.name}!`),
});

// Export the app router type to be imported on the client side
export type AppRouter = typeof appRouter;

// Create HTTP server
const { listen } = createHTTPServer({
  router: appRouter,
  createContext,
});

// Listen on port 2022
listen(2022);
```
npm package: @pier_two/staking-ts
Description: A JS development kit with supported TypeScript typings.
Latest version: 1.2.7

# Piertwo Staking API SDK
A JS development kit with supported TypeScript typings.

## Installation
`yarn add @pier_two/staking-ts`

## Documentation
`yarn` or `npm run install`
`yarn build:docs` or `npm run build:docs`
`npx serve ./docs`

### PierTwoStakingApi
The main class for interacting with the Pier Two staking platform. 
All endpoints in the [Pier Two Staking Api](https://gw-1.api.piertwo.io/docs) are implemented.
Read [full documentation here](https://sdk.piertwo.com/).

```javascript

import { URL, PierTwoStakingApi } from '@pier_two/staking-ts'

const piertwo = new PierTwoStakingApi({
  baseUrl: URL.MAINNET,
  apiKey: 'yourApiKey'
});

async function main() {
  const accountDetails = await piertwo.account.getAccount();

  console.log(accountDetails.data)
}

main()

```
npm package: @pierce-h/shipengine-node
Description: ShipEngine API client written for Node.
Author: Pierce Harmon
Latest version: 2.0.0

# ShipEngine Node

![Quality](https://github.com/pierce-h/shipengine-node/workflows/Quality/badge.svg)
[![jest](https://jestjs.io/img/jest-badge.svg)](https://github.com/facebook/jest)

## Installation

Install the package with:

```sh
npm install @pierce-h/shipengine-node
# or
yarn add @pierce-h/shipengine-node
```

## Usage

The package needs to be configured with an API key. You can download a [sandbox API key](https://app.shipengine.com/) for testing purposes or a [production API key](https://app.shipengine.com/#/portal/apimanagement).

Using ES modules:

<!-- prettier-ignore -->
```js
import { ShipEngine } from "@pierce-h/shipengine-node";

const client = new ShipEngine("TEST_...")

(async () => {
  const carriers = await client.listCarriers();

  console.log(carriers);
})();
```

or

<!-- prettier-ignore -->
```js
const shipengine = require("@pierce-h/shipengine-node")

const client = new shipengine.ShipEngine("TEST_...")

client.listCarriers()
  .then(response => console.log(response))
  .catch(error => console.error(error));
```
npm package: @piercefreeman/groove
Description: Node APIs for Groove, a proxy server built for web crawling and unit test mocking. Highlights of its primary features:
Latest version: 1.0.4

# Groove

Node APIs for Groove, a proxy server built for web crawling and unit test mocking. Highlights of its primary features:

- HTTP and HTTPs support over HTTP/1 and HTTP/2.
- Local CA certificate generation and installation on Mac and Linux to support system curl and Chromium.
- Different tiers of caching support - from disabling completely to aggressively maintaining all body archives.
- Limit outbound requests of the same URL to 1 concurrent request to save on bandwidth if requests are already inflight.
- Record and replay requests made to outgoing servers. Recreate testing flows in unit tests while separating them from crawling business logic.
- 3rd party proxy support for commercial proxies.
- Custom TLS Hello Client support to maintain a Chromium-like TLS handshake while intercepting requests and re-forwarding on packets.

For more information, see the [Github](https://github.com/piercefreeman/grooveproxy) project.

## Usage

Add groove to your project and generate the local certificates.

```
npm install @piercefreeman/groove
npx @piercefreeman/groove install-ca
```

```javascript
import { Grove, TapeSession, fetchWithProxy } from '@piercefreeman/groove'

const main = async () => {
    const proxy = new Groove(
        commandTimeout?;
        port?;
        controlPort?;
        proxyServer?;
        proxyUsername?;
        proxyPassword?:;
    )
    await proxy.launch()

    const mockedSession = new TapeSession(
        [
            {
                request: {
                    url: "https://example.com:443/",
                    method: "GET",
                    headers: {},
                    body: Buffer.from(""),
                },
                response: {
                    status: 200,
                    headers: {},
                    body: Buffer.from("Test response")
                }
            }
        ]
    )

    await proxy.tapeLoad(mockedSession);

    const response = await fetchWithProxy("https://example.com", proxy);
    console.log(response) // "Test response"
}
```
npm package: @piercefreeman/use-editable
Description: A small React hook to turn elements into fully renderable & editable content surfaces, like code editors, using contenteditable (and magic)
Latest version: 2.3.4

This is a fork of Formidable's [use-editable](https://github.com/FormidableLabs/use-editable), with some
performance improvements / unmerged PRs baked in by default.

Incorporated PRs:
- https://github.com/FormidableLabs/use-editable/pull/33