open-index/open-npm huggingface dataset:
npm package: @royalzsoftware/royal-data-ts
Description: 🌟 Define your models and this package handle will handle the persistence
Author: Alexander Panov
Latest version: 0.4.3

# Royal Data TS
🚀 Define your models and this package will handle the persistence 

This package is a simple library using the power of repositories to unify data access to several different sources.

## Run the example in 4.738 seconds from now
```sh
$ cd /tmp && git clone https://github.com/royalzsoftware/royal-data-ts && cd royal-data-ts && npm install && npm run example
```

## Installation
#### npm
```bash
$ npm i @royalzsoftware/royal-data-ts
```

#### yarn
```bash
$ yarn add @royalzsoftware/royal-data-ts
```

## Example
```typescript
import { firstValueFrom } from "rxjs";
import { CrudRepository } from "./crud-repository";
import { CrudRepositoryBuilder } from "./crud-repository-builder";

// 0. create the user domain object
class User {
    private readonly permissions: string[] = [];

    constructor(public username: string, public password: string) { }

    addPermission(permission: string) {
        this.permissions.push(permission);
    }

    isAdminUser() {
        return this.permissions.includes('admin');
    }
}

// 1. inject the userRepository
async function test(userRepository: CrudRepository<User>) {
    // 2. create the user
    const user = new User("Alexander", "Panov");

    // 3. store the current user and retrieve newly created id
    const {id: userId} = await firstValueFrom(userRepository.create(user));

    // 4. add permission to the user
    user.addPermission('admin');

    // 5. update the user with the previously retrieved id and the user data
    const {model: updatedUser} = await firstValueFrom(userRepository.update(userId, user));

    // 6. print out if the admin is an admin user
    console.log(updatedUser.isAdminUser());
}

const repoBuilder = new CrudRepositoryBuilder<User>();

// 7. instantiate in memory repository
const userRepository = repoBuilder.inMemory();

// 8. or inject the http repository, by providing a http client.
const httpClient = undefined as any // YOUR JOB

const httpUserRepository = repoBuilder.http(httpClient, (userData: any) => {
    return new User(userData.username, userData.password);
}).withDefaultRouteDefinitions('/users');

// 9. run this shit
test(userRepository);
```

## 🌟 Highlights
- RxJs first
- `EventRepository` that holds the changes inMemory until you want to persist it by applying the events to a persisted CRUD Repository
- Zero dependencies besides Typescript
- Small modules that can be extended easily
- Shipped with `LocalStorage` adapter, for UI development without external depedencies
- Clear defined interfaces with low risk of wrong usage
- Ships with highly extensible `HTTP Repository`

## Releasing a new version
### Prerequisites
- Please do not have neither staged, nor unstaged changes, these will break the flow.
- You need to have make installed.
## Doing
- Rename the `UNRELEASED` section in the `CHANGELOG.md` file to following `DATE - SEMANTICVERSION` for example `2023-11-12 - 0.1.3`
- Then run `make`
npm package: @roybarber/kombo-typescript-sdk
Description: Typescript SDK for the Kombo.dev API
Author: Roy Barber
Latest version: 1.0.1

# Kombo Typescript SDK

The **Kombo Typescript SDK** simplifies the integration with Kombo's ATS, HRIS, and assessment APIs. It provides prebuilt API methods and models with full TypeScript support, making it easy to build scalable and type-safe applications.

---

## Key Features

- **Simplified API Access**: Predefined methods for all major endpoints.
- **TypeScript Support**: Built-in types and models for better developer experience.
- **Centralized Namespace**: Access all APIs and models through the unified `Kombo` namespace.
- **Configurable**: Support for global configuration (e.g., base URL, access tokens).

---

## Installation

Install the SDK using NPM or Yarn:

```bash
npm install @roybarber/kombo-typescript-sdk

Or with Yarn:

yarn add @roybarber/kombo-typescript-sdk
```

## Configuration

You can configure the SDK globally with reusable settings like baseURL and accessToken.

**Example Configuration:**
```typescript
import { client, getAtsJobs } from '@roybarber/kombo-typescript-sdk';

// You can make the below reusable
client.setConfig({
  baseUrl: 'https://api.kombo.dev/v1',
  headers: {
    Authorization: 'Bearer process.env.KOMBO_API_TOKEN',
  },
});

const { data, error } = await getAtsJobs({
  headers: {
    'X-Integration-Id': 'your-integration-id'
  },
  query: {
    statuses: 'OPEN,DRAFT',
    employment_types: 'FULL_TIME,PART_TIME',
    updated_after: '2024-01-01T00:00:00.000Z',
    name_contains: 'Developer'
  }
});
console.log('Integration Details:', data);
```

---

### API Reference

**TODO**
npm package: @roycenobles/cdk-constructs
Description: CDK Constructs for use in AWS projects.
Author: Royce Nobles
Latest version: 1.5.1

# cdk-constructs

CDK Constructs for use in my personal AWS projects.

## Installation

```bash
npm install @roycenobles/cdk-constructs
```

## Constructs

### Core (`@roycenobles/cdk-constructs/core`)

- **`StandardApp`** - Extended CDK App with built-in context and resource handling
- **`StandardStack`** - Extended CDK Stack with access to app-level context and resource handlers
- **`IAppScope`** - Interface providing access to context and resource handlers

### Context (`@roycenobles/cdk-constructs/context`)

- **`ContextHandler`** - Loads and manages application configuration from CDK context
- **`ResourceHandler`** - Generates standardized resource names with app and stage prefixes
- **`IConfiguration`** - Configuration interface for app name and environment settings
- **`IEnvironment`** - Environment interface for account, region, and stage

### Lambda (`@roycenobles/cdk-constructs/lambda`)

- **`StandardNodeFunction`** - Preconfigured Node.js Lambda function with:
  - Node.js 20.x runtime
  - ARM64 architecture
  - 1GB memory, 30s timeout
  - 1-week log retention
  - Minified bundles with external AWS SDK modules

### DynamoDB (`@roycenobles/cdk-constructs/dynamodb`)

- **`StandardDynamoTable`** - Preconfigured DynamoDB table with:
  - Pay-per-request billing
  - AWS-managed encryption
  - Contributor insights disabled
  - Auto-exported table ARN and name

### S3 (`@roycenobles/cdk-constructs/s3`)

- **`StandardBucket`** - Preconfigured S3 bucket with:
  - Bucket owner enforced ownership
  - All public access blocked
  - S3-managed encryption

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

**This software is provided for personal use without warranty of any kind.** Use at your own risk.
npm package: @roydukkey/eslint-config
Description: My strict configuration for eslint with TypeScript
Author: roydukkey
Latest version: 4.0.2

# ESLint Config

[![Release Version](https://img.shields.io/npm/v/@roydukkey/eslint-config.svg)](https://www.npmjs.com/package/@roydukkey/eslint-config)
[![License](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)

Use this if you like, but I'll probably make changes and might not accept any.

## Install

Install the packages:

```bash
pnpm add --save-dev \
@roydukkey/eslint-config \
@typescript-eslint/eslint-plugin \
@typescript-eslint/parser \
eslint
```

### Vue

Install the optional peer dependency for linting Vue files.

```sh
pnpm add --save-dev eslint-plugin-vue
```

## Configuration

Here is an example for configuring ESLint from the `package.json` and `eslint.config.js`.

```json
{
  "script": {
    "lint": "eslint './**/*.@(?(m|c)@(j|t)s|@(j|t)sx|vue)'",
    "lint:fix": "npm run lint -- --fix"
  }
}
```

```js
import { config } from 'typescript-eslint';
import roydukkeyConfig from '@roydukkey/eslint-config';

export default config(
  ...roydukkeyConfig({
    tsconfigRootDir: import.meta.dirname,
  }),
);

```

### TypeScript

By default, this package will _not_ use the `tsconfig.json` and instead only searches for `tsconfig.eslint.json` files. This provides better support for different monorepos.

Also, `@typescript-eslint/recommended-requiring-type-checking` is applied so don't forget to target the proper environments. For example, the following configuration targets Node:

```js
import { config } from 'typescript-eslint';
import globals from 'globals';

export default config(
  {
    languageOptions: {
      globals: {
        ...globals.node,
      },
    },
  },
);
```
npm package: @royjs/lite
Description: A lite state manager based on react hooks
Author: xing.gex
Latest version: 0.1.0

# RoyLite[Under Development] ![buildStatus](https://travis-ci.org/windyGex/royjs.svg?branch=master)

A lite state manager based on react hooks.

## Install

```shell
npm install @royjs/lite --save
```

## Usage

### Basic Usage

```js
import {Store, useStore, useDispatch} from '@royjs/lite';

const store = new Store({
    state: {
        count: 0
    },
    actions: {
        add(state, payload) {
            state.count++;
        },
        reduce(state, payload) {
            state.count--;
        }
    }
});

function App() {
    const count = useStore(state => state.count);
    const dispatch = useDispatch();
    return <div onClick={() => dispatch('add')}>{count}</div>
}

```

### Centralized Store

```js
import {Store, useStore, useDispatch} from '@royjs/lite';

const store = new Store({}, {
    plugins: [devtools]
});

store.create('module1', {
    state: {
        name: 'module1'
    },
    actions: {
        change(state, payload){
            state.name = payload;
        }
    }
});

store.create('module2', {
    state: {
        name: 'module2'
    },
    actions: {
        change(state, payload){
            state.name = payload;
        }
    }
});

function App() {
    const {name} = useStore(state => state.module1);
    const dispatch = useDispatch();
    const onClick = () => {
        dispatch('module2.change', 'changed name from module1');
    }
    return <div onClick={onClick}>{name}</div>
}

function App2() {
    const {name} = useStore(state => state.module2);
    return <div>{name}</div>
}
```