open-index/open-npm huggingface dataset:
npm package: @jcu-test/jcudatetime
Description: Jcu Date and Time
Author: Mahendra Patel
Latest version: 0.1.3-alpha.0

# `@jcu-test/jcudatetime`

> TODO: description

## Usage

```
const jcudatetime = require('@jcu-test/jcudatetime');

// TODO: DEMONSTRATE API
```
npm package: @jcu/promised-ldap
Description: A thin wrapper over ldapjs to give a promise interface and a couple of other goodies
Author: JCU eResearch Centre
Latest version: 0.4.0


promised-ldap
=============

This library is a quick-n-dirty shim over [ldapjs](https://github.com/mcavage/node-ldapjs) to add
promises and easier authentication.  It currently only supports the client interface.

Usage
-----

To create a new client:

```js
var LdapClient = require('promised-ldap');
var client = new LdapClient({url: 'ldap://127.0.0.1:389'});
```

The options argument to the constructor is identical to the options argument used in `ldapjs` for
`ldap.createClient`.  Please see the docs [here](http://ldapjs.org/client.html).

It supports the other methods documented there as well, except that instead of taking a callback, the methods
return a promise.  E.g.:

```js
client.bind('username', 'password').then(function () { ... });
```

The `search` method in `ldapjs` is now accessible (in promisified form) by `client._search`.  I
have provided a method `client.search` with similar behaviour as the original but an arguably
easier API.  E.g.:

```js
client.search(base, options).then(function (result) {
  /* result is:
  {
    entries: [...],
    references: [...]
  }
  no messing about with EventEmitters!
  */
});
```

Let's face it, the reason why you're messing about with LDAP is probably to add LDAP authentication
to your app, so I've added a couple of helper method for this:

```js
client.authenticate(base, cn, password).then(function (result) {
  // if the authentication succeeded, then result is the LDAP user object
  // otherwise, it is null
});
```

This basically does a `bind` using the supplied credentials, and if successful, does a `search` for
the specified user and returns that.

If all you really wanted was the user's name, email address, and list of unqualified groups, we
can do that too:

```js
client.authenticateUser(base, cn, password).then(function (result) {
  /*
  if the authentication succeeded, then result is:
  {
    name: <the user's DisplayName>,
    email: <the user's PrincipalName>,
    groups: <an array of the CNs of groups which are in the base CN>
  }
  otherwise, result is null
  */
});
```

Pull requests and suggestions are welcome!
npm package: @jcubegroup/bootstrap-vue-3
Description: Early (but lovely) implementation of Vue 3, Bootstrap 5 and Typescript
Latest version: 0.1.6

<p align="center">
  <a href="https://cdmoro.github.io/bootstrap-vue-3/">
    <img src="https://raw.githubusercontent.com/cdmoro/bootstrap-vue-3/main/static/logo.png" width="300">
  </a>
</p>

<h1 align="center">BootstrapVue 3</h1>
<p align="center">Early (but lovely) implementation of Vue 3, Bootstrap 5 and Typescript</p>

<br>

<p align="center">
  <a href="https://www.npmjs.com/package/bootstrap-vue-3">
    <img src="https://flat.badgen.net/npm/v/bootstrap-vue-3" alt="Current version">
  </a>
  <a href="https://getbootstrap.com/docs/5.0/getting-started/introduction/">
    <img src="https://flat.badgen.net/badge/bootstrap/5.0.x/563d7c" alt="Bootstrap version">
  </a>
  <a href="https://v3.vuejs.org/">
    <img src="https://flat.badgen.net/badge/vue.js/3.0.x/4fc08d" alt="Vue.js version">
  </a>

  <a href="https://github.com/cdmoro/bootstrap-vue-3/actions?workflow=Tests">
    <img src="https://flat.badgen.net/github/status/cdmoro/bootstrap-vue-3" alt="Build status">
  </a>

  <br>

  <a href="https://www.npmjs.com/package/bootstrap-vue-3">
    <img src="https://flat.badgen.net/npm/dt/bootstrap-vue-3" alt="npm downloads">
  </a>
  <a href="https://www.npmjs.com/package/bootstrap-vue-3">
    <img src="https://flat.badgen.net/npm/dw/bootstrap-vue-3" alt="npm weekly downloads">
  </a>
</p>

# Why BootstrapVue3?

BootstrapVue3 is an attempt to have [BootstrapVue](https://bootstrap-vue.org/) components in Vue3, Bootstrap 5, and typescript. Another goal is to have components written in a simple and readable way.

As you may suppose, this library is heavily inspired by **BootstrapVue**, as well as the components properties, events, slots, directives, etc. We want to make it that way because we want to have compatibility with **BootstrapVue**, so it will be easy to switch between libraries.

# Install

```console
# NPM
npm i --save bootstrap bootstrap-vue-3

# Yarn
yarn add bootstrap bootstrap-vue-3
```

# Contribute & support 🙌

This project is still in **alpha version** so there is a lot of work to do. If you want to contribute you can:

- submit an [issue](https://github.com/cdmoro/bootstrap-vue-3/issues/new)
- or better, a [pull request](https://github.com/cdmoro/bootstrap-vue-3/pulls)
- or even better, visit [my patreon page](https://patreon.com/cdmoro) and support me 😄

## One-time donations

Or if you prefer you can make a one-time donation through these channels:

[!["Buy Me A Coffee"](https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png)](https://www.buymeacoffee.com/cdmoro)
[![Invitame un café en cafecito.app](https://cdn.cafecito.app/imgs/buttons/button_2.svg)](https://cafecito.app/cdmoro)

# Links

- :blue_book: [Documentation](https://cdmoro.github.io/bootstrap-vue-3/)

# License

Released under the MIT [Licence](./LICENSE). Copyright (c) BootstrapVue3.

# Making a new release

```
npm run release
git push --follow-tags
```

then https://github.com/cdmoro/bootstrap-vue-3/releases/new
npm package: @jcubegroup/vue-grid
Description: It's css grid component.
Author: jcubegroup
Latest version: 2.0.2

# vue-Grid 
It's css grid component.

## Install
`npm i @jcubegroup/vue-grid`

## Usage

```js
import Vue from 'vue'
import vGrid from '@jcubegroup/vue-grid'
Vue.use(vGrid)
```

```vue
<v-grid :cols="6" :rows="3" class="ui-gap-2">
    <v-col :col="4" :col-start="2">1</v-col>
    <v-col :row="2" :col-start="1" :col-end="3">2</v-col>
    <v-col :col="3" :col-end="7">3</v-col>
    <v-col :col-start="3" :col="'full'">4</v-col>
</v-grid>
```

[Full documentation](http://vue-grid.jcubegroup.com/guide/)
npm package: @jcubic/lily
Description: Very simple option parser inspired by YARGS with no dependencies
Author: Jakub T. Jankiewicz
Latest version: 0.5.0

# LILY

[![NPM Version](https://img.shields.io/npm/v/%40jcubic/lily)](https://www.npmjs.com/package/@jcubic/lily)
[![Test](https://github.com/jcubic/lily/actions/workflows/test.yml/badge.svg)](https://github.com/jcubic/lily/actions/workflows/test.yml)
[![Coverage Status](https://coveralls.io/repos/github/jcubic/lily/badge.svg?branch=master)](https://coveralls.io/github/jcubic/lily?branch=master)
[![LICENSE MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/NApp-notes/markdown-parser/blob/master/LICENSE)

[LILY is very simple option parser inspired by YARGS with no dependencies](https://github.com/jcubic/lily)

LILY stands for LILY Is Like Yargs

In fact it's inspired by [yargs-parser](https://www.npmjs.com/package/yargs-parser/) used by Yargs to parse the options.

## Installation

```bash
npm install --save @jcubic/lily
```

## Usage

```javascript
#!/usr/bin/env node
const lily = require('@jcubic/lily');
// or
import lily from '@jcubic/lily';

const options = lily(process.argv.slice(2), {boolean: ['b']});
```

if you run the script with:

```
./script -l 10 --hello 20 -asb one two three
```

you will get this object as result:

```
{
    "_": [
        "one",
        "two",
        "three"
    ],
    "l": "10",
    "hello": "20",
    "a": true,
    "s": true,
    "b": true
}
```

## License

Copyright (C) 2020-2025 [Jakub T. Jankiewicz](https://jcubic.pl/me)

Released under MIT license
npm package: @jcubic/vhtml
Description: Hyperscript reviver that constructs a sanitized HTML string.
Author: Jason Miller
Latest version: 2.2.1

# vhtml (fork)

[![NPM](https://img.shields.io/npm/v/vhtml.svg?style=flat)](https://www.npmjs.org/package/vhtml)
[![travis-ci](https://travis-ci.org/developit/vhtml.svg?branch=master)](https://travis-ci.org/developit/vhtml)

### **Render JSX/Hyperscript to HTML strings, without VDOM**

> Need to use HTML strings (angular?) but want to use JSX? vhtml's got your back.
>
> Building components? do yourself a favor and use [<img title="Preact" alt="Preact" src="https://cdn.rawgit.com/developit/b4416d5c92b743dbaec1e68bc4c27cda/raw/8dd78c9d138f13e3fec98cbdd6d1c619cf986ee0/preact-logo-trans.svg" height="24" align="top">](https://github.com/developit/preact)

[**JSFiddle Demo**](https://jsfiddle.net/developit/9q0vyskg/)

---


## Installation

Via npm:

`npm install --save @jcubic/vhtml`


---


## Usage

```js
// import the library:
import h from 'vhtml';

// tell babel to transpile JSX to h() calls:
/** @jsx h */

// now render JSX to an HTML string!
let items = ['one', 'two', 'three'];

document.body.innerHTML = (
  <div class="foo">
    <h1>Hi!</h1>
    <p>Here is a list of {items.length} items:</p>
    <ul>
      { items.map( item => (
        <li>{ item }</li>
      )) }
    </ul>
  </div>
);
```


### New: "Sortof" Components!

`vhtml` intentionally does not transform JSX to a Virtual DOM, instead serializing it directly to HTML.
However, it's still possible to make use of basic Pure Functional Components as a sort of "template partial".

When `vhtml` is given a Function as the JSX tag name, it will invoke that function and pass it `{ children, ...props }`.
This is the same signature as a Pure Functional Component in react/preact, except `children` is an Array of already-serialized HTML strings.

This actually means it's possible to build compositional template modifiers with these simple Components, or even higher-order components.

Here's a more complex version of the previous example that uses a component to encapsulate iteration items:

```js
let items = ['one', 'two'];

const Item = ({ item, index, children }) => (
  <li id={index}>
    <h4>{item}</h4>
    {children}
  </li>
);

console.log(
  <div class="foo">
    <h1>Hi!</h1>
    <ul>
      { items.map( (item, index) => (
        <Item {...{ item, index }}>
          This is item {item}!
        </Item>
      )) }
    </ul>
  </div>
);
```

The above outputs the following HTML:

```html
<div class="foo">
  <h1>Hi!</h1>
  <ul>
    <li id="0">
      <h4>one</h4>This is item one!
    </li>
    <li id="1">
      <h4>two</h4>This is item two!
    </li>
  </ul>
</div>
```
npm package: @jcwang587/geddes
Description: Node.js bindings for geddes (Rust XRD parser)
Latest version: 0.2.0

# Geddes

[![Crates.io](https://img.shields.io/crates/v/geddes)](https://crates.io/crates/geddes)
[![PyPI](https://img.shields.io/pypi/v/geddes)](https://pypi.org/project/geddes/)
[![npm](https://img.shields.io/npm/v/%40jcwang587%2Fgeddes)](https://www.npmjs.com/package/@jcwang587/geddes)


A Rust XRD pattern parser with Python and Node.js bindings. Supports:
- `.raw` (GSAS text or Bruker binary)
- `.rasx` (Rigaku Zip archive)
- `.xrdml` (Panalytical XML)
- `.xy` / `.xye` (Space-separated ASCII)
- `.csv` (Comma-separated values)

## Rust Usage

Load from a file path:

```rust
use geddes::read;

fn main() {
    let pattern = read("tests/data/xy/sample.xy").unwrap();
    println!("{} {}", pattern.x.len(), pattern.y.len());
}
```

Load from in-memory bytes (filename is used to infer the format):

```rust
use std::fs;

use geddes::read_bytes;

fn main() {
    let data = fs::read("tests/data/xy/sample.xy").unwrap();
    let pattern = read_bytes(&data, "sample.xy").unwrap();
    println!("{} {}", pattern.x.len(), pattern.y.len());
}
```

## Python Usage

Load from a file path:

```python
import geddes

pattern = geddes.read("tests/data/xy/sample.xy")
print(len(pattern.x), len(pattern.y))
```

Load from in-memory bytes (filename is used to infer the format):

```python
import geddes

with open("tests/data/xy/sample.xy", "rb") as f:
    data = f.read()

pattern = geddes.read_bytes(data, "sample.xy")
print(len(pattern.x), len(pattern.y))
```

## Node.js Usage

Load from a file path:

```javascript
const geddes = require('@jcwang587/geddes')

const pattern = geddes.read('tests/data/xy/sample.xy')
console.log(pattern.x.length, pattern.y.length)
```

Load from in-memory bytes (filename is used to infer the format):

```javascript
const fs = require('node:fs')
const geddes = require('@jcwang587/geddes')

const bytes = fs.readFileSync('tests/data/xy/sample.xy')
const pattern = geddes.readBytes(bytes, 'sample.xy')
console.log(pattern.x.length, pattern.y.length)
```

## License

MIT
npm package: @jcwang587/geddes-linux-arm-gnueabihf
Description: Node.js bindings for geddes (Rust XRD parser)
Latest version: 0.1.7-alpha

# `@jcwang587/geddes-linux-arm-gnueabihf`

This is the **armv7-unknown-linux-gnueabihf** binary for `@jcwang587/geddes`
npm package: @jcwang587/geddes-win32-arm64-msvc
Description: Node.js bindings for geddes (Rust XRD parser)
Latest version: 0.2.0

# `@jcwang587/geddes-win32-arm64-msvc`

This is the **aarch64-pc-windows-msvc** binary for `@jcwang587/geddes`
npm package: @jcwang587/geddes-win32-x64-msvc
Description: Node.js bindings for geddes (Rust XRD parser)
Latest version: 0.2.0

# `@jcwang587/geddes-win32-x64-msvc`

This is the **x86_64-pc-windows-msvc** binary for `@jcwang587/geddes`
npm package: @jcwatson11/gbo
Description: FH Global Business Objects project in nodejs
Author: Jon Watson
Latest version: 1.0.4

# NodeJs Food for the Hungry Global Business Objects (GBO)

This is a starting place for a NodeJs implementation of the FH GBO library.
It is a simple proof of concept (POC) demonstrating:

- Unit Tests for GBOs
- Unit Tests for Repositories
- Code Coverage for tests
- Automatic documentation generation

This library also provides provider arrays for inclusion in the NestJs framework.

## Project Origin and Context

The original POC was created to facilitate the FH Vision project, which uses Azure facial
recognition to process child profile photos, providing automatic cropping according to
the golden ratio, auto color balance, and recognition of inappropriate content using
artificial intelligence in order to reduce the number of working hours required to prepare
photos for printed materials in its efforts to acquire new sponsors for children involved
in FH field programs.

## Objects Implemented

Objects currently implemented are:

- Photo
- PhotoError
- PhotoErrorPhoto
- PhotoStatus
- PhotoLog

## Data Sources

The current implementation only gets data from a separated database that was isolated
from all other FH data systems. This is referred to as the "VisionDB".

## Initial Implementation

The first usage of this library was implemented in the NestJs framework.
As such, the usage instructions below will assume usage of that framework.
A more simplified usage example may be provided at a later date depending
on need.

## Usage

```typescript
// File: database.config.ts
import "reflect-metadata";
import * as dotenv from "dotenv";
dotenv.config();
import {Photo} from "./modules/Vision/gbo/Photo.gbo";
import {PhotoStatus} from "./modules/Vision/gbo/PhotoStatus.gbo";
import {PhotoErrorPhoto} from "./modules/Vision/gbo/PhotoErrorPhoto.gbo";
import {PhotoError} from "./modules/Vision/gbo/PhotoError.gbo";
import {SequelizeModuleOptions} from "@nestjs/sequelize";
import {PhotoLog} from "./modules/Vision/gbo/PhotoLog.gbo";
import {Dialect} from "sequelize/types";
import {OperatorAliases} from "@jcwatson11/sequelizeqsfind";

export const databaseConfig:SequelizeModuleOptions = {
   dialect: process.env.DB_DRIVER as Dialect
  ,host: process.env.DB_HOST
  ,port: +process.env.DB_PORT
  ,username: process.env.DB_USER
  ,password: process.env.DB_PASS
  ,database: process.env.DB_NAME
  ,models: [
     Photo
    ,PhotoErrorPhoto
    ,PhotoError
    ,PhotoStatus
    ,PhotoLog
  ]
  ,operatorsAliases: OperatorAliases
};

```
npm package: @jcx0/fastify-ts
Description: <h1 ><b>Fastify OpenAPI Typescript</b></h1>
Latest version: 0.0.0

<h1 ><b>Fastify OpenAPI Typescript</b></h1>

Generate Fastify routing types from OpenAPI specifications. This project is quick hack using the source from [@hey-api/openapi-ts](https://github.com/hey-api/openapi-ts).

## Features

- supports OpenAPI 2.0, 3.0, and 3.1 specifications
- supports both JSON and YAML input files
- supports external references using [json-schema-ref-parser](https://github.com/APIDevTools/json-schema-ref-parser/)

## Usage

Config copied from [@hey-api/openapi-ts](https://heyapi.vercel.app/openapi-ts/configuration.html).

Example server in `example/` directory.