open-index/open-npm huggingface dataset:
npm package: @resreq/type-error-decorator
Description: TypeError Decorator for JavaScript & TypeScript
Author: molvqingtai
Latest version: 1.0.6

# type-error-decorator

[![version](https://img.shields.io/github/v/release/molvqingtai/type-error-decorator)](https://www.npmjs.com/package/@resreq/type-error-decorator) [![workflow](https://github.com/molvqingtai/type-error-decorator/actions/workflows/ci.yml/badge.svg)](https://github.com/molvqingtai/type-error-decorator/actions) [![download](https://img.shields.io/npm/dt/@resreq/type-error-decorator)](https://www.npmjs.com/package/@resreq/type-error-decorator) [![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

TypeError Decorator for JavaScript &amp; TypeScript

When we make a TypeScript-based library, the compiled .d.ts will only work for TypeScript users, and if we need to add type checking for Vanilla JS users as well, we need to write redundant type of judgements.

This project provides some decorators that make it easy to add type checking to class.

## Install

```shell
npm i @resreq/type-error-decorator
```

**or**

```shell
yarn add @resreq/type-error-decorator
```

## Documentation

### Get Started

Using decorators in class.

```js
import { TypeClass, TypeMethod, TypeParam } from '@resreq/type-error-decorator'

@TypeClass
class Http {
  options? = {}
  constructor(@TypeParam('Object',false) options?: any) {
    this.options = options
  }

  @TypeMethod
  get(@TypeParam('String') url: any, options?: any) {}

  @TypeMethod
  post(@TypeParam('String|URL') url: any, @TypeParam('Object') options: any) {}
}
```

Testing your class, with an incorrect parameter type, will throw a TypeError.

```js
new Http(1)
// TypeError: constructor arguments[0] must be Object
```

```js
const http = new Http()
http.get(1)
// TypeError: get arguments[0] must be String
```

```js
const http = new Http()
http.post(1, {})
// TypeError: post arguments[0] must be String or URL
```

```js
const http = new Http()
http.post(new URL('https://www.example.com/'))
// TypeError: post arguments[1] is required
```

The decorator uses [Symbol.toStringTag](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/toStringTag) internally to compare types, so you can use all the built-in constructor names (Upper Camel Case) to define types.

For example:

```js
@TypeParam('BigInt|RegExp|Symbol|Request|Response|...')
```

### Decorators

**TypeClass**

- **Arguments:** No

- **Usage:**

  The check constructor must have @TypeClass added to the class.

**TypeMethod**

- **Arguments:** No

- **Usage:**

  The check method must have @TypeMethod added to the method.

**TypeParam(type, required = true)**

- **Arguments:**

  - `{string} type`
  - `{Boolean?} required`

- **Usage:**

  Add @TypeParam to the parameters of the method to set the type of check.

## License

This project is licensed under the MIT License - see the [LICENSE](https://github.com/molvqingtai/type-error-decorator/blob/master/LICENSE) file for details
npm package: @ressjs/core
Description: Core utilities for ress.js
Author: ressjs team
Latest version: 0.3.0

# @ressjs/core

Core utilities and components for ress.js framework.

## Installation

```bash
npm install @ressjs/core
```

## Features

- **Page Generation**: Automatic page entry generation for SSR and client-side hydration
- **Platform Detection**: Support for mobile, desktop, and webview-specific builds
- **SSR Utilities**: Server-side rendering helpers and components
- **Asset Management**: Efficient handling of CSS and JavaScript assets

## Usage

### Basic Page Generation

```javascript
import { generateTempEntries, getClientEntriesInput } from '@ressjs/core';

// Generate temporary entry files for all pages
await generateTempEntries('dist');

// Get client entry configuration for Vite
const entries = await getClientEntriesInput('dist');
```

### Platform-Specific Builds

The core package automatically detects and generates platform-specific entries:

- `index.scss` - Base styles
- `index.mobile.scss` - Mobile-specific styles  
- `index.desktop.linux.scss` - Desktop Linux-specific styles

### SSR Components

```javascript
import { render } from '@ressjs/core';

// Server-side rendering with platform detection
const html = await render(Component, { platform: 'mobile' });
```

## API Reference

### Functions

#### `generateTempEntries(distPath?: string)`
Generates temporary entry files for all pages with platform-specific variants.

#### `getClientEntriesInput(distPath?: string)`
Returns Vite entry configuration object for client-side builds.

#### `render(component, options)`
Server-side rendering function with platform detection support.

## Platform Detection

The core package supports automatic platform detection based on user agent:

- **Mobile**: iOS Safari, Android Chrome, mobile browsers
- **Desktop**: Desktop browsers, electron apps
- **WebView**: Embedded webview contexts

## License

MIT - see [LICENSE](../../LICENSE) for details.

## Contributing

See the main [ress.js repository](https://github.com/gabrielspisso/ress.js) for contribution guidelines.
npm package: @ressjs/create-ress-app
Description: CLI tool for creating ress.js applications
Author: ress.js team
Latest version: 0.4.0

# @ressjs/create-ress-app

> CLI tool for creating ress.js applications

## Usage

### With npx (recommended)

```bash
npx @ressjs/create-ress-app my-app
```

### With npm

```bash
npm create @ressjs my-app
```

### Interactive Mode

Run without arguments for interactive mode:

```bash
npx @ressjs/create-ress-app
```

## Options

- `--template <template>` - Choose template: `basic` or `advanced` (default: `basic`)
- `--typescript` - Use TypeScript (default)
- `--javascript` - Use JavaScript instead of TypeScript
- `--skip-install` - Skip npm install

## Templates

### Basic Template

A simple ress.js application with:
- 🚀 Demo Pokédex component
- 📱 Mobile/desktop responsive styles
- 🎯 Single home page
- 📖 Comprehensive README

### Advanced Template

A full-featured ress.js application with:
- 🌍 Multiple pages (Weather, Pokédex, etc.)
- 🧩 Advanced components
- 🎨 Complex styling patterns
- 🛠️ Development tools

## Examples

```bash
# Create a basic TypeScript app
npx @ressjs/create-ress-app my-app

# Create an advanced JavaScript app
npx @ressjs/create-ress-app my-app --template advanced --javascript

# Skip dependency installation
npx @ressjs/create-ress-app my-app --skip-install
```

## What's Created

Your new ress.js app will include:

```
my-app/
├── app/
│   ├── pages/           # Auto-routed pages
│   ├── components/      # Reusable components
│   └── assets/         # Static assets
├── public/             # Public files
├── server.js          # Express server
├── vite.config.ts     # Vite configuration
└── package.json       # Dependencies
```

## Getting Started

After creating your app:

```bash
cd my-app
npm run dev
```

Your app will be available at `http://localhost:3000`.

## Learn More

- [React Documentation](https://react.dev)
- [Vite Documentation](https://vitejs.dev)
npm package: @ressjs/jora
Description: JoRA - A simple, offline task management tool
Author: gzzy
Latest version: 0.2.4

# JoRA 🎯

> **J**ust **o**ne **R**eally **A**wesome task manager - Because you don't need to pay for Jira

A simple, offline task management tool that works locally in any project without databases, servers, or subscriptions.

## 🚀 Quick Start

### Method 1: One-line install (coming soon)
```bash
curl -sSL https://raw.githubusercontent.com/your-user/JoRA/main/install.sh | bash
```

### Method 2: Manual download
1. Download the binary for your platform from [Releases](https://github.com/your-user/JoRA/releases)
   - `jora-linux` for Linux
   - `jora-mac` for macOS  
   - `jora-win.exe` for Windows
2. Put it in your project: `mkdir tools && mv jora-* tools/jora`
3. Initialize and run:

```bash
# Initialize JoRA in your project
./tools/jora init

# Start the web interface (opens at http://localhost:3333)
./tools/jora
```

### Method 3: Run from source
```bash
git clone https://github.com/your-user/JoRA.git
cd JoRA
npm install
npm start
```

## 📁 What JoRA creates in your project

```
your-project/
├── cl-todo/
│   ├── config.json         # Project config
│   ├── authors.json        # Team members
│   ├── tags.json          # Available tags
│   ├── epics/             # Epic definitions
│   │   └── frontend.json
│   ├── tasks/             # Individual tasks
│   │   └── task-abc123.json
│   ├── releases/          # Released versions
│   │   └── v1.0.0.json
│   └── current.json       # Current state index
```

## 🎯 Features

- **📋 Kanban Board**: Simple todo → in_progress → ready_to_release workflow
- **📦 Offline**: No internet, no database, no server required
- **🔄 Version Control Friendly**: All data in JSON files that git can track
- **🏷️ Organization**: Tags, epics, subtasks, priorities
- **🚀 Release Management**: Generate releases and clean up completed tasks
- **💻 Multiplataform**: Single binary for Windows, Linux, macOS
- **🌐 Web UI**: Clean interface accessible in your browser

## 📋 Task States

- `todo` - New tasks
- `in_progress` - Currently being worked on  
- `ready_to_release` - Completed and ready for next release

## 🎪 Commands

```bash
jora init          # Initialize JoRA in current directory
jora              # Start web interface (default: http://localhost:3333)
jora --port 8080  # Start on custom port
jora version      # Show version
jora help         # Show help
```

## 🔧 Building from source

```bash
npm install
npm run build     # Builds for all platforms
```

Binaries will be in `dist/` folder.

## 📝 Why JoRA?

- **No vendor lock-in**: Your data is yours, in simple JSON files
- **No subscriptions**: Download once, use forever
- **No complexity**: Just tasks, states, and releases
- **Git-friendly**: Everything can be version controlled
- **Universal**: Works with any programming language or project type

## 🤝 Contributing

PRs welcome! This is meant to be simple and focused.

## 📄 License

MIT - Do whatever you want with it

---

*Made with ❤️ for developers who just want to track tasks without the enterprise bloat*
npm package: @rest-api-codegen/react-query
Description: REST API Code Generator For React-Query
Author: Michael
Latest version: 0.0.3

# REST API Code Generator For React-Query
Based on OpenAPI

## Installation

```bash
// npm
npm install @rest-api-codegen/react-query --save-dev

// yarn
yarn add @rest-api-codegen/react-query -D

// pnpm
pnpm add @rest-api-codegen/react-query -D
```

## Configuration

### Schema directory
command options: `-schema-directory` `-s`

Generator will automatically scan all json files in schema directory.

### Fetcher
command options: `-fetcher` `-f`

Customize the fetcher you wish to use in the generated file. React-Query is agnostic to the data-fetching layer, so you should provide it, or use a custom one.

The following options are available to use:

- `file#identifier` You can use custom fetcher method that should implement the exported ReactQueryFetcher interface. Example: `./fetcher#apiFetcher`.

```ts
interface FetcherOptions {
  url: string
  method: string
  query?: Record<string, unknown>
  body?: Record<string, unknown> | Record<string, unknown>[]
}

export async function apiFetcher<T = any>(options: FetcherOptions) {
  const response = await fetch(options.url, {method: options.method})
  const result = await response.json()
  return result as T
}
```

### Output directory
command options: `-output-directory` `-o`

For generated files.

Naming like `{schema directory}/sample.json` -> `{output directory}/sample.generated.ts`

## Quick Start

```bash
pnpm add @rest-api-codegen/react-query -D
pnpm add @tanstack/react-query

```

Create fetcher, [content like here](#fetcher)

```bash
npx @rest-api-codegen/react-query -s ./src/samples -o ./src/samples/generated -f ./utils/fetcher#apiFetcher
```

```tsx
import {
  QueryClient,
  QueryClientProvider,
} from '@tanstack/react-query'
import { useGetUsersQuery, useCreateUserMutation } from './samples/sample.generated.ts'

const queryClient = new QueryClient()

function App() {
  return (
    // Provide the client to your App
    <QueryClientProvider client={queryClient}>
      <Users />
    </QueryClientProvider>
  )
}

function Users() {
  // Queries
  const { data } = useGetUsersQuery({ query: { limit: 20, offset: 0 } })

  // Mutations
  const mutation = useCreateUserMutation()

  return (
    <div>
      <ul>{data.users?.map((user) => <li key={user.id}>{user.name}</li>)}</ul>

      <button
        onClick={() => {
          mutation.mutate({
            name: 'Do Laundry',
          })
        }}
      >
        Add User
      </button>
    </div>
  )
}
```
npm package: @rest-api-codegen/vue-query
Description: REST API Code Generator For Vue Query
Author: Michael
Latest version: 0.0.3

# REST API Code Generator For Vue Query
Based on OpenAPI

## Installation

```bash
// npm
npm install @rest-api-codegen/vue-query --save-dev

// yarn
yarn add @rest-api-codegen/vue-query -D

// pnpm
pnpm add @rest-api-codegen/vue-query -D
```

## Configuration

### Schema directory
command options: `-schema-directory` `-s`

Generator will automatically scan all json files in schema directory.

### Fetcher
command options: `-fetcher` `-f`

Customize the fetcher you wish to use in the generated file. React-Query is agnostic to the data-fetching layer, so you should provide it, or use a custom one.

The following options are available to use:

- `file#identifier` You can use custom fetcher method that should implement the exported ReactQueryFetcher interface. Example: `./fetcher#apiFetcher`.

```ts
interface FetcherOptions {
  url: string
  method: string
  query?: Record<string, unknown>
  body?: Record<string, unknown> | Record<string, unknown>[]
}

export async function apiFetcher<T = any>(options: FetcherOptions) {
  const response = await fetch(options.url, {method: options.method})
  const result = await response.json()
  return result as T
}
```

### Output directory
command options: `-output-directory` `-o`

For generated files.

Naming like `{schema directory}/sample.json` -> `{output directory}/sample.generated.ts`

## Quick Start

```bash
pnpm add @rest-api-codegen/vue-query -D
pnpm add @tanstack/vue-query

```

Create fetcher, [content like here](#fetcher)

```bash
npx @rest-api-codegen/vue-query -s ./src/samples -o ./src/samples/generated -f ./utils/fetcher#apiFetcher
```

```vue
<script setup>
  import { useQueryClient } from '@tanstack/vue-query'
  import { useGetUsersQuery, useCreateUserMutation } from './samples/sample.generated.ts'

  const queryClient = useQueryClient()

  // Queries
  const { data, isPending, isError, error } = useGetUsersQuery({ query: { limit: 20, offset: 0 } })

  // Mutations
  const mutation = useCreateUserMutation({
    onSuccess: () => {
    },
  })
  function onButtonClick() {
    mutation.mutate({
      id: Date.now(),
      title: 'Do Laundry',
    })
  }
</script>

<template>
  <span v-if="isPending">Loading...</span>
  <span v-else-if="isError">Error: {{ error.message }}</span>
  <!-- We can assume by this point that `isSuccess === true` -->
  <ul v-else>
    <li v-for="user in data.users" :key="user.id">{{ user.name }}</li>
  </ul>
  <button @click="onButtonClick">Add User</button>
</template>
```