open-index/open-npm huggingface dataset:
npm package: @musti007/my-lib
Description: Just a test package
Author: Musti
Latest version: 1.0.0

# MyLib

This project was generated using [Angular CLI](https://github.com/angular/angular-cli) version 21.2.0.

## Code scaffolding

Angular CLI includes powerful code scaffolding tools. To generate a new component, run:

```bash
ng generate component component-name
```

For a complete list of available schematics (such as `components`, `directives`, or `pipes`), run:

```bash
ng generate --help
```

## Building

To build the library, run:

```bash
ng build my-lib
```

This command will compile your project, and the build artifacts will be placed in the `dist/` directory.

### Publishing the Library

Once the project is built, you can publish your library by following these steps:

1. Navigate to the `dist` directory:

   ```bash
   cd dist/my-lib
   ```

2. Run the `npm publish` command to publish your library to the npm registry:
   ```bash
   npm publish
   ```

## Running unit tests

To execute unit tests with the [Karma](https://karma-runner.github.io) test runner, use the following command:

```bash
ng test
```

## Running end-to-end tests

For end-to-end (e2e) testing, run:

```bash
ng e2e
```

Angular CLI does not come with an end-to-end testing framework by default. You can choose one that suits your needs.

## Additional Resources

For more information on using the Angular CLI, including detailed command references, visit the [Angular CLI Overview and Command Reference](https://angular.dev/tools/cli) page.
npm package: @mustib/utils
Description: a lightweight npm library that provides a collection of commonly used utilities. Whether you’re working on web applications, APIs, or backend services, these tools simplify repetitive tasks and enhance productivity
Author: Muhammad Mustafa
Latest version: 2.9.0

# @mustib/utils ![NPM License](https://img.shields.io/npm/l/@mustib/utils) ![NPM Version](https://img.shields.io/npm/v/@mustib/utils)

**A lightweight** npm library with **zero dependencies** that provides a collection of commonly used utilities.<br/>
Whether you’re working on web applications, APIs, or backend services, these tools **simplify** repetitive tasks and **enhance** productivity

---

## Installation:

```bash
npm install @mustib/utils
```

<br/>

Please see the **[Getting Started](https://mustib.github.io/mustib-utils/start-guide/getting-started/)** guide for a comprehensive guide on using **`@mustib/utils`** in your projects.

**Don't forget to star [this repository](https://github.com/mustib/mustib-utils)** if you find it useful.

For updates and new features, please refer to the **[CHANGELOG.md](https://github.com/mustib/mustib-utils/blob/main/CHANGELOG.md)** file in the GitHub repository to track all changes.

### Common Utilities:

- **[AppError](https://mustib.github.io/mustib-utils/v2/utilities/common/apperror/)**

- **[CustomEventEmitter](https://mustib.github.io/mustib-utils/v2/utilities/common/customeventemitter/)**

- **[EventAction](https://mustib.github.io/mustib-utils/v2/utilities/browser/eventaction/)**

- **[EnvVars](https://mustib.github.io/mustib-utils/v2/utilities/node/envvars/)**

- **[millisecondsFromString](https://mustib.github.io/mustib-utils/v2/utilities/common/millisecondsfromstring/)**

- **[stringFromMilliseconds](https://mustib.github.io/mustib-utils/v2/utilities/common/stringfrommilliseconds/)**

- **[retry](https://mustib.github.io/mustib-utils/v2/utilities/common/retry/)**

For All Utilities and details, please refer to the **[documentation](https://mustib.github.io/mustib-utils/)**.
npm package: @mustmove/overlay-kit-rn
Description: React Native overlay management library
Author: cheondeuggwon
Latest version: 1.0.114

# @mustmove/overlay-kit-rn

React Native overlay management library for modals and bottom sheets.

## Installation

```bash
npm install @mustmove/overlay-kit-rn
```

### Peer Dependencies

This library requires the following peer dependencies:

```bash
npm install react-native-reanimated react-native-gesture-handler @mustmove/bottom-sheet react-native-worklets
```

## Quick Start

```tsx
import { overlay, OverlayProvider } from '@mustmove/overlay-kit-rn';

// 1. Wrap your app with OverlayProvider
function App() {
  return (
    <OverlayProvider>
      <YourAppContent />
    </OverlayProvider>
  );
}

// 2. Create your modal component
const MyModal = ({ close }) => (
  <View>
    <Text>Hello Modal!</Text>
    <Button title="Close" onPress={close} />
  </View>
);

// 3. Open the modal
const openModal = () => {
  overlay.open(MyModal, {
    overlayType: 'modal',
    modalType: 'center',
  });
};
```

## Features

- ✅ Pure React Native Modal (no third-party modal dependency)
- ✅ Bottom Sheet with @mustmove/bottom-sheet
- ✅ Multiple overlay types (modal, bottomSheet, overlay)
- ✅ Async modal support
- ✅ Nested modals
- ✅ TypeScript support
- ✅ Keyboard handling for bottom sheets

## API

### `overlay.open(Component, options)`

Opens an overlay with the specified component.

```tsx
overlay.open(YourComponent, {
  overlayType: 'modal' | 'bottomSheet' | 'overlay',
  // Modal specific options
  modalType: 'center' | 'bottom' | 'top' | 'left' | 'right',
  backdropOpacity: 0.5,
  animationType: 'slideInUp' | 'slideInDown' | 'bounceIn' | 'fadeIn',
  // Bottom sheet specific options
  snapPoints: ['25%', '50%', '90%'],
  enablePanDownToClose: true,
});
```

### `overlay.openAsync(Component, options)`

Opens an overlay and returns a promise that resolves with the result.

```tsx
const result = await overlay.openAsync(AsyncComponent, {
  overlayType: 'modal',
});
```

### Component Props

Your overlay components receive these props:

```tsx
interface OverlayComponentProps {
  close: (result?: any) => void;
}
```

## License

MIT
npm package: @mustmove/react-native-image-size
Description: Get original image size (iOS + Android)
Author: Ivan Sorokin
Latest version: 1.0.0

## react-native-image-size (iOS + Android)

---

Friends, sorry, but I can't now support this project as too busy and I am not working with react-native projects already few years....

If someone believes that he can support the project - let me know and I can add you to the Collaborators
(existfragger@gmail.com)

---


[![NPM version](https://badge.fury.io/js/react-native-image-size.svg)](http://badge.fury.io/js/react-native-image-size)

Android 4.0 (API level 14) introduced the ability to get original image size.

iOS uses Image.getSize https://facebook.github.io/react-native/docs/image#getsize


### Installation

Download via NPM

```shell
npm i -S react-native-image-size
```

Download via Yarn

```shell
yarn add react-native-image-size
```

Afterward make sure to rebuild app, not just refresh bundler.

## Linking (for React Native <= 0.59 only, React Native >= 0.60 skip this as auto-linking should work)

**-- Automaticaly --**

Link, either via `react-native link` or manually

```shell
react-native link react-native-image-size
```

**-- Manually --**

#### android/settings.gradle
```diff
+include ':react-native-image-size'
+project(':react-native-image-size').projectDir = new File(rootProject.projectDir, '../node_modules/react-native-image-size/android')
```
#### android/app/build.gradle
```diff
dependencies {
  ...
+  implementation project(':react-native-image-size')
  ...
}
```
#### android/app/src/main/java/.../MainApplication.java
```diff
+import com.existfragger.rnimagesize.RNImageSizePackage;
...
@Override
protected List<ReactPackage> getPackages() {
  return Arrays.<~>asList(
-    new MainReactPackage()
+    new MainReactPackage(),
+    new RNImageSizePackage()
  );
}
```

### How to use

```js
import ImageSize from 'react-native-image-size'
...
ImageSize.getSize(uri).then(size => {
    // size.height
    // size.width
})
```

You can also use async/await, if you would prefer.

```js
import ImageSize from 'react-native-image-size'
...
foo = async () => {
  const { width, height } = await ImageSize.getSize(uri);
  // do stuff with width and height
}
```
npm package: @musubi/broadcast-channel-link
Description: <div style="text-align: center;width:100%"> <h1> Musubi 🪢 </h1> <strong>End-to-end typesafe communication. 🎉</strong> </div>
Latest version: 0.4.0



<div style="text-align: center;width:100%">
<h1>
Musubi 🪢
</h1>
<strong>End-to-end typesafe communication. 🎉</strong>
</div>

# @musubi/broadcast-channel-link

Adapter for using Musubi in browser extension.

## Documentation
Full documentation for `musubi` can be found [here](https://github.com/TheUnderScorer/musubi).

## Installation
```shell
# npm
npm install @musubi/broadcast-channel-link

# Yarn
yarn add @musubi/broadcast-channel-link
```

## Usage

```ts
// Service worker/shared worker script
import { createBroadcastChannelLink } from '@musubi/broadcast-channel-link';
import { MusubiReceiver } from '@musubi/core';
import { schema } from '../schema';

const channel = new BroadcastChannel('musubi');

async function main() {
  const link = createBroadcastChannelLink(channel);
  const receiver = new MusubiReceiver(schema, [
    link.receiver,
  ]);

  receiver.handleQuery('ping', async () => {
    return 'pong';
  });
}

main().catch(console.error);
```

```ts
// Inside your app
import { createBroadcastChannelLink } from '@musubi/broadcast-channel-link';
import { schema } from '../schema';

const channel = new BroadcastChannel('musubi');

const worker = new SharedWorker('worker.js');
// or if browser doesn't support SharedWorker
// const worker = new Worker('worker.js');

const link = createBroadcastChannelLink(channel);

// If you are using Worker, you can pass it into link instead of channel
// const link = createBroadcastChannelLink(worker);

const client = new MusubiClient(schema, [
  link.client,
]);

await client.query('ping') // 'pong'
```
npm package: @musubi/browser-extension-link
Description: <div style="text-align: center;width:100%"> <h1> Musubi 🪢 </h1> <strong>End-to-end typesafe communication. 🎉</strong> </div>
Latest version: 0.12.0



<div style="text-align: center;width:100%">
<h1>
Musubi 🪢
</h1>
<strong>End-to-end typesafe communication. 🎉</strong>
</div>

# @musubi/browser-extension-link

Adapter for using Musubi in browser extension.

## Documentation
Full documentation for `musubi` can be found [here](https://github.com/TheUnderScorer/musubi).

## Installation
```shell
# npm
npm install @musubi/browser-extension-link

# Yarn
yarn add @musubi/browser-extension-link
```

## Usage

```ts
// Background/service worker script
import { createBrowserExtensionLink } from '@musubi/browser-extension-link';
import { MusubiReceiver } from '@musubi/core';
import { schema } from '../schema';
import * as browser from 'webextension-polyfill';

async function main() {
  const link = createBrowserExtensionLink('background');
  const receiver = new MusubiReceiver(schema, [
    link.receiver,
  ]);

  receiver.handleQuery('getTabs', async () => {
    return browser.tabs.query({});
  });

  console.info('background script ready');
}

main().catch(console.error);


```
npm package: @musubi/core
Description: <div style="text-align: center;width:100%"> <h1> Musubi 🪢 </h1> <strong>End-to-end typesafe communication. 🎉</strong> </div>
Latest version: 0.14.0



<div style="text-align: center;width:100%">
<h1>
Musubi 🪢
</h1>
<strong>End-to-end typesafe communication. 🎉</strong>
</div>

# @musubi/core

## Documentation
Full documentation for `@musubi/core` can be found [here](https://github.com/TheUnderScorer/musubi).

## Installation
```shell
# npm
npm install @musubi/core

# Yarn
yarn add @musubi/core
```

## Usage
```ts
import { defineSchema, CommunicatorClient } from "@musubi/core";
import { createHttpClientLink } from "@musubi/http-link";
import { z } from "zod";

const schema = defineSchema({
  queries: {
    greet: query()
      .withPayload(
        z.object({
          name: z.string()
        })
      )
      .withResult(z.string())
  }
});

async function main() {
  const httpLink = createHttpClientLink({
    url: "http://localhost:3000/api"
  });
  const client = new CommunicatorClient(schema, [httpLink]);

  // Querying the greeting
  const response = await client.query("greet", {
    name: "John"
  });

  console.log("response", response); // Hello John
}

```
npm package: @musubi/electron-link
Description: <div style="text-align: center;width:100%"> <h1> Musubi 🪢 </h1> <strong>End-to-end typesafe communication. 🎉</strong> </div>
Latest version: 0.15.0



<div style="text-align: center;width:100%">
<h1>
Musubi 🪢
</h1>
<strong>End-to-end typesafe communication. 🎉</strong>
</div>

# @musubi/electron-link

Adapter for using Musubi in electron apps.

## Documentation
Full documentation for `musubi` can be found [here](https://github.com/TheUnderScorer/musubi).

## Installation
```shell
# npm
npm install @musubi/electron-link

# Yarn
yarn add @musubi/electron-link
```

## Basic setup

1. Initialize your electron app
```typescript
import { app } from "electron";
import { createMainLink } from "@musubi/electron-link/main";
import { cr } from "@musubi/electron-link/main";
import { schema } from "./schema";

app.on("ready", () => {
  const win = new BrowserWindow({
    webPreferences: {
      // Replace this path with the path to your preload file (more in next step)
      preload: "path/to/preload.js"
    }
  });

  const electronLink = createMainLink({
    windows: [win]
  });

  const { receiver, client } = createMusubi({
    schema,
    clientLinks: [electronLink.client],
    receiverLinks: [electronLink.receiver]
  });

  receiver.handleCommand(...);
  receiver.handleQuery(...);


  // Send query to specific window, by passing it's ID as last parementer.
  // It works with commands and events as well
  client.query("testQuery", { test: true }, win.id);
});
```
> Note: By omitting `channel` parameter, message will be sent to all windows, but you will always get `void` as result

2. Expose the IPC to the render process from the preload file:
```typescript
import { exposeElectronLink } from '@musubi/electron-link/main';

exposeElectronLink();
```
3. Create a client in the renderer process:
```typescript
import { createRendererLink } from "@musubi/electron-link/renderer";
import { electronSchema } from "./schema";
import { createMusubi } from "@musubi/core";

const link = createRendererLink();

const { receiver, client } = createMusubi({
  clientLinks: [link.client],
  receiverLinks: [link.receiver],
  schema: electronSchema
});

// Send query to main process
client.query(...);

// Send command to main process
client.command(...);

// Handle query from main process
receiver.handleQuery(...);

// Handle command from main process
receiver.handleCommand(...);

// Dispatch even to main process
receiver.dispatchEvent();
```
4. Done! 🎉
npm package: @musubi/http-link
Description: <div style="text-align: center;width:100%"> <h1> Musubi 🪢 </h1> <strong>End-to-end typesafe communication. 🎉</strong> </div>
Latest version: 0.8.0



<div style="text-align: center;width:100%">
<h1>
Musubi 🪢
</h1>
<strong>End-to-end typesafe communication. 🎉</strong>
</div>

# @musubi/http-link

Adapter for using Musubi in via HTTP.

## Documentation
Full documentation for `musubi` can be found [here](https://github.com/TheUnderScorer/musubi).

## Installation
```shell
# npm
npm install @musubi/http-link

# Yarn
yarn add @musubi/http-link
```

## Basic setup

WIP
npm package: @musubi/in-memory-link
Description: <div style="text-align: center;width:100%"> <h1> Musubi 🪢 </h1> <strong>End-to-end typesafe communication. 🎉</strong> </div>
Latest version: 0.14.1



<div style="text-align: center;width:100%">
<h1>
Musubi 🪢
</h1>
<strong>End-to-end typesafe communication. 🎉</strong>
</div>

# @musubi/in-memory-link

Adapter for using Musubi with in-memory communication.

## Documentation
Full documentation for `musubi` can be found [here](https://github.com/TheUnderScorer/musubi).

## Installation
```shell
# npm
npm install @musubi/in-memory-link

# Yarn
yarn add @musubi/in-memory-link
```

## Usage
```ts
import { defineSchema, CommunicatorClient, MusubiReceiver } from "@musubi/core";
import { createInMemoryLink } from "@musubi/in-memory-link";
import { z } from "zod";

const schema = defineSchema({
  queries: {
    greet: query()
      .withPayload(
        z.object({
          name: z.string()
        })
      )
      .withResult(z.string())
  }
});

const memoryLink = createInMemoryLink();

const receiver = new MusubiReceiver(schema, [memoryLink.receiver]);

receiver.handleQuery('greet', payload => `Hello ${payload.name}`);

async function main() {
  const client = new CommunicatorClient(schema, [memoryLink.client]);

  // Querying the greeting
  const response = await client.query("greet", {
    name: "John"
  });

  console.log("response", response); // Hello John
}

```
npm package: @musubi/react
Description: <div style="text-align: center;width:100%"> <h1> Musubi 🪢 </h1> <strong>End-to-end typesafe communication. 🎉</strong> </div>
Latest version: 0.9.1



<div style="text-align: center;width:100%">
<h1>
Musubi 🪢
</h1>
<strong>End-to-end typesafe communication. 🎉</strong>
</div>

# @musubi/react

Wrapper for using Musubi in React. It uses [react-query](https://react-query.tanstack.com/) under the hood.

## Installation
```shell
# npm
npm install @musubi/react

# Yarn
yarn add @musubi/react
```

## Documentation
Full documentation for `musubi` can be found [here](https://github.com/TheUnderScorer/musubi).

## Usage
1. Initialize react hooks
```tsx
// schema.ts
import { createReactMusubi } from "@musubi/react";
import { defineSchema, query } from "@musubi/core";
import { z } from "zod";

export const schema = defineSchema({
  queries: {
    greet: query()
      .withPayload(
        z.object({
          name: z.string()
        })
      )
      .withResult(z.string())
  }
});

export const m = createReactMusubi(schema);
```
2. Wrap your application in provider

```tsx
// index.tsx
import { schema } from "./schema";
import { QueryClient } from "@tanstack/react-query";
import { MusubiClient } from "@musubi/core";
import { createInMemoryLink } from "@musubi/in-memory-link";
import { App } from './App';
import { MusubiProvider } from "@musubi/react";

// Example with in memory link, but it could be any link
const link = createInMemoryLink()

// Query client from @tanstack/react-query
const queryClient = new QueryClient();

const client = new MusubiClient(schema, [link.client]);

function MyApp() {
  return (
    <MusubiProvider queryClient={queryClient} client={client}>
      <App />
    </MusubiProvider>
  )
}
```
3. Use operations inside your components 🎉
```tsx
// App.tsx
import { m } from "./schema";

export function App() {
  const { data, isLoading } = m.greet.useQuery("greet", { name: "John" });

  return (
    <div>
      {isLoading ? "Loading..." : data}
    </div>
  )
}
```
npm package: @musubi/socket-io-link
Description: <div style="text-align: center;width:100%"> <h1> Musubi 🪢 </h1> <strong>End-to-end typesafe communication. 🎉</strong> </div>
Latest version: 0.6.0



<div style="text-align: center;width:100%">
<h1>
Musubi 🪢
</h1>
<strong>End-to-end typesafe communication. 🎉</strong>
</div>

# @musubi/socket-io-link

Adapter for using Musubi with socket.io.

## Documentation
Full documentation for `musubi` can be found [here](https://github.com/TheUnderScorer/musubi).

## Installation
```shell
# npm
npm install @musubi/socket-io-link

# Yarn
yarn add @musubi/socket-io-link
```

## Usage

```ts
// Server
import { createSocketIoServerLink } from '@musubi/socket-io-link/server';
import { createMusubi } from '@musubi/core';
import { schema } from '../schema';
import { Server} from 'socket.io';

async function main() {
  const server = new Server();
  
  const link = createSocketIoServerLink(server);
  const { receiver, client } = createMusubi({
    schema,
    clientLinks: [link.client],
    receiverLinks: [link.receiver],
  });

  receiver.handleQuery('ping', async (_, ctx) => {
    // Access client socket
    console.log(ctx.socket);
    
    // Send message to all clients
    // Note: It will always return void for now
    await client.query('pong')
    
    // Send query to sockets in specific room
    await client.query('pong', {
      roomId: 'room1',
    })
    
    // Send query to specific socket
    await client.query('pong', {
      socketId: ctx.socketId
    })
    
    // Send query to all sockets except the current one
    await client.query('pong', {
      socketId: ctx.socketId,
      isBroadcast: true,
    })
    
    // Above examples work for
    
    return 'pong'
  });
}

main().catch(console.error);
```

```ts
// Client
import { createSocketIoClientLink } from '@musubi/socket-io-link/client';
import { createMusubi } from '@musubi/core';
import { schema } from '../schema';
import io from 'socket.io-client';

async function main() {
  const socketClient = io('http://localhost:3000', {
    autoConnect: false,
  });
  
  const link = createSocketIoClientLink(socketClient);

  const { receiver, client } = createMusubi({
    schema,
    clientLinks: [link.client],
    receiverLinks: [link.receiver],
  });

  const result = await client.query('ping');
  console.log(result); // pong
}

```