open-index/open-npm huggingface dataset:
npm package: @ste.martinek/stream-csv-parser
Description: Simple CSV parser made for coding challenge utilizing node steams
Author: Stepan Martinek
Latest version: 1.0.1

# Stream CSV Parser
 * Simple stream based CSV parses
 * Based on RFC 4180, with the exception that headers can also be escaped and TEXTDATA are not limited by sequences
 * Option to change escape sequence, rowBreak sequence, columnBreak sequence
 * Originally made as part of coding challenge for Morning Train
npm package: @ste7en/react-native-simple-shadow-view
Description: A native shadow view for react native, for Android and iOS
Author: Ste7en
Latest version: 1.0.0


# @ste7en/react-native-simple-shadow-view

## Getting started

`$ npm install @ste7en/react-native-simple-shadow-view --save`

### Mostly automatic installation

`$ react-native link @ste7en/react-native-simple-shadow-view`

### Manual installation


#### iOS

1. In XCode, in the project navigator, right click `Libraries` ➜ `Add Files to [your project's name]`
2. Go to `node_modules` ➜ `react-native-shadow` and add `RNShadow.xcodeproj`
3. In XCode, in the project navigator, select your project. Add `libRNShadow.a` to your project's `Build Phases` ➜ `Link Binary With Libraries`
4. Run your project (`Cmd+R`)<

#### Android

1. Open up `android/app/src/main/java/[...]/MainActivity.java`
  - Add `import com.como.RNTShadowView.ShadowViewPackage;` to the imports at the top of the file
  - Add `new ShadowViewPackage()` to the list returned by the `getPackages()` method
2. Append the following lines to `android/settings.gradle`:
  	```
  	include ':react-native-simple-shadow-view'
  	project(':react-native-simple-shadow-view').projectDir = new File(rootProject.projectDir, 	'../node_modules/@ste7en/react-native-simple-shadow-view/android')
  	```
3. Insert the following lines inside the dependencies block in `android/app/build.gradle`:
  	```
      implementation project(':react-native-simple-shadow-view')
  	```
4. Insert the following lines inside the defaultConfig block in `android/app/build.gradle`:
  	```
      renderscriptTargetApi 18
      renderscriptSupportModeEnabled true
  	```


## Usage

Set shadow parameters to the ShadowView just as you use shadows in iOS. it will appear on android same as on iOS.

```javascript
import React, { Component } from 'react';
import ShadowView from '@ste7en/react-native-simple-shadow-view'

class MyView extends Component {

	render() {
		return (
			<ShadowView
					style={{
						width: 100,
						height: 100,
						shadowColor: 'black',
						shadowOpacity: 1,
						shadowRadius: 20,
						shadowOffset: { width: 0, height: 0 },
						backgroundColor: 'rgba(0,255,0,0.5)',
					}}
				>
				... Texts / Views / etc ...
				</ShadowView>
			);
	}

export default MyView;
```
npm package: @ste_tisci/ecs
Description: A minimalistic game engine with zero dependencies based on the Entity Component System (ECS) architecture implemented in TypeScript
Latest version: 0.1.5

> [!IMPORTANT]  
> Work in progress.

# ECS in TypeScript

A minimalistic game engine with zero dependencies based on the **Entity Component System (ECS)** architecture implemented in **TypeScript**

## Features

- **ECS architecture** with single responsability principles (SRP)

- **SparSet** for ultra-fast entities lookup

- **Structure of Arrays(SoA)** for optimized memory storage and access

- **Bitmask** for efficient component queries

## Core Components

- **EntityManager**: Manage creation, destruction and entity recycle. Uses a bitmask to track components of every entity.

- **ComponentStore**: Generic store that maintains components data in SoA format to maximise cache locality.

- **ECS**: Central Orchestator that coordinates entity and components, expose an API for queries and CRUD operations

- **SparseSet**: Data structure that grants O(1) for insertion, removal and lookups of entities.

## Technologies

- TypeScript for type safety
- Data oriented architecture for optimal performance
- Functional pattern without classes

```typescript
import { ECS } from '@ste_tisci/ecs';

// Define the type of the components
const World = ECS<{
  Position: { x: number; y: number };
  Velocity: { x: number; y: number };
  Size: { width: number; height: number };
  Sprite: { src: HTMLImageElement };
}>();

// Define the structure of components that will be converted in SoA Arrays with the types previously defined
// Position = { x: number[], y: number[] }
// Size = { src: HTMLImageElement[] }
// etc.
World.defineComponents({
  Position: {},
  Size: {},
  Velocity: {},
  Sprite: {},
});

const ent = World.createEntity();

World.addComponent(ent, 'Position', { x: 100, y: 20 });
World.addComponent(ent, 'Velocity', { x: 2, y: 1 });
World.addComponent(ent, 'Size', { width: 20, height: 20 });

function movementSystem(World) {
  const { Position, Velocity } = World.components;

  for (const entity of World.query('Position', 'Velocity')) {
    const posID = entity.Position.id;
    const velID = entity.Velocity.id;

    Position.x[posID] += Velocity.x[velID];
    Position.y[posID] += Velocity.y[velID];
  }
}

function gameLoop() {
  movementSystem(World);
  requestAnimationFrame(gameLoop);
}

gameLoop();
```

## ⚖️ License

MIT © 2025 SteTisci