open-index/open-npm huggingface dataset:
npm package: @ranchhandrobotics/rde-common
Description: Common functionality for VSCode extensions
Author: Ranch Hand Robotics, LLC
Latest version: 1.0.0

# rde-common

Common functionality for VSCode extensions by Ranch Hand Robotics.

## Installation

```bash
npm install rde-common
```

## Features

This package provides common utilities for VSCode extensions:

- **Logger**: Structured logging with output channels
- **ConfigurationHelper**: Easy configuration management
- **CommandHelper**: Command registration and execution helpers

## Usage

### Logger

```typescript
import { Logger, LogLevel } from 'rde-common';

const logger = new Logger('My Extension', LogLevel.INFO);

logger.info('Extension activated');
logger.warn('Something might be wrong');
logger.error('An error occurred', error);
logger.debug('Debug information');

// Show the output channel
logger.show();
```

### ConfigurationHelper

```typescript
import { ConfigurationHelper } from 'rde-common';

const config = new ConfigurationHelper('myExtension');

// Get configuration values
const value = config.get<string>('someKey', 'defaultValue');

// Update configuration
await config.update('someKey', 'newValue');

// Watch for changes
const disposable = config.onDidChange((event) => {
  console.log('Configuration changed');
});
```

### CommandHelper

```typescript
import { CommandHelper } from 'rde-common';

const commandHelper = new CommandHelper();

// Register a command
commandHelper.registerCommand('myExtension.doSomething', () => {
  console.log('Command executed');
});

// Register a text editor command
commandHelper.registerTextEditorCommand('myExtension.transform', (editor, edit) => {
  // Modify the editor
});

// Execute a command
await commandHelper.executeCommand('workbench.action.files.save');
```

## Development

### Build

```bash
npm run build
```

### Test

```bash
npm test
```

### Watch Mode

```bash
npm run watch
```

## License

MIT License - Copyright (c) 2026 Ranch Hand Robotics, LLC
npm package: @ranchonyx/arraywindow
Description: Iterate over specifically sized array windows and potentially move them fwd or bkwd
Author: Felix Janetzki
Latest version: 1.0.1

# ArrayWindows

# Background
ArrayWindows is directly inspired by Rust's `std::slice::Windows`, for it provides similar functionality for Arrays in JavaScript and/or TypeScript.

# Warning
ArrayWindows adds a new method to the `Array.prototype`, namely `Array.prototype.windows`.

# Functionality
## Signature
`Array.prototype.windows<T>(winSz: number): ArrayWindowIterator<T>`

## Sample usage
```typescript
import "@ranchonyx/arraywindow";
const textArrayExample = "Hello, I am bored at work!".split("");

for(let window of textArrayExample.windows(3)) {
    console.log(window.content());
}
```
```
C:\Users\Bla\test> node test.js
[ 'H', 'e', 'l' ]
[ 'e', 'l', 'l' ]
[ 'l', 'l', 'o' ]
[ 'l', 'o', ' ' ]
[ 'o', ' ', 't' ]
[ ' ', 't', 'h' ]
[ 't', 'h', 'e' ]
[ 'h', 'e', 'r' ]
[ 'e', 'r', 'e' ]
[ 'r', 'e', '!' ]
```

# Reference
Each `ArrayWindow<T>` yielded by the `ArrayWindowIterator<T>` returned by `Array.prototype.windows()` exposes the following methods:

```typescript
isEmpty(): boolean;

first(): T;

last(): T;

swap(): void;

set(index: number, element: T): T;

get(index: number): T;
```

# Honest FYI
Since JavaScript doesn't pass arrays by reference, I had to cut some insane corners to emulate this behaviour, such as passing the topmost array's `this` object down to all slice objects and doing indexing magic.

It's messy, but it does work, you can edit the original array from inside a slice using the `get(index: number)` & `set(index: number, element: T)` Methods
npm package: @ranchonyx/ini-parser
Description: A simple, relatively lightweight ini parser
Author: Felix Janetzki
Latest version: 1.1.2

# INI-Parser

INI-Parser is a simplistic `ini` file format parser written in `typescript` for `node.js`.
I wrote this in my downtime at work to fend off boredom.
To use it, simply import it in your typescript files.

# Example

### Ini file
```ini
;Demo.ini
[details]
firstname=John
lastname=Doe
id=0123456789
alive=yes

[activity]
name=Reticulating splines
since=2023-08-02T14:54:11.840Z
```

### Typescript code
```typescript
//Demo.ts
import {INIParser} from "@ranchonyx/ini-parser"

const parser = INIParser.GetParser("./Demo.ini");

///Get the value of a key in a section as an INI entity.
parser.get("details", "firstname").asString();
///>>> John

///Get all keys for a section
parser.getKeysForSection("details");
///>>> [ 'firstname', 'lastname', 'id', 'alive' ]

///Get sections
parser.getSections();
///>>> [ 'details', 'activity' ]

///Convert to JSON
parser.asJSON();
/*>>>
{
  details: { firstname: 'john', lastname: 'doe', id: 123456789, alive: true },
  activity: { name: 'reticulating splines', since: 2023-08-02T14:54:11.840Z }
}
*/
```

# Documentation
### Types
```typescript
type nativeType = string | number | boolean | Date;
type maybe<T> = undefined | T;

type INIEntity = {
    getKey: () => string;
    asNumber: () => maybe<number>;
    asString: () => maybe<string>;
    asBoolean: () => maybe<boolean>;
    asDate: () => maybe<Date>;
    asGuessedNative: () => nativeType;
}

type INIBlock = Record<string, INIEntity | string> & { __ini_section_name__: string };

type INIParseResult = Record<string, INIBlock>;
```

### Signatures
```typescript
public static INIParser.GetParser(INIContentOrFilePath: string): INIParser;
public INIParser.get(sectionKey: string, key: string): INIEntity;
public INIParser.getKeysForSection(sectionKey: string): string[];
public INIParser.getSections(): string[];
public INIParser.asJSON(): any;
```

# Notes
### INIEntity
Please not that `INIEntity` describes a wrapper around the raw `string`-like value read from the ini.
You may interpret the raw value as
- string
- number
- boolean
- Date

by calling their respective `as`-methods.  
A way of implicitly getting a javascript native type is to calle the
`asGuessedNative()`-method, which will, with decent accuracy, convert the raw type to a javascript native type.

### JSON.stringify() support
Calling `JSON.stringify()` with an INIParser as argument, it will return the same data as `INIParser.asJSON()`.
npm package: @ranchuanjiang/antd-ms
Description: ​​@msxf/antd-ms 是基于 Ant Design 封装、专为中台应用定制的高质量 React 组件库，致力于提升中台项目的开发效率与一致性​​
Latest version: 0.0.1

# @msxf/antd-ms

马上云公共组件库，[文档地址](http://ui.msxf.msxfyun.test/)。