open-index/open-npm huggingface dataset:
npm package: @logzio-node-toolbox/config
Description: config manager based on Joi schema with subscription capabilities
Author: Nir winkler
Latest version: 0.0.16

<p align="center">
  <a href="http://logz.io">
    <img height="150px" src="https://logz.io/wp-content/uploads/2017/06/new-logzio-logo.png">
  </a>
</p>

# Config
an efficient config manager based on Joi schema for better easy managing configurations

## Usage
```javascript
import { Config } from '@logzio-node-toolbox/config';

const schema = {}; // Joi schema or array of Joi schemas (in case or array will merge the schemas)

const defaults = {}; // defaults to override the schema defaults (use to pass defaults per region or environment)

const overrides = {}; // configs that could never be override even when try to set (usually environment variables)

const config = new Config({ schema, defaults, overrides });
```

### get value
use path to fetch nested value, if empty will fetch the all config
```javascript
const value = config.get('path.to.value');
```

### set value
use path in key property to set nested values, if empty will mergeDeep from root

onError - callback for when validation error with the schema, if onError return true will continue with the merge config even if not valid
```javascript
config.set({ value: {}, key = 'path.to.set', onError: (err) => {
  console.log(err)
  return true;
} })
```

### subscribe
onChange - callback to invoke when value changed
if key is empty will watch all config

return unSubscribe method

```javascript
const unSubscribe = config.subscribe({ key: 'path.to.value.to.watch', onChange: (value) => {
  console.log("new value:", value);
}})

unSubscribe(); // stop watching value
```
npm package: @logzio-node-toolbox/tracer
Description: multi-functional trace
Author: Nir winkler
Latest version: 0.0.13

<p align="center">
  <a href="http://logz.io">
    <img height="150px" src="https://logz.io/wp-content/uploads/2017/06/new-logzio-logo.png">
  </a>
</p>

## TRACER

create a tracer by passing configuration with build-in defaults.
params:
  serviceName - string (node-js)
  tags - object | key value of tags to add to each span
  carrierType - string (http-header) | opentracing carrier types
  debug - boolean (false) | print spans on finish, and set sampler to 1 const 1
  shouldIgnore - function | ignore spans by the operation name
  onStartSpan - function | will call function with created span
  onFinishSpan - function | will call function before closing the span
  exporterOptions - object | configure the exporter
          type - string (const) | jaeger exporter types
          probability - number (1) | jaeger exporter probability
          host - string (localhost) | jaeger exporter host
          port - number (6832) | jaeger exporter port
          interval - number (2000) | jaeger exporter flush interval

```javascript
import { Tracer } from '@logzio-node-toolbox/tracer;

const config = {
  serviceName: 'client-api',
  exporterOptions: {
    host: '127.0.13.1',
    interval: 5000,
  },
  tags: {
    region: 'us',

  },
  shouldIgnore: (url) => {
    if url.includes('ignore path') return true;
    return false;
  },
  onStartSpan: (span) => {
    span.addTag()
  }
}
const tracer = new Tracer(config);

const span = tracer.startSpan({operation: 'operationName', tags: { default: 'tags for this span' }, carrier: req.headers });

tracer.finishSpan({ span: span, tags: { default: 'tags for finish span' }});
```
npm package: @logzio-node-toolbox/utils
Description: collection of nice utils
Author: Nir winkler
Latest version: 0.0.8

<p align="center">
  <a href="http://logz.io">
    <img height="150px" src="https://logz.io/wp-content/uploads/2017/06/new-logzio-logo.png">
  </a>
</p>

# handy utils

## Observable
simplified observable pattern class
```javascript
import { Observable }  from '@logz/utils';
const data = {
  num: 2
}
const observable = new Observable(data);

const unsubscribe = observable.subscribe((newData => console.log(newData));

observable.set({num : 3}) // wii invoke all subscribes


unsubscribe() // will remove subscriber from object
```

## Monitor
using the observable pattern implement with timeouts can monitor changes
constructor params:
 interval: number (default 5000) | interval time to iterate on the callback
 afterFinish: boolean (default false) | should start next iteration timer after callback function finished
 monitor: fn (optional can also be pass on the start method)

methods:
  start: { monitor: fn, interval: number (default from class) onCall: fn } | start the interval
  stop: | stop interval
  subscribe: fn | call on each interval
  unSubscribe: fn | remove fn from subscribes
  destroy: | stop interval the remove all subscribes

```javascript
import { Monitor }  from '@logz/utils';

const sum = 0;
const toMonitorCallback = () => {
  sum = sum + 20
  delay(2000)
  return sum
}

// in this case afterFinish will cause interval be 5000 (delay from monitor + interval time) instead of 3000
const monitor = new Monitor({ interval: 3000, afterFinish: true, monitor: toMonitorCallback });

const subscriber2 = newData => console.log(newData);

monitor.subscribe(subscriber2);

const unsubscriber1 = monitor.subscribe((newData => console.log(newData)));

monitor.start(); // wii invoke all subscribers each call

monitor.unsubscribe(subscriber2);
unsubscriber1(); // will remove subscriber from object

monitor.destroy();

```
npm package: @lohan9999/rn-calendar-events
Description: A modern React Native module for calendar events
Author: LohanJi
Latest version: 1.2.0

# rn-calendar-events

A modern React Native module for seamless access to native calendar functionality on both iOS and Android. Rebuilt for performance and compatibility with the New Architecture (TurboModules).

## Features

- Create, fetch, update, and delete calendar events.
- Permission handling for both platforms.
- Support for multiple calendars.
- Modern Swift (iOS) and Kotlin (Android) implementations.

## Installation

```sh
npm install @lohan9999/rn-calendar-events
# or
yarn add @lohan9999/rn-calendar-events
```

### iOS Setup
Add the following to your `Info.plist`:
```xml
<key>NSCalendarsUsageDescription</key>
<string>This app requires access to your calendar to schedule events.</string>
<key>NSCalendarsFullAccessUsageDescription</key>
<string>This app requires full access to your calendar to manage events.</string>
```

### Android Setup
Permissions are automatically added to your manifest by the library, but ensure your app handles runtime permissions if targeting Android 6.0+.

## Usage

### Permissions

```typescript
import RnCalendarEvents from 'rn-calendar-events';

const status = await RnCalendarEvents.requestPermissions();
if (status === 'authorized') {
  // Access granted
}
```

### Fetching Calendars

```typescript
const calendars = await RnCalendarEvents.findCalendars();
console.log(calendars);
```

### Creating an Event

```typescript
const eventId = await RnCalendarEvents.saveEvent('New Meeting', {
  startDate: '2026-06-01T10:00:00.000Z',
  endDate: '2026-06-01T11:00:00.000Z',
  notes: 'Discuss project roadmap',
});
```

### Fetching Events

```typescript
const events = await RnCalendarEvents.fetchAllEvents(
  '2026-01-01T00:00:00.000Z',
  '2026-12-31T23:59:59.000Z'
);
```

## License

MIT

---

Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)