open-index/open-npm huggingface dataset:
npm package: @nina-protocol/magic-admin-js
Description: Magic Authentication Admin Javascript SDK.
Author: Magic Labs
Latest version: 2.0.7

# Magic Authentication Admin Javascript SDK

[![Publish](https://github.com/magiclabs/magic-admin-js/actions/workflows/publish.yml/badge.svg?branch=master)](https://github.com/magiclabs/magic-admin-js/actions/workflows/publish.yml)
> The Magic Admin SDK lets developers secure endpoints, manage users, and create middlewares via easy-to-use utilities.

<p align="center">
  <a href="./LICENSE">License</a> ·
  <a href="./CHANGELOG.md">Changelog</a> ·
  <a href="./CONTRIBUTING.md">Contributing Guide</a>
</p>

## 📖 Documentation

See the [developer documentation](https://magic.link/docs/api-reference/server-side-sdks/node) to learn how you can master the Magic Admin SDK in a matter of minutes.

## 🔗 Installation

Integrating your Node.js application with Magic will require our server-side NPM package:

```bash
# Via NPM:
npm install --save @magic-sdk/admin

# Via Yarn:
yarn add @magic-sdk/admin
```

## ⚡️ Quick Start

Sign up or log in to the [developer dashboard](https://dashboard.magic.link) to receive API keys that will allow your application to interact with Magic's administration APIs.

```ts
const { Magic } = require('@magic-sdk/admin');

// In async function:
const magic = await Magic.init('YOUR_SECRET_API_KEY');
// OR
Magic.init('YOUR_SECRET_API_KEY').then((magic) => {
  magic
});
// Validate a token
try {
  magic.token.validate("DIDToken");
} catch (e) {
  console.log(e);
}
// Magic Auth - Get User Email
try {
  await magic.users.getMetadataByToken("DIDToken");
} catch (e) {
  console.log(e);
}
```
npm package: @ninanfm/feed
Description: > This package is still working in progress, take your own risk to use it.
Latest version: 1.0.0

# @ninanfm/feed

> This package is still working in progress, take your own risk to use it.

`@ninanfm/feed` is a feed generator with flexible APIs, it's designed to use with [TypeORM](https://typeorm.io).

## Table of Contents
- [@ninanfm/feed](#ninanfmfeed)
  - [Table of Contents](#table-of-contents)
  - [Supported Specifications](#supported-specifications)
  - [Quick Start](#quick-start)
  - [Predefined Models](#predefined-models)
  - [License](#license)

## Supported Specifications

- [x] [JSONFeed 1.1](https://jsonfeed.org/version/1.1)
- [x] [RSS 2.0](https://validator.w3.org/feed/docs/rss2.html)
- [x] [iTunes 1.0](https://help.apple.com/itc/podcasts_connect/#/itcb54353390)

## Quick Start

This package must to use with [reflect-metadata](https://www.npmjs.com/package/reflect-metadata), so you have to make sure that you have installed it.

```bash
yarn add reflect-metadata @ninanfm/feed
# or
npm i reflect-metadata @ninanfm/feed
```

Then add this line of code on the top of your entry file.

```
import 'reflect-metadata';
```

The next step is to define models to tell `@ninanfm/feed` how to generate your feed.
Here, we suppose that your are using this package with TypeORM and want to generate a RSS feed for your blog.

```typescript
import { RSS2_0 as RSS, xml } from '@ninanfm/feed';
import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';

@RSS.support
@Entity()
export class Post {
    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    slug: string;

    @Column('text')
    @RSS.item.description
    content: string;

    @RSS.item.author
    authorName: string;

    @RSS.item.pubDate
    publishedAt: Date;

    @RSS.item.link
    @RSS.item.guid({isPermaLink: true})
    get url(): string {
        return 'https://domain/posts/' + this.slug; 
    }

    @ManyToOne(() => Blog, blog => blog.posts)
    blog: Blog;
}

@RSS.support
@Entity()
export class Blog {
    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    @RSS.channel.title
    title: string;

    @Column('text')
    @RSS.channel.description
    description: string;

    @Column()
    slug: string;

    @RSS.channel.link
    readonly homePageUrl = 'https://domain';

    @OneToMany(() => Post, post => post.blog)
    posts: Post[];

    toRSS(): string {
        return xml.toString(this);
    }
}
```

That's it, now you can call `#toRSS` method on `Blog` instance to generate RSS feed.

## Predefined Models

Currently, we only defined a `Podcast` model, you can see the codes for `Podcast` model to find out how to use the advanced features of this package.

* [src/feed/podcast.ts](src/feed/podcast.ts)
* [src/example/podcast.ts](src/example/podcast.ts)

 ## License

[MIT](./LICENSE)
npm package: @ninanor/maplibre-gl-cog
Description: Maplibre protocol to handle cloud optimized geotiff
Author: niccolo.cantu@nina.no
Latest version: 0.0.2

# Maplibre-gl-cog

This library aims to provide maplibre support for Cloud Optimized GEOTiff

**NOTES**: The library requires that the GEOTiff has 4 bands (RGBA) and the values of each band is the range 0-255

## Dependencies
- GEOTiff.js
- fast-png

## Maplibre support
The library provides support up to maplibre 3.x.

### How to use it
In the map style prepend `cog://` to the url of the resource, for example: `cog://http://my-server.com/path/to/cloud-optimized-geotiff.tif`.
**NOTE**: also relative paths are supported (`cog://cloud-optimized-geotiff.tif`) 

Vanilla JS
```html
<link rel='stylesheet' href='https://unpkg.com/maplibre-gl@3.6.2/dist/maplibre-gl.css' />
<script src='https://unpkg.com/maplibre-gl@3.6.2/dist/maplibre-gl.js'></script>
<script src='maplibre-gl-cog.js'></script>
<script>
    const protocol = new maplibreglCOG.ProtocolV3();
    maplibregl.addProtocol('cog', protocol.tile);

    const map = new maplibregl.Map({
        container: 'map',
        style: 'style.json'
    });
</script>
```

ES6
```js
import { ProtocolV3 } from 'maplibre-gl-cog';
const protocol = new maplibreCOG.ProtocolV3();
maplibregl.addProtocol('cog', protocol.tile);
```

### How to generate a valid geotiff
Here is an example script that turns a grayscale single band GEOTiff into a RGBA compatible COG

```bash
export MASK=$(mktemp .cog.XXXXXXX.tif -p .)
export NORMALIZED=$(mktemp .cog.XXXXXXX.tif -p .)
export RGBA=$(mktemp .cog.XXXXXXX.tif -p .)

gdal_translate -scale 0 1 255 255 $1 $MASK   # turns any value into 255 to create a mask
gdal_translate -scale 0 1 0 255 $1 $NORMALIZED   # rescale the values to 0-255
gdal_merge.py -separate -o $RGBA -of GTiff $NORMALIZED $NORMALIZED $NORMALIZED $MASK  # creates 3 bands + mask
gdal_translate $RGBA $2 -of COG -co TARGET_SRS=EPSG:3857 -co ADD_ALPHA=NO -co COMPRESS=LZW -co LEVEL=9   # generate the COG
rm $MASK $NORMALIZED $RGBA;
```
npm package: @nindaff/ascii-tree
Description: WIP. More to come soon.
Latest version: 0.0.2

# ASCII Tree

WIP. More to come soon.

## Turn This
```js
const tree = {
  value: 'Foo',
  children: [
    {
      value: 'Bar',
      children: [
        'Bar-1',
        'Bar-2',
      ]
    },
    {
      value: 'Bang',
      children: [
        {
          value: 'Bang-1',
          children: [
            'Bang-1-1',
            'Bang-1-2',
            'Bang-1-3',
          ]
        },
        'Bang-2',
      ],
    },
  ],
};
```

## Into This
```txt
                                  Foo                                 
          __________________________|_______                          
          |                                |                          
        Bar                              Bang                         
     _____|___                       ______|_________________         
     |       |                       |                      |         
  Bar-1   Bar-2                   Bang-1                 Bang-2       
                         ____________|__________                      
                         |          |          |                      
                     Bang-1-1   Bang-1-2   Bang-1-3                   
```
npm package: @nine-lab/nine-board
Description: Custom Element based Whiteboard Component for Real-time Collaboration
Author: nine-lab
Latest version: 0.46.0

# @nine-lab/nine-board

실시간 판서 및 PDF 공유를 위한 웹 컴포넌트입니다.

## 설치
npm install @nine-lab/nine-board

## 사용법
1. 라이브러리 임포트
   import '@nine-lab/nine-board';

   2. HTML에서 사용
      <nine-board
          room-id="YOUR_ROOM_ID"
          user-id="YOUR_USER_ID"
          role="teacher"
          writable>
      </nine-board>

3. 소켓 설정 (React/JS)
   import { NineBoard } from '@nine-lab/nine-board';
   NineBoard.setHost("http://nineboard.com:4000");
npm package: @nine-lab/nine-util
Description: Custom Element based Util Component for Real-time Collaboration
Author: nine-lab
Latest version: 0.7.0

# @nine-lab/nine-util

실시간 협업, 판서 및 효율적인 디버깅을 위한 유틸리티 라이브러리입니다.

## 설치
npm install @nine-lab/nine-util

## 사용법
1. 실시간 로그 추적 (Trace)
    단순한 console.log 대신 서비스별로 색상과 이름표를 붙여 가독성 높은 로그를 남길 수 있습니다.

    import { trace } from '@nine-lab/nine-util';

    // 1. 초기화 (이름과 색상 설정)
    trace.init("NineBoard", "#4CAF50");
    
    // 2. 사용
    trace.log("서버 연결 시도...");
    trace.warn("연결 지연 발생");
    trace.error("연결 실패", err);
    
    // 배포 시 로그 끄기
    if (import.meta.env.PROD) trace.disable();

2. 작업 최적화 (TaskDebouncer)
    비동기 작업이나 잦은 이벤트 발생 시 중복 실행을 방지하고 순차적으로 처리합니다.

    import { trace } from '@nine-lab/nine-util';
    
    // 1. 초기화 (이름과 색상 설정)
    trace.init("NineBoard", "#4CAF50");
    
    // 2. 사용
    trace.log("서버 연결 시도...");
    trace.warn("연결 지연 발생");
    trace.error("연결 실패", err);
    
    // 배포 시 로그 끄기
    if (import.meta.env.PROD) trace.disable();

## API Reference
1. Trace
    trace.init(name, color): 로거의 헤더 이름과 테마 색상을 설정합니다.
    trace.enable() / trace.disable(): 로그 출력 여부를 제어합니다.
    trace.log() / .warn() / .error(): 스타일이 적용된 로그를 출력합니다.

2. TaskDebouncer
    new TaskDebouncer(delay): 대기 시간을 설정하여 인스턴스를 생성합니다.
    execute(task): 설정된 딜레이 이후 작업을 수행하며 중복 실행을 방지합니다.
npm package: @nine7soft/react-di
Description: Dependency Injection package for React
Author: nine7soft
Latest version: 1.0.0

# react-di

A dependency injection container package for React.

## How to configure it?

Create a config factory to return your dependency.

```javascript
const config = {
  hello: () => {
    return "Hello world!";
  },
};
```

Wrap the application with the ContainerProvider and pass your dependency config.

```javascript
ReactDOM.render(
  <React.StrictMode>
    <ContainerProvider config={config}>
      <App />
    </ContainerProvider>
  </React.StrictMode>,
  document.getElementById("root")
);
```

To access the dependency use the hook: useDependency.

```javascript
const hello = useDependency('hello')
```
npm package: @nine7soft/react-modx
Description: React-modx is an implementation of a Design Pattern Modular Redux. (https://www.genui.com/resources/modular-redux)
Author: nine7soft
Latest version: 1.0.4

# React-modx

React-modx is an implementation of a Design Pattern Modular Redux. (https://www.genui.com/resources/modular-redux)

## What is Modular Redux?

From the point of view of modular design, there were four main opportunities for improving Redux design patterns:

- Encapsulate
- Consolidate
- Isolate
- Minimize

## Example

You can look at the example in the git repository (https://github.com/nine7soft/react-modx)
### Hook

```javascript
import { useModularState } from "../../config/useModularState";
import * as reducers from "./reducers";
import * as sagas from "./sagas";
import { HelloStoreInterface } from "./HelloStoreInterface";

export function useHelloWorld() {
  const initialState: HelloStoreInterface = {
    example: {
      title: "",
      description: "",
    },
  };

  const [helloWorldValue, actions] = useModularState("helloWorldValue", initialState, {
    reducers: { ...reducers },
    sagas: { ...sagas },
  });

  return { helloWorldValue, actions };
}
```

### Saga

```javascript
import { put, getContext, call } from "redux-saga/effects";
import { SagaCallable } from "react-modx";
import { Types } from "../types";

export const getHelloWorld: SagaCallable = {
  type: Types.GET_HELLO_WORLD,
  call: function* () {
    const fakeApiClient: any = yield getContext("fakeApiClient");

    const response = yield call([fakeApiClient, "getHelloWorld"]);

    yield put({ type: Types.ADD_HELLO_WORLD, payload: response });
  },
};
```

### Reducer

```javascript
import { ReducerCallable } from "react-modx";
import { Types } from "../types";
import { HelloWorldInterface } from "../../../models/HelloWorldInterface";
import { HelloStoreInterface } from "../HelloStoreInterface";

export const addHelloWorld: ReducerCallable = {
  type: Types.ADD_HELLO_WORLD,
  call: (currentState: HelloStoreInterface, helloWorld: HelloWorldInterface[]) => {
    return {
      ...currentState,
      example: helloWorld[0],
    };
  },
};
```
npm package: @nine_tails9/vuemodelgenerator
Description: Generate Vue Files With speicified model details from components
Latest version: 1.1.3

# @nine_tails9/vuemodelgenerator
![npm](https://img.shields.io/badge/npm-1.1.1-blue.svg) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)


## Description

This tiny npm package let's you generate Vue Model Template to get started with your work.
Package includes basic primitives to boost your work. Primitives include basics like Button, Input Text, Input Email,
Checkboxes, searchable dropdowns and much more. 

## Installation


```
    npm i @nine_tails9/vuemodelgenerator
```

Then import globalcomponents in your Main.js 
## Usage
#### Format
```
    dg-vmg Ouput Input Path
```
Ouput is the name of model to be generated, Input is input Js file exporting an object contaning Model details.
Path is output path of file.
#### Example
```
    dg-vmg User './ff.js' './'
```
This command will generate User.vue in root directory using model from file 'ff.js' located in **bin**
directory.





## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.


## License
[MIT](https://github.com/nine-tails9/npm-VueGenerator/blob/master/LICENSE)
npm package: @ninedays-io/google-translate-token
Description: A package that generates the necessary token to use the Google Translate API for free
Author: Matheus Fernandes
Latest version: 1.0.0

# google-translate-token [![Build Status](https://travis-ci.org/matheuss/google-translate-token.svg?branch=master)](https://travis-ci.org/matheuss/google-translate-token) [![XO code style](https://img.shields.io/badge/code_style-XO-5ed9c7.svg)](https://github.com/sindresorhus/xo) [![Known Vulnerabilities](https://snyk.io/package/npm/google-translate-token/badge.svg)](https://snyk.io/package/npm/google-translate-token)

A package that generates the necessary token to use the [**Google Translate API for free** :dollar::no_entry_sign:](https://github.com/matheuss/google-translate-api)

## Why

[translate.google.com](https://translate.google.com) uses a token to authorize the requests. If you are not Google, you do not have this token and will have to [pay $20 per 1 million characters of text](https://cloud.google.com/translate/v2/pricing).

This package is the [result](https://github.com/matheuss/google-translate-token/blob/master/index.js#L12-110) of reverse engineering on the [obfuscated and minified code](https://translate.google.com/translate/releases/twsfe_w_20160620_RC00/r/js/desktop_module_main.js) used by Google to generate such token.

## How it works

The token is based on a seed which is updated once per hour and on the text that will be translated. Both are combined – by some strange math – in order to generate a final token (e.g. `820594.703830`) which is used by the API to validade the request. 


## Install

```
npm install --save google-translate-token
```

## Usage

``` js
const token = require('google-translate-token');

token.get('Hello').then(console.log);
//=> { name: 'tk', value: '159402.284291' }
```

## Related

- [`google-translate-api`](https://github.com/matheuss/google-translate-api) – A **free** and **unlimited** API for Google Translate :dollar::no_entry_sign: