open-index/open-npm huggingface dataset:
npm package: @qubit-rs/svelte
Description: Seamless RPC for Rust & TypeScript - Svelte style
Author: Tom Anderson
Latest version: 0.0.6

# create-svelte

Everything you need to build a Svelte library, powered by [`create-svelte`](https://github.com/sveltejs/kit/tree/main/packages/create-svelte).

Read more about creating a library [in the docs](https://kit.svelte.dev/docs/packaging).

## Creating a project

If you're seeing this, you've probably already done this step. Congrats!

```bash
# create a new project in the current directory
npm create svelte@latest

# create a new project in my-app
npm create svelte@latest my-app
```

## Developing

Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:

```bash
npm run dev

# or start the server and open the app in a new browser tab
npm run dev -- --open
```

Everything inside `src/lib` is part of your library, everything inside `src/routes` can be used as a showcase or preview app.

## Building

To build your library:

```bash
npm run package
```

To create a production version of your showcase app:

```bash
npm run build
```

You can preview the production build with `npm run preview`.

> To deploy your app, you may need to install an [adapter](https://kit.svelte.dev/docs/adapters) for your target environment.

## Publishing

Go into the `package.json` and give your package the desired name through the `"name"` option. Also consider adding a `"license"` field and point it to a `LICENSE` file which you can create from a template (one popular option is the [MIT license](https://opensource.org/license/mit/)).

To publish your library to [npm](https://www.npmjs.com):

```bash
npm publish
```
npm package: @qubitabhay/prisma-ddl-generator
Description: This package generates SQL DDL statements from a Prisma schema for various SQL dialects, including MySQL, PostgreSQL, SQLite, and MariaDB.
Author: QUBITABHAY
Latest version: 0.0.3

# prisma-ddl-generator

Generate SQL DDL from a Prisma schema using Prisma DMMF. Supports MySQL, MariaDB, PostgreSQL, and SQLite.

## Install

Local project (as a dev tool):

```bash
npm i @qubitabhay/prisma-ddl-generator
```

Or clone this repo and use via `npm link`:

```bash
npm link
```

## CLI Usage

```bash
npx ddlgen --dialect <mysql|postgres|sqlite|mariadb> --schema ./schema.prisma --out output.sql
```

- `--dialect` / `-d`: Target SQL dialect (default: mysql)
- `--schema`  / `-s`: Path to Prisma schema (default: ./schema.prisma)
- `--out`     / `-o`: Output file (default: output.<dialect>.sql)

Examples:

```bash
# MySQL (MariaDB uses the same output)
npx ddlgen -d mysql -s schema.prisma -o schema.mysql.sql

# PostgreSQL
npx ddlgen -d postgres -s schema.prisma -o schema.postgres.sql

# SQLite
npx ddlgen -d sqlite -s schema.prisma -o schema.sqlite.sql
```

## Library Usage

```js
import { prismaToSQL, genSQL } from 'prisma-ddl-generator';
import { getDMMF } from '@prisma/internals';
import fs from 'fs';

// From a Prisma schema file
const sql = await prismaToSQL({ schemaPath: './schema.prisma', dialect: 'postgres' });
console.log(sql);

// Or from a DMMF you already have
const schema = fs.readFileSync('./schema.prisma', 'utf8');
const dmmf = await getDMMF({ datamodel: schema });
const sql2 = genSQL(dmmf, 'mysql');
```

## Notes
- Enums are emitted as:
  - PostgreSQL: `CREATE TYPE ... AS ENUM (...)` and used by columns
  - MySQL/MariaDB: inline `ENUM('A','B',...)`
  - SQLite: stored as `VARCHAR(...)` (SQLite has no native enums)
- Foreign keys are inferred from `*Id` fields (heuristic). For perfect fidelity, extend to use relation metadata in DMMF.
- Defaults: `now()` becomes `CURRENT_TIMESTAMP(3)` for MySQL/Postgres and `CURRENT_TIMESTAMP` for SQLite. Primitive defaults are inlined.

## License
MIT
npm package: @qubixstudio/qunity
Description: Helper framework for working with threejs based on Unity3D ideas.
Author: Qubix
Latest version: 0.3.16

# qunity

Three.js wrapper. Using Unity system of Gameobjects and components. Check example folder for some examples. Handle more camera in scene and their drawing. You can create own component in your project.  Every component extends Monobehaviour. 

## Version 0.3.0

update three.js version, add three js as peer dependency

## Component example
Each component should have a onDestroy method. Qunity handle destroing Gameobject and his components. 

    export abstract class Primitive extends Component {
      abstract mesh: Mesh;
      /** @internal */
      constructor() {
        super()
      }

      changePosition(): void {
        this.mesh.position.y += 1;
      }

      gameObjectSet(gameObject: GameObject): void {
        gameObject.attach(this.mesh);
      }

      onDestroy(): void {
        if(this.mesh)
          if(this.mesh.geometry)
            this.mesh.geometry.dispose()
          if(this.mesh.material)
            Utils3D.disposeMaterialSave(this.mesh.material);
      }
    }

## Gameobject
  create new GameObject

    const go = GameObject.create() // create new instance, the constructor cannot be used
    this.transformControls = go.addComponent(TransformControls);
    this.transformControls.addListener('dragging-changed', this.transformDraggingChange);
    GameObject.add(go); //adding object to scene

## Created by Qubix 
  https://www.qubixstudio.com/

## Licence
https://opensource.org/licenses/MIT
npm package: @qubixstudio/webinput
Description: Helper for working with input in web development, dedicated mostly for threejs projects.
Author: Qubix
Latest version: 0.0.19

# webinput
Handle mouse and keyboard inputs by interface. Using  

# Web Input Interface  

    onMouseClick(event: QMouseEvent): void
    onMouseDown(event: QMouseEvent): void
    onMouseDrag(event: QMouseEvent): void
    onMouseUp(event: QMouseEvent): void
    onMouseMove(event: QMouseEvent): void
    onMouseDragClick(event: QMouseEvent): void
    onKeyDown(event: KeyboardEvent): void
    onKeyUp(event: KeyboardEvent): void

# Usage 
    import { IInputListener, QMouseEvent, InputMgr } from '@qubixdevops/webinput';
    class YourCalss implements IInputListener {
      initInput() : void {
        InputMgr.instance.registerDom("HTMLCanvasElement");
        InputMgr.instance.addListener(this);
      }

      destroy() : void {
         InputMgr.instance.unregisterDom("HTMLCanvasElement");
      }

      onMouseClick(event: QMouseEvent): void {
          //handle mouse click
      }

      onKeyDown(event: KeyboardEvent): void {
          //handle key click
      }
    }

## Created by qubixstudio
https://www.qubixstudio.com/
npm package: @qubyte/appended-file-watcher
Description: Watch a file for changes due to data being appended to it.
Latest version: 0.1.0

# appended file watcher

This module exposes a function. Given a file path, this function creates a
watcher for that file and returns an event emitter. On change events, the file
is opened, appended data read, and a buffer with the new content emitted. A new
change is then awaited.

Between emitting content and the next change event, the file is closed.

## API

### `createWatcher(path: PathLike) => relay: EventEmitter`

The returned event emitter can emit three kinds of event:

 - `('append', buffer)` when data is appended to the file.
 - `('error', error)` when there was an error handling the file.
 - `('close')` when watching has stopped. Emitted as the last event after
   `relay.close` is called.

### `relay.close() => void`

Calling `relay.close()` closes the underlying watcher and unregisters internal
events.
npm package: @qubyte/gamma
Description: the gamma function (Γ)
Latest version: 2.0.0

# gamma

[gamma function](http://en.wikipedia.org/wiki/Gamma_function)
in javascript using the
[lanczos approximation](http://en.wikipedia.org/wiki/Lanczos_approximation)
for small values and the 
[spouge approximation](https://en.wikipedia.org/wiki/Spouge's_approximation) for
larger values

# example

```
> import gamma from 'gamma'
> gamma(5)
23.999999999999996
> gamma(1.6)
0.8935153492876909
```

# methods

import gamma from 'gamma'

## gamma(z)

Return the gamma function over `z`. Complex numbers aren't supported, only reals.

## log(z)

```
import { log } from 'gamma'
```

Return the natural log of the gamma function for `z`.

This function is used internally by the spouge approximation to compute large
values.

# install

With [npm](http://npmjs.org) do:

```
npm install @qubyte/gamma
```

# kudos

Implementation transliterated from the python script on the wikipedia entry for
the
[lanczos approximation](http://en.wikipedia.org/wiki/Lanczos_approximation).

Spouge approximation from [Niggler](https://github.com/Niggler).

# license

MIT