open-index/open-npm huggingface dataset:
npm package: @rubisco0211/quasar-app-extension-qotp
Description: A quasar component for inputting one-time passcode.
Author: RUBisco0211
Latest version: 0.0.22

# Quasar App Extension q-otp-input

The QOtpInput component is used for inputting one-time password.

# Links

[npm: @rubisco0211/quasar-app-extension-qotp](https://www.npmjs.com/package/@rubisco0211/quasar-app-extension-qotp)

[demo](https://quasar-app-extension-qotp.vercel.app/#/)

# Install

```bash
quasar ext add @rubisco0211/qotp
```

Quasar CLI will retrieve it from the NPM registry and install the extension to your project.

# Uninstall

```bash
quasar ext remove @rubisco0211/qotp
```

# Usage

```vue
<template>
    <q-otp-input v-bind="otpProps" v-model="otp"></q-otp-input>
</template>
<script setup lang="ts">
import { ref } from "vue";

const otp = ref("");

const otpProps = ref({
    length: 6,
    placeholder: "",

    autofocus: true,
    digitOnly: true,
    allowPaste: true,
    realTime: true,

    type: "text",
    readonly: false,
    disable: false,
    loading: false,
    error: false,

    outlined: true,
    filled: false,
    dense: false,
    standout: false,
    fontSize: "18px",
});
</script>
```

# Donate

If you appreciate the work that went into this App Extension, please consider [donating to Quasar](https://donate.quasar.dev).
npm package: @rubix-code/electron-update-window-options
Description: Update an electron window after it's already been created using the constructor options schema
Author: Rinzler D. Vicky
Latest version: 1.1.1

# electron-update-window-options

This library allows you to update an electron window after it's already been created using the constructor options schema.

```js
updateWindowOptions(browserWindow, { movable: false });
```

is the same as

```js
new BrowserWindow({ movable: false });
```

But you can use this function after it's created

# Examples/Usage

```js
const { BrowserWindow, app } = require("electron");
const updateWindowOptions = require("electron-update-window-options");

app.on("ready", () => {
  const browserWindow = new BrowserWindow({ movable: true });

  browserWindow.setMovable(false);
  // Is the same as
  updateWindowOptions(browserWindow, { movable: false });
  // But this is the same format as
  // new BrowserWindow(/* this */);
});
```
npm package: @rubix-code/ini
Description: An ini-file parser which supports multi line, multiple levels and arrays to get a maximum of compatibility with Zend config files.
Author: Rubixcode
Latest version: 0.0.4

# @rubix-code/ini
This project is a fork of [evangelion1204/multi-ini](https://github.com/evangelion1204/multi-ini)

An ini-file parser which supports multi line, multiple levels and arrays to get a maximum of compatibility with Zend config files.

Please note that this is a work in progress and may be ditched, all contributions are welcome!

## Install

```shell
npm install @rubix-code/ini
```

## Usage

```js
ini = require('@rubix-code/ini');
content = ini.read(file);
content.section.key = value;
ini.write(file, content);

```

## Options

Following options are available:
* encoding \[*'utf8'*\] - directly passed to readFileSync
* keep_quotes \[*false*\] - does not strip quotes around values
* filters - predefined *lowercase*, *uppercase*, *trim*, *constants*, *boolean*

### Examples

#### encoding

```js
ini = require('@rubix-code/ini');
content = ini.read(file, {encoding: 'utf8'});
content.section.key = value;
ini.write(file, content, {encoding: 'utf8'});
```

#### keep_quotes
This option is by default off to be backward compatible, if you ever need the value containing the quotes then use this.
```ini
key="value"
```
Enabling this option will result in **"value"** instead of **value**.

```js
ini = require('@rubix-code/ini');
content = ini.read(file, {keep_quotes: true});
```

This will also affect the Serializer and serialized values. Using it will not quote anything automatically.
```js
{
    production: {
        quoted: '"quoted"',
        not_quoted: 'not_quoted'
    }
}
```

Will result in a ini like
```ini
[production]
quoted="quoted"
not_quotes=not_quoted
```

#### filters

```js
Ini = require('@rubix-code/ini');
ini = new Ini.Class({
    filters: [Ini.filters.lowercase]
});
content = ini.read(file);
```

*Replacing constants*
```js
Ini = require('@rubix-code/ini');
ini = new Ini.Class({
  constants: {'CONSTANT': 'replacement'},
  filters: [Ini.filters.constants]
});
content = ini.read(file);
```


*Define a custom filter*
```js
Ini = require('@rubix-code/ini');
ini = new Ini.Class({
    filters: [
        function (value) {
            return "Prepend " + value;
        }
    ]
});
content = ini.read(file);
```

#### line_breaks

Either `unix` or `windows` for line breaks.

```js
ini = require('@rubix-code/ini');
content = ini.read(file, {line_breaks: 'windows'});
content.section.key = value;
```

#### Parser

It's also possible to parse a ini file from an array of strings.

```js
ini = require('@rubix-code/ini');
parser = new ini.Parser();
content = parser.parse(lines);
```

#### Serializer

Like parsing it's also possible to serialize an ini object to a string.

```js
ini = require('@rubix-code/ini');
serializer = new ini.Serializer();
content = serializer.serialize({
    production: {
        base_url: 'https://google.com'
    }
});
```

## Changelog

### 0.0.2
* Rewritten in `Typescript`
npm package: @rubix-code/on-change
Description: Watch an object or array for changes
Author: Rubixcode
Latest version: 0.0.2

# This is a fork of [on-change](https://travis-ci.org/sindresorhus/on-change)

> Watch an object or array for changes

It works recursively, so it will even detect if you modify a deep property like `obj.a.b[0].c = true`.

Uses the [`Proxy` API](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy).


## Install

```
$ npm install @rubix-code/on-change
```


## Usage

```js
import observe from "@rubix-code/on-change"

const object = {
	foo: false,
	a: {
		b: [
			{
				c: false
			}
		]
	}
};

let i = 0;
const watchedObject = observe(object, (o) => {
	console.log(o, 'Object changed:', ++i);
});

watchedObject.foo = true;
//=> 'Object changed: 1'

watchedObject.a.b[0].c = true;
//=> 'Object changed: 2'
```


## API

### onChange(object, onChange)

Returns a version of `object` that is watched. It's the exact same object, just with some `Proxy` traps.

#### object

Type: `Object`

Object to watch for changes.

#### onChange

Type: `Function`

Param: `Object`
The changed object

Function that gets called anytime the object changes.


## Use-case

I had some code that was like:

```js
const foo = {
	a: 0,
	b: 0
};

// …

foo.a = 3;
save(foo);

// …

foo.b = 7;
save(foo);


// …

foo.a = 10;
save(foo);
```

Now it can be simplified to:

```js
const foo = onChange({
	a: 0,
	b: 0
}, (obj) => save(obj));

// …

foo.a = 3;

// …

foo.b = 7;

// …

foo.a = 10;
```


## Related

- [known](https://github.com/sindresorhus/known) - Allow only access to known object properties *(Uses `Proxy` too)*
- [negative-array](https://github.com/sindresorhus/negative-array) - Negative array index support `array[-1]` *(Uses `Proxy` too)*
- [statux](https://github.com/franciscop/state) - State manager *(Uses `Proxy` too)*
- [introspected](https://github.com/WebReflection/introspected) - Never-ending Proxy with multiple observers *(Uses `Proxy` too)*


## License

MIT © [Sindre Sorhus](https://sindresorhus.com)
npm package: @rubix-code/string-format
Description: An extensible string formatter for Node.js
Author: Rubixcode
Latest version: 0.1.2

# String-Format
[![semantic-release: eslint](https://img.shields.io/badge/semantic--release-eslint-e10079?logo=semantic-release)](https://github.com/semantic-release/semantic-release)
[![codecov](https://codecov.io/gh/rubix-code/string-format/graph/badge.svg?token=0CM91KRJW6)](https://codecov.io/gh/rubix-code/string-format)
[![npm version](https://badge.fury.io/js/%40rubix-code%2Fstring-format.svg)](https://badge.fury.io/js/%40rubix-code%2Fstring-format)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

A Highly functional and extensible string formatting library for JS.

## Inspiration
This repo is inspired by the following libraries:
- [string-format-js](https://github.com/tmaeda1981jp/string-format-js)
- [string-format](https://github.com/davidchambers/string-format)
- [pyformat](https://github.com/tamzinblake/pyformat)

All of this libraries are great in their own way. But installing them individually can be tedious. Also, they are not extensible, and have not been maintained for quite some time.

This library aims to provide a single library that can be used to format strings in a variety of ways. It also aims to be extensible, so that you can add your own custom formatters.

## Installation
```bash
npm install @rubix-code/string-format
```
## Usage

### Basic Usage
```ts
// Globally apply the default formatters
import "@rubix-code/string-format/register";

// Python style formatting
"My name is {name}".format({ name: "Slim Shady" }); // My name is Slim Shady

// C++ style formatting
"The answer to life, the universe and everything is %d".format(42); // The answer to life, the universe and everything is 42
```

## TODO:
- [ ] Fix CI/CD pipeline
- [ ] Add complete documentation