open-index/open-npm huggingface dataset:
npm package: @liteobject/demo-my-react-component-library
Description: A demo react component library
Author: Mohammed
Latest version: 0.0.5

# React Component

## Initialize project

    npm init -y

## Install dev dependencies

    npm i -D @types/node @types/react @types/react-dom react react-dom typescript source-map-loader

## Add TypeScript config

    npx tsc --init
npm package: @litepos/payment
Description: LitePOS payment gateway SDK - Core package
Latest version: 1.0.18

# @litepos/payment

LitePOS Payment Gateway SDK - Core package

## Overview

This is the core package of LitePOS payment gateway SDK. It provides unified interfaces and types for payment gateway integrations.

## Features

- Unified payment interface for multiple gateways
- Type-safe payment operations
- Configuration validation
- Built-in simulator for testing
- Extensible adapter system

## Installation

```bash
pnpm add @litepos/payment
```

## Usage

```typescript
import { LitePosPayment } from '@litepos/payment'

const payment = new LitePosPayment({
  // Configuration will be added when integrations are implemented
})

// Charge payment
const result = await payment.charge({
  method: 'fiuu-card',
  amount: 100,
  currency: 'MYR',
  orderId: 'ORDER-001'
})

// Query payment status
const status = await payment.queryPayment('fiuu-card', result.transactionId)
```

## Architecture

This package provides:
- Core interfaces (`IPaymentAdapter`)
- Type definitions (`PaymentRequest`, `PaymentResponse`, etc.)
- Simulator for testing
- Main client class (`LitePosPayment`) with built-in routing

Payment gateway specific implementations are provided by adapter packages (e.g., `@litepos/payment-fiuu`).

## Development

```bash
# 在当前包目录
pnpm build  # Build package
pnpm test   # Run tests

# 从根目录运行
pnpm test   # 测试所有包
```

## Status

Current version: 0.0.0 (Initial development)

The core package is ready. Payment gateway integrations will be added as separate adapter packages.
npm package: @litera-bp/bpcommon
Description: Made with create-react-library
Latest version: 1.4.24

# bpcommon

> Made with create-react-library

[![NPM](https://img.shields.io/npm/v/bpcommon.svg)](https://www.npmjs.com/package/bpcommon) [![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

## Install

```bash
npm install --save bpcommon
```

## Usage

```jsx
import React, { Component } from 'react'

import MyComponent from 'bpcommon'
import 'bpcommon/dist/index.css'

class Example extends Component {
  render() {
    return <MyComponent />
  }
}
```

## License

MIT © [](https://github.com/)
npm package: @literacyfanatic/eslint-config
Description: Reusable modular flat ESLint configuration package.
Latest version: 0.2.0

# @literacyfanatic/eslint-config

Reusable, flat ESLint configuration presets for TypeScript/JavaScript, React, Vitest, Playwright, package.json, import ordering, paths, stylistic rules, and spelling checks.

## Installation

Install this package and its peer dependencies into your project:

```bash
npm install --save-dev @literacyfanatic/eslint-config eslint typescript vitest
```

## Usage

Create an `eslint.config.mjs` in your project root and compose the presets you need.

### All-in-one config

```js
// eslint.config.mjs
import { defineConfig } from 'eslint/config';
import { all } from '@literacyfanatic/eslint-config';

export default defineConfig(all);
```

### Individual presets

You can import each preset separately and compose them yourself:

```js
import { defineConfig } from 'eslint/config';
import {
    base,
    typescript,
    react,
    vitestRules,
    playwrightRules,
    packageJsonRules,
    cspell,
    stylisticRules,
    importRules,
    pathsRules
} from '@literacyfanatic/eslint-config';

export default defineConfig([
    ...base,
    ...typescript,
    ...react,
    ...vitestRules,
    ...playwrightRules,
    ...packageJsonRules,
    ...cspell,
    ...stylisticRules,
    ...importRules,
    ...pathsRules
]);
```

## Development

Inside this repo:

```bash
# Install dependencies
npm install

# Build TypeScript to dist/
npm run build

# Run tests
npm test

# Lint this repo using the config itself
npm run lint
```

`prepublishOnly` runs the build, so `npm publish` will always publish a fresh `dist/`.
npm package: @literal-jsx/parser
Description: An example parser implementation for Literal JSX using nearley.js + moo
Author: Kelley van Evert
Latest version: 0.1.7

This is an example implementation of a Literal JSX parser, built with [nearley.js](https://nearley.js.org) + [moo](https://github.com/no-context/moo).

## Literal JSX

<p align="center">
  <img src="https://user-images.githubusercontent.com/43432/58766059-90999780-857a-11e9-91df-7a42baa79c38.png" height="140" />
</p>

**Literal JSX** is a lightweight format for interchanging content structures potentially rich in shape and data. It extends JSON by adding an "Element" node type, which is shaped as JSX, but which can only contain literal (JSON) data structures. For more information, see http://literal-jsx.org/.

## Usage

```js
import {
  // converts LJSX to an AST similar to Babel's output
  parseAST,

  // converts LJSX directly to a value
  // (you can optionally pass it a component hydration factory)
  parseValue,

  // create a moo lexer like the one used under the hood
  makeLexer,

  // the nearley.js generated grammar
  grammar,

  // for if you want to stream feed the nearley.js parser
  Parser
} from "literal-jsx";
```

_Note: line/col numbers come from moo, and are 1-based; offsets are 0-based._

Literal JSX is a conservative extension of JSON, so in particular, it will parse any JSON data structure.

```js
parseValue(`{ "normal": ["json", "data"] }`);
// { normal: ["json", "data"] }
```

Parse some typical JSX. By default, JSX elements are described by nodes of the shape `{ _JSXElement: true, name, attributes, children }`.

```js
parseValue(`<Button size="large" primary>Hi {"there"}</Button>`);
// { _JSXElement: true,
//   name: "Button",
//   attributes: { size: "large", primary: true },
//   children: ["Hi ", "there"] }
```

If you pass it a factory function (such as a simple wrapper around `React.createElement` that does a component lookup by name), it will use that factory function to hydrate the JSX. For example:

```js
const components = {
  Button,
  NavBar
};

const h = (name, attrs, ...children) =>
  React.createElement(components[name] || name, attrs, ...children);

parseValue(`<Button size="large" primary>Hi {"there"}</Button>`, h);
// React.createElement(Button, { size: "large", primary: true }, "Hi ", "there")
```