open-index/open-npm huggingface dataset:
npm package: @isearch-lab/cordova-plugin-screen-pinning
Description: Cordova plugin exposing Android's screen pinning APIs
Author: Federico Meini
Latest version: 1.0.3
Deprecated: Deprecated

# Cordova screen pinning plugin

Cordova plugin exposing Android (API 21+) screen pinning APIs.

## Installation

Run the following command inside your project's folder:

```sh
cordova plugin add cordova-plugin-screen-pinning
```

## Usage

### enterPinnedMode()

- **successCallback:** [Function optional] - success callback
- **errorCallback:** [Function optional] - error callback
- **kioskMode:** [Boolean optional] - set this to true to enter Kiosk Mode

```js
cordova.plugins.screenPinning.enterPinnedMode(successCallback, errorCallback);
```

### exitPinnedMode()

- **successCallback:** [Function optional] - success callback

- **errorCallback:** [Function(error) optional] - error callback, error message string is passed

```js
cordova.plugins.screenPinning.exitPinnedMode(successCallback, errorCallback);
```

## Device owner (Kiosk Mode)

With the normal pinned mode, user can leave pinned mode easily with a combination of buttons. If, instead, you need your app to run in a sort of "Kiosk mode" (which the user cannot leave), you first need to set your app as the device owner:

In order to set your app as the device owner you need to run this command while your device is plugged via USB debug:

```sh
adb shell dpm set-device-owner <YOUR APP PACKAGE NAME>/me.raimaj.plugin.DefaultDeviceAdminReceiver
```

For example, if your app package is "com.mydomain.myapp", you would run:

```sh
adb shell dpm set-device-owner com.mydomain.myapp/me.raimaj.plugin.DefaultDeviceAdminReceiver
```

After you have set your app as the device owner, you can do the following:

```js
cordova.plugins.screenPinning.enterPinnedMode(successCallback, errorCallback, true);
```
npm package: @iseei/rxjs-grpc
Description: Typesafe gRPC with RxJS in TypeScript
Latest version: 0.2.8

[![Build Status](https://travis-ci.org/kondi/rxjs-grpc.svg?branch=master)](https://travis-ci.org/kondi/rxjs-grpc)
[![npm version](https://badge.fury.io/js/rxjs-grpc.svg)](https://badge.fury.io/js/rxjs-grpc)

# rxjs-grpc

## Installation

```sh
$ npm install rxjs-grpc rxjs grpc
```

## Quickstart

Create your protobuf definition file `sample.proto`:

```protobuf
syntax = "proto3";

package sample;

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}
```

Generate your TypeScript interfaces:

```sh
$ ./node_modules/.bin/rxjs-grpc -o grpc-namespaces.ts *.proto
```

Implement your typesafe server returning `Observable<sample.HelloReply>`:

```typescript
import { of } from 'rxjs';
import { serverBuilder } from 'rxjs-grpc';
import { sample } from './grpc-namespaces';

// Pass the path of proto file and the name of namespace
const server = serverBuilder<sample.ServerBuilder>('sample.proto', 'sample')
// Add implementation
server.addGreeter({
  sayHello(request: sample.HelloRequest) {
    return of({
      message: 'Hello ' + request.name
    });
  }
})
// Start the server to listen on port 50051
server.start('0.0.0.0:50051');
```

Call it from a client:

```typescript
import { clientFactory } from 'rxjs-grpc';
import { sample } from './grpc-namespaces';

// Pass the path of proto file and the name of namespace
const Services = clientFactory<sample.ClientFactory>('sample.proto', 'sample');
// Create a client connecting to the server
const services = new Services('localhost:50051');
// Get a client for the Greeter service
const greeter = services.getGreeter();

// Call the service by passing a sample.HelloRequest
greeter.sayHello({ name: 'world' }).forEach(response => {
  console.log(`Greeting: ${response.message}`);
});
```

## Generated interfaces

```typescript
import { Observable } from 'rxjs';

export namespace sample {

  export interface ClientFactory {
    getGreeter(): sample.Greeter;
  }

  export interface ServerBuilder {
    addGreeter(impl: sample.Greeter): sample.ServerBuilder;
  }

  export interface Greeter {
    sayHello(request: sample.HelloRequest): Observable<sample.HelloReply>;
  }

  export interface HelloRequest {
    name?: string;
  }

  export interface HelloReply {
    message?: string;
  }

}
```

## Examples

You can see a simple example project in the [examples folder](examples).
npm package: @iseei/vite-plugin-svgr
Description: Vite plugin to transform SVGs into React components
Author: iseei
Latest version: 1.1.0

# vite-plugin-svgr

[![npm](https://img.shields.io/npm/v/vite-plugin-svgr.svg)](https://www.npmjs.com/package/@iseei/vite-plugin-svgr)

Vite plugin to transform SVGs into React components. Uses [svgr](https://github.com/gregberge/svgr) under the hood.

## Usage

```js
// vite.config.js
import svgrPlugin from '@iseei/vite-plugin-svgr'

export default {
  // ...
  plugins: [
    svgrPlugin({
      svgrOptions: {
        icon: true,
        // ...svgr options (https://react-svgr.com/docs/options/)
      },
      defaultExportComponent: true,
    }),
  ],
}
```

Then SVG files can be imported as React components, just like [create-react-app](https://create-react-app.dev/docs/adding-images-fonts-and-files#adding-svgs) does:

```js
import { ReactComponent as Logo } from './logo.svg'
```

If you are using TypeScript, `vite-plugin-svgr/client` can be added to `tsconfig.json`:

```json
{
  // ...
  "compilerOptions": {
    // ...
    "types": ["vite-plugin-svgr/client"]
  }
}
```

## License

MIT