open-index/open-npm huggingface dataset:
npm package: @synclab/eslint-config
Description: ESLint configuration used by SyncLab.
Latest version: 1.1.2

# SyncLab ESLint config

Inspired by [Rocketseat ESLint config](https://github.com/Rocketseat/eslint-config-rocketseat).

## Whats included?

- Standard config base;
- React plugin;
- React Hooks plugin;
- JSX a11y plugin;
- Prettier;

## Setup

1. Install the dependencies

```bash
npm i -D eslint @synclab/eslint-config
```

2. Create a `.eslintrc.json` file extending the config:

```json
{
  "extends": "@synclab/eslint-config/react"
  // "extends": "@synclab/eslint-config/node"
}
```

> You can also use a `.eslintrc.js` instead of JSON if you prefer.
npm package: @synconset/angular-selectize
Description: AngularJS directive for selectize
Latest version: 2.0.2

angular-selectize
==================
![selectize5](https://cloud.githubusercontent.com/assets/4087667/5633745/2cfeac18-958f-11e4-9e62-6eba90547b4c.png)

###Demo
[Try the Demo on Plunker](http://plnkr.co/edit/X2YYPX?p=preview)

###Features
This is an Angular.js directive for Brian Reavis's [selectize jQuery plugin](http://brianreavis.github.io/selectize.js/). It supports all of Selectize's features. Here are some highlights:

* Better performance than UI-Select ([ui-select](http://plnkr.co/edit/pSJNHS?p=preview) vs [angular-selectize](http://plnkr.co/edit/xdyzf9?p=preview))
* Selectize is ~7kb (gzipped)
* Smart Ranking / Multi-Property Searching & Sorting
* Angular Models & Bindings
* Skinnable
* Keyboard support





## Dependencies

- [AngularJS](http://angularjs.org/)
- [JQuery](http://jquery.com/)
- [Selectize](http://brianreavis.github.io/selectize.js/)

## Install
Install with [Bower](http://bower.io)

`$ bower install angular-selectize2`

Load the script files in your application:
```html
<link rel="stylesheet" href="bower_components/selectize/dist/css/selectize.default.css ">
<script type="text/javascript" src="bower_components/jquery/jquery.js"></script>
<script type="text/javascript" src="bower_components/selectize/dist/js/standalone/selectize.min.js"></script>
<script type="text/javascript" src="bower_components/angular/angular.js"></script>
<script type="text/javascript" src="bower_components/angular-selectize2/dist/selectize.js"></script>
```


Add the selectize module as a dependency to your application module:

```javascript
var myAppModule = angular.module('MyApp', ['selectize']);
```

## Basic Usage
Setup your controller variables:

```javascript
$scope.myModel;
$scope.myOptions = ['Spectrometer', 'Star Chart', 'Laser Pointer'];
```

Add the selectize element to your view template:

```html
<selectize options='myOptions' ng-model="myModel"></selectize>
```

## Advanced Usage

```javascript
$scope.myModel = 1;

$scope.myOptions = [
  {id: 1, title: 'Spectrometer'},
  {id: 2, title: 'Star Chart'},
  {id: 3, title: 'Laser Pointer'}
];

$scope.myConfig = {
  create: true,
  valueField: 'id',
  labelField: 'title',
  delimiter: '|',
  placeholder: 'Pick something',
  onInitialize: function(selectize){
    // receives the selectize object as an argument
  },
  // maxItems: 1
};
```


```html
<selectize config='myConfig' options='myOptions' ng-model="myModel"></selectize>
```


##Documentation
- [Selectize config options](https://github.com/brianreavis/selectize.js/blob/master/docs/usage.md)
- [Selectize API](https://github.com/brianreavis/selectize.js/blob/master/docs/api.md)

##Config
####Inline

```html
<selectize config="{create:true, maxItems:10}" options='myOptions' ng-model="myModel"></selectize>
```


####Global
To define global defaults, you can configure the `selectize` injectable:

```javascript
MyApp.value('selectizeConfig', {
  delimiter: '|'
});
```
npm package: @synconset/knex-cleaner
Description: Database cleaner for Knex.js and bookshelf.js
Author: Steven Ferguson
Latest version: 1.2.1

# knex-cleaner
Helper library to clean a PostgreSQL, MySQL or SQLite3 database tables using Knex. Great for integration tests.

###Installation
```
npm install knex-cleaner
```

###Usage
```javascript
var knexCleaner = require('knex-cleaner');

var knex = require('knex')({
  client: 'mysql',
  connection: {
    host     : '127.0.0.1',
    user     : 'your_database_user',
    password : 'your_database_password',
    database : 'myapp_test'
  }
});

knexCleaner.clean(knex).then(function() {
  // your database is now clean
});

// You can also use this in BookshelfJS
var bookshelf = require('bookshelf')(knex);

knexCleaner.clean(bookshelf.knex).then(function() {

});

// You can also pass if it deletes the tables with delete instead of truncate
// as well as a list of tables to ignore.

var options = {
  mode: 'delete', // Valid options 'truncate', 'delete'
  ignoreTables: ['Dont_Del_1', 'Dont_Del_2']
}

knexCleaner.clean(knex, options).then(function() {
  // your database is now clean
});
```
The example above used MySQL but it has been tested on PostgreSQL and SQLite3.
npm package: @synconset/typeormgen
Description: Generate typeorm models from your database tables
Latest version: 2.1.4

# typeormgen
Generate typeorm models from your database tables

### Command Line Usage

```
Options:
--base, -b                    Path to a file containing a class for the model
                              to exend.  The class should be the default
                              export
--host, -h                    Database host url
--port, -p                    Port the database is exposed on
--user, -u                    Database username
--password                    Database password
--configFile                  Path to json config file
--envFile                     Path to env file to be parsed by dotenv
--database, -d                Database name
--table, -t                   Table name to generate a model for    [required]
--model, -m                   Model class name.  Will default to converting
                              snake case table name to PascalCase
--moment                      Use Date | Moment for the type for dates instead
                              of just Date                           [boolean]
--rules, -r                   Output a static rules function that returns
                              basic joi validation rules             [boolean]
--toJSON                      Output a toJSON function that returns the
                              model's properties
--pluralization               Whether the name of the model should be plural
                              e.g., table users to model Users or User
--out, -o                     Path to where model file will be written
                                                                    [required]
--tabs                        Use tabs instead of spaces             [boolean]
--tabSize                     Number of spaces to indent lines
--primaryGeneratedColumn      Column to decorate with
                              @PrimaryGeneratedColumn()
--primaryGeneratedColumnUUID  Column to decorate with
                              @PrimaryGeneratedColumn('uuid')
--primaryColumn               Column to decorate with @PrimaryColumn()
--createDateColumn            Column to decorate with @CreateDateColumn()
--updateDateColumn            Column to decorate with @UpdateDateColumn()
--versionColumn               Column to decorate with @VersionColumn()
--help                        Show help                              [boolean]
```

### Config File Example

```
{
    "host": "localhost",
    "port": 3306,
    "user": "user",
    "password": "password",
    "database": "database",
    "rules": true,
    "toJSON": true,
    "pluralization": false,
    "moment": true,
    "tabSize": 2
}
```

### Environment Variable Configuration

```
MYSQL_HOST=localhost
MYSQL_PORT=3306
MYSQL_DATABASE=database
MYSQL_USER=user
MYSQL_PASSWORD=password

TYPEORMGEN_HOST=localhost
TYPEORMGEN_CONFIG_FILE=/home/user/config.json
TYPEORMGEN_ANY_OPTION
```
npm package: @syncpoint/signs
Description: Military symbols based on milsymbol.
Author: horst.dehmer@syncpoint.io
Latest version: 1.1.0

## Ideas for possible improvements for milsymbol

### GENERAL
* favor maintainability over time/performance over space/memory
* reduce overall complexity (1,827 branches, 28,534 statements)
* consistently apply ES6 style throughout the code
* replace deprecated String.substr()
* replace == and != with === and !==
* use immutable objects whenever appropriate (incl. Symbol)
* never modify actual parameters
* remove/replace all var declarations
* favor map/reduce over loops
* reduce (global) symbol state as far as possible

### SPECIFIC
* drop Canvas2D support (for now)
* define icon parts statically, preferably in JSON definition files
* defer styling as long as possible
* add named styles to icon parts depending on symbol options
* use SVG compliant attributes throughout the code
* hoist default style attributes to SVG namespace
* define icons (composition of icon parts) declaratively (NICE TO HAVE)
* introduce SVG group to scale/transform icon parts
* improve separation of symbol style options and effective style
* remove icon cache
* move SIDC-dependent metadata to JSON configuration (NICE TO HAVE)
* abstract styling over letter and number SIDC (alpha/numeric)

### CANCELLED
* IMPRACTICAL - use XML library to generate SVG from JavaScript object
* OVER-ENGINEERED - use simple layout framework for placement/alignment
* IMPRACTICAL - use expression framework for dynamic texts
npm package: @syncr/angular
Description: Angular adapter for Syncr – Signals + RxJS state synchronization.
Author: Vidhyut Rabari
Latest version: 0.1.4

🅰️ 3) README for @syncr/angular

@syncr/angular
Angular Signals & RxJS adapter for Syncr


📦 Install
npm install @syncr/core @syncr/angular


Requires:

Angular 16+

RxJS 7+

⚡ Quickstart
import { Component } from '@angular/core';
import { createSyncrSignal } from '@syncr/angular';

@Component({
  selector: 'app-root',
  standalone: true,
  template: `
    <input [value]="filters().q" (input)="update($event.target.value)" />
    <pre>{{ filters() | json }}</pre>
  `
})
export class AppComponent {
  { filters, setFilters } = createSyncrSignal({
    key: 'filters',
    defaultValue: { q: '', sort: 'date', page: 1 },
    channels: ['url', 'storage']
  });

  update(v: string) {
    this.setFilters(p => ({ ...p, q: v }));
  }
}

🎉 Features

Angular Signals support

Optional RxJS store API

URL + storage + encrypted + API channels

SSR-safe

Built for scalable enterprise apps

🧩 Zod Schemas
schema: zodSchema(FilterSchema)

📚 Docs

See root README for:

Channels

Encrypted Storage

API Sync

Router integration

Storybook examples

📝 License

MIT © Vidhyut Rabari
npm package: @syncr/core
Description: Core engine for Syncr – multi-channel state synchronization library.
Author: Vidhyut Rabari
Latest version: 0.1.4

📦 1) README for @syncr/core



@syncr/core
The core multi-channel state synchronization engine powering Syncr.


🌟 About

@syncr/core provides the framework-agnostic engine that synchronizes application state across:

🌐 URL query parameters

💾 LocalStorage / SessionStorage

🔐 Encrypted Storage (AES-GCM)

🪟 BroadcastChannel (multi-tab sync)

☁️ API (ETag/version-aware syncing)

It powers all framework adapters (React, Angular, Vue, Svelte).

📦 Installation
npm install @syncr/core

⚡ Basic Usage (Vanilla JS)
import { createSyncr } from '@syncr/core';

const { get, set, subscribe } = createSyncr({
  key: 'filters',
  defaultValue: { q: '', sort: 'date', page: 1 },
  channels: ['url', 'storage'],
});

🔌 Built-in Channels
✔ URL Channel

Syncs state with query parameters.

✔ Storage Channel

Persists state in localStorage.

✔ Encrypted Storage Channel

AES-GCM encryption using WebCrypto.

import { storageEncryptedChannel } from '@syncr/core';

const enc = storageEncryptedChannel('settings', {
  passphrase: 'my-secret-pass'
});

✔ BroadcastChannel

Real-time cross-tab sync.

broadcastChannel('cart')

✔ API Channel

Server synchronization with conflict detection.

apiChannel('profile', { baseUrl: '/api' })

🧩 Schema Validation (Zod)
import { z } from 'zod';
import { zodSchema } from '@syncr/core';

useSyncr({
  schema: zodSchema(
    z.object({ q: z.string(), page: z.number().min(1) })
  )
});

📚 Documentation

🔐 Encrypted Storage → docs/ENCRYPTED_STORAGE.md

🪟 BroadcastChannel → docs/BROADCAST.md

🌐 API Sync → docs/API_CHANNEL.md

🧩 Zod → docs/ZOD.md

SSR/Router helpers → docs/ROUTER_AND_SSR.md

📝 License

MIT © Vidhyut Rabari
npm package: @syncr/react
Description: React adapter for Syncr – useSyncr hook for synchronized state.
Author: Vidhyut Rabari
Latest version: 0.1.4

⚛️ 2) README for @syncr/react

Save as:
packages/react/README.md

@syncr/react
React hooks for the Syncr multi-channel state engine






📦 Install
npm install @syncr/core @syncr/react

⚡ Quickstart
import { useSyncr } from '@syncr/react';

export function Users() {
  const [filters, setFilters] = useSyncr({
    key: 'filters',
    defaultValue: { q: '', sort: 'date', page: 1 },
    channels: ['url', 'storage'],
  });

  return (
    <>
      <input
        value={filters.q}
        onChange={(e) => setFilters(p => ({ ...p, q: e.target.value }))}
      />
      <pre>{JSON.stringify(filters, null, 2)}</pre>
    </>
  );
}

🚀 Features
✔ useSyncr hook

Synchronizes state across channels.

✔ Debounced writes

Avoids excessive URL/storage writes.

✔ SSR Safe

Auto-detects browser vs server.

✔ Deep merging & immutability

Updater functions use React patterns.

🧩 With Encrypted Storage
const encrypted = storageEncryptedChannel('filters', {
  passphrase: 'top-secret'
});

useSyncr({
  key: 'filters',
  defaultValue: {},
  channels: ['url', encrypted]
});

🪟 Multi-Tab Sync
useSyncr({
  key: 'cart',
  channels: ['storage', broadcastChannel('cart')]
});

🧠 With Zod Validation
import { z } from 'zod';
import { zodSchema } from '@syncr/core';

useSyncr({
  schema: zodSchema(z.object({
    q: z.string(),
    page: z.number().min(1)
  }))
});

📚 Documentation

See repo root README for:

Channels

API Sync

Zod integration

Examples

Storybook playground

📝 License

MIT © Vidhyut Rabari
npm package: @syncr/svelte
Description: Svelte adapter for Syncr – Svelte stores for synchronized state.
Author: Vidhyut Rabari
Latest version: 0.1.4

🟧 5) README for @syncr/svelte

@syncr/svelte
Svelte store adapter for Syncr

📦 Install
npm install @syncr/core @syncr/svelte

⚡ Quickstart
<script lang="ts">
  import { syncrStore } from '@syncr/svelte';

  const { store, setStore } = syncrStore({
    key: 'filters',
    defaultValue: { q: '', sort: 'date', page: 1 },
    channels: ['url', 'storage']
  });
</script>

<input bind:value={$store.q} />
<pre>{JSON.stringify($store, null, 2)}</pre>

🎉 Features

Svelte writable store interface

URL + storage + encrypted

Multi-tab sync

API channel

Zod support

📚 Docs

See root README.

📝 License

MIT © Vidhyut Rabari