open-index/open-npm huggingface dataset:
npm package: @manuth/caller-module
Description: Provides information about the caller of a method and its module
Author: Manuel Thalmann
Latest version: 2.0.1

# CallerModule
Provides information about the caller of a method and its module

[![status-badge](https://bergwache.nuth.ch/api/badges/lordgizmo/CallerModule/status.svg)](https://bergwache.nuth.ch/repos/lordgizmo/CallerModule)

This module provides the ability to determine what module performed the most recent function call. It additionally provides information about the module such as:

- Its name
- Its root-path
- The path to the file that performed the function call
- The CallSite-object of the function call ([More about the CallSite class...](https://v8.dev/docs/stack-trace-api#customizing-stack-traces))

## Installation
You can install this package using npm:
```bash
npm install --save @manuth/caller-module
```

## Usage
TypeScript-example:
```ts
import { GetCallerModule } from "@manuth/caller-module";

console.log(GetCallerModule().name); // Logs the name of your module. 
```

```js
const { GetCallerModule } = require("@manuth/caller-module");
console.log(GetCallerModule().name);
```

### Documentation
`GetCallerModule([method: function], [level: number])`
 - `method`:  
   The method whose caller is to be determined.  
   Defaults to the GetCallerModule-method.
 - `level`:
   The number of levels above the `method` whose caller is to be determined.

### Example
```ts
import { GetCallerModule } from "@manuth/caller-module";

function test
{
    test1();
}

function test1()
{
    test2();
}

function test2()
{
    last();
}

function last()
{
    console.log(GetCallerModule().name); // Your module's name.
    console.log(GetCallerModule().callSite.getFunctionName()); // last
    console.log(GetCallerModule(2).callSite.getFunctionName()); // test2
    console.log(GetCallerModule(last).callSite.getFunctionName()); // test2
    console.log(GetCallerModule(last, 2).callSite.getFunctionName()); // test1
}
```
npm package: @manuth/culture-info
Description: A node-package for representing locales
Author: Manuel Thalmann
Latest version: 3.0.1

# CultureInfo.js
A node-package for representing locales

[![status-badge](https://bergwache.nuth.ch/api/badges/lordgizmo/CultureInfo.js/status.svg)](https://bergwache.nuth.ch/repos/lordgizmo/CultureInfo.js)

## General
This package allows you to easily represent locales and determining the next lesser-specific parent of a locale (`en-US` => `en`).

This key feature might be usable for creating a resource-manager or showing web-content based on a language-tag consisting of the language, the script and the region.

## Creating a `CultureInfo` instance
You can create a `CultureInfo` instance by passing a language-tag to its constructor:

```ts
import { CultureInfo } from "@manuth/culture-info";

let culture = new CultureInfo("en-US");
```

Following kinds of language-tags are supported:
  - Language  
    Example: `en`
  - Language and region  
    Example: `en-US`
  - Language, script and region  
    Example: `zh-Hans-CN`

## Features
### Automated Casing
The casing is automatically adjusted allowing you to pass the language-tag even with incorrect letter-casing:

```ts
console.log(new CultureInfo("EN-US").Name); // Logs `"en-US"`
console.log(new CultureInfo("zH-hANs-cN").Name); // Logs `"zh-Hans-CN"`
```

Checking whether a culture only consists of a language:
```ts
console.log(new CultureInfo("en").IsNeutralCulture); // Logs `true`
console.log(new CultureInfo("en-US").IsNeutralCulture); // Logs `false`
```

### Walking up the Locale-Graph
You might want to find out the next lesser specific locale of a specific language-tag.
This can be achieved using the `Parent`-property:

```ts
let culture = new CultureInfo("en-US");
console.log(culture.Name); // Logs `"en-US"`
culture = culture.Parent;
console.log(culture.Name); // Logs `"en"`
culture = culture.Parent;
console.log(culture.Name); // Logs `""` - That's the invariant culture
```

### String Conversion
When converting a `CultureInfo` to a string it's automatically converted to the language-tag:

```ts
console.log(`${new CultureInfo("en-US")}`); // Logs `"en-US"`
```
npm package: @manuth/eslint-plugin-typescript
Description: A set of personal eslint-rulesets for TypeScript-projects
Author: Manuel Thalmann
Latest version: 5.0.3

# ESLintPresets
[![status-badge](https://bergwache.nuth.ch/api/badges/lordgizmo/ESLintPresets/status.svg)](https://bergwache.nuth.ch/lordgizmo/ESLintPresets)

A set of personal eslint-rulesets for TypeScript-projects

## Usage
### Flat Config Interface
Import `flatConfigs` from this module and use the desired configurations:

***eslint.config.js:***
```js
import { flatConfigs } from "@manuth/eslint-plugin-typescript";

export default [
    ...flatConfigs.recommendedWithTypeChecking
]
```

Following configurations are available:
  - `weak`:  
    Lightweight configurations which prevent common issues from happening
  - `weakWithTypeChecking`:  
    The `weak` configuration including rules which require type checking
  - `recommended`:  
    An opinionated default configuration
  - `recommendedWithTypeChecking`:  
    The `recommended` configuration including rules which require type checking

### eslintrc (Legacy) Config Interface
Add the desired presets to the `extends`-list of your configuration:

***.eslintrc.cjs:***
```js
module.exports = {
    extends = [
        "plugins:@manuth/typescript/recommended-requiring-type-checking"
    ];
};
```

Following configurations are available:
  - `weak`:  
    Lightweight configurations which prevent common issues from happening
  - `weak-requiring-type-checking`:  
    The `weak` configuration including rules which require type checking
  - `recommended`:  
    An opinionated default configuration
  - `recommended-requiring-type-checking`:  
    The `recommended` configuration including rules which require type checking
npm package: @manuth/exceptions
Description: Provides lightweight versions of the most important exceptions from Microsoft's .NET
Author: Manuel Thalmann
Latest version: 2.0.1

# NetExceptions.js
Provides lightweight versions of the most important exceptions from Microsoft's .NET

[![status-badge](https://bergwache.nuth.ch/api/badges/lordgizmo/NetExceptions.js/status.svg)](https://bergwache.nuth.ch/repos/lordgizmo/NetExceptions.js)
npm package: @manuth/generator-my-ts-project
Description: Generates TypeScript-Projects with custom additions
Author: Manuel Thalmann
Latest version: 5.0.1

# MyTSProjectGenerator
A Set of Generators for Creating Projects Written in TypeScript with custom additions

[![status-badge](https://bergwache.nuth.ch/api/badges/lordgizmo/TSProjectGenerator/status.svg)](https://bergwache.nuth.ch/lordgizmo/TSProjectGenerator)

## General
The generators in this packages are based on the [`@manuth/generator-ts-project`][TSProjectGenerator] package.  
In addition to the output of these generators, the code-style of all `.md` files will be refactored automatically and a Drone configuration will be created for continuous integration.

## Usage
### Install MyTSProjectGenerator
You can install `MyTSProjectGenerator` using the following command:

```bash
npm install -g yo @manuth/generator-my-ts-project
```

### Generate a Generator Written in TypeScript
You can create a generator written in TypeScript using this command:

```bash
yo @manuth/my-ts-project
```

It is recommended to use a code-editor which provides TypeScript-support (like, for example [VSCode] or [Atom]).

## Generator Output
  - A basic folder-structure for keeping `TypeScript`-code and `JavaScript`-builds separate
  - Linting-rules (optional)
    - Either weak rules…
    - …or strong rules
  - A node-package with required dependencies
  - Mocha test-environment
  - NPM-Scripts for…
    - Compiling the TypeScript-code
    - Cleaning compiled TypeScript-code
    - Linting the package
    - Testing the package
 - Drone-configuration
 - Visual Studio Code workspace _(optional)_
    - Settings
    - Task for building the generator (by pressing <kbd>CTRL</kbd>, <kbd>SHIFT</kbd> + <kbd>B</kbd>)
    - Task for linting the generator
    - Debug-settings

When generating a module you'll additionally get:
  - An empty `index` script

When generating a generator you'll get following in addition:
  - An `EJS`-extension for [VSCode]
  - An example-generator including template-files
  - As many sub-generators as you bother to create

<!--- References -->
[VSCode]: https://code.visualstudio.com/
[Atom]: https://atom.io/
[TSProjectGenerator]: https://codeberg.org/lordgizmo/TSProjectGenerator/tree/main/packages/generator-ts-project
npm package: @manuth/generator-ts-project
Description: A Set of Generators for Creating Projects Written in TypeScript
Author: Manuel Thalmann
Latest version: 5.0.1

# TSProjectGenerator
A Set of Generators for Creating Projects Written in TypeScript

[![status-badge](https://bergwache.nuth.ch/api/badges/lordgizmo/TSProjectGenerator/status.svg)](https://bergwache.nuth.ch/lordgizmo/TSProjectGenerator)

## Usage
### Install TSProjectGenerator
You can install `TSProjectGenerator` using the following command:

```bash
npm install -g yo @manuth/generator-ts-project
```

### Generate a Generator Written in TypeScript
You can create a generator written in TypeScript using this command:

```bash
yo @manuth/ts-project
```

It is recommended to use a code-editor which provides TypeScript-support (like, for example [VSCode] or [Atom]).

## Generator Output
  - A basic folder-structure for keeping `TypeScript`-code and `JavaScript`-builds separate
  - Linting-rules _(optional)_
    - Either weak rules…
    - …or strong rules
  - A node-package with required dependencies
  - Mocha test-environment
  - NPM-Scripts for…
    - Compiling the TypeScript-code
    - Cleaning compiled TypeScript-code
    - Linting the package
    - Testing the package
 - Visual Studio Code workspace _(optional)_
    - Settings
    - Task for building the generator (by pressing <kbd>CTRL</kbd>, <kbd>SHIFT</kbd> + <kbd>B</kbd>)
    - Task for linting the generator
    - Debug-settings

When generating a module you'll additionally get:
  - An empty `index` script

When generating a generator you'll get following in addition:
  - An `EJS`-extension for [VSCode]
  - An example-generator including template-files
  - As many sub-generators as you bother to create

<!--- References -->
[VSCode]: https://code.visualstudio.com/
[Atom]: https://atom.io/
npm package: @manuth/generator-wsc-package
Description: A Generator for WoltLab Suite Core Packages.
Author: Manuel Thalmann
Latest version: 4.0.1

# WSCPackageGenerator
A Generator for WoltLab Suite Core Packages.

## Usage
### Installing `WSCPackageGenerator`
You can install `WSCPackageGenerator` using following command:

```bash
npm install -g yo @manuth/generator-wsc-package
```

### Using the Generator
You can run the generator by invoking this command on a command prompt:

```bash
yo @manuth/wsc-package
```

## Generator Output
  - WoltLab Suite Core Package
    - Meta-Data written in TypeScript
    - Components written in TypeScript (optional)
  - NPM-scripts for...
    - Compiling the Package-Metadata
    - Compiling the Package-Metadata in Watched Mode
    - Building the Package-File (`.tar`-archive)
  - Visual Studio Code-Environment (optional)
npm package: @manuth/temp-files
Description: Provides the functionality to handle temporary files and directories the object-oriented way.
Author: Manuel Thalmann
Latest version: 3.0.3

# TempFiles
Provides the functionality to handle temporary files and directories the object-oriented way.

[![status-badge](https://bergwache.nuth.ch/api/badges/lordgizmo/TempFiles/status.svg)](https://bergwache.nuth.ch/repos/lordgizmo/TempFiles)

## Installing TempFiles
`TempFiles` can be installed using the `npm`-cli:

```bash
npm install --save @manuth/temp-files
```

## Using TempFiles
You can create temporary filesystem-entries by initializing new instances of the `TempFile`- or the `TempDirectory`-class.  
Temporary filesystem-entries easily can be removed by invoking `TempFileSystem.Dispose()`.

When working with a `TempDirectory` you can use `TempDirectory.MakePath(...string[])` to create paths relative to the directory.

### Example
```ts
import fs = require("fs");
import { TempDirectory, TempFile } from "@manuth/temp-files";

let tempDir = new TempDirectory();
let tempFile = new TempFile(
    {
        postfix: ".json"
    });

let fileName = tempDir.MakePath("this", "is", "a", "test.txt");
fs.writeFileSync(fileName, "Hello World");
fs.writeFileSync(tempFile.FullName, '{ "Message": "Hello World" }');

tempFile.Dispose();
tempDir.Dispose();
```
npm package: @manuth/tsconfig
Description: Provides recommended settings for TypeScript
Author: Manuel Thalmann
Latest version: 4.0.2

# TypeScriptRecommendations
Provides recommended settings for TypeScript

[![status-badge](https://ci.nuth.ch/api/badges/manuth/TypeScriptRecommendations/status.svg)](https://ci.nuth.ch/manuth/TypeScriptRecommendations)

## Usage
Simply inherit the settings provided by this module by setting the `extends`-options of the `tsconfig.json`-file:
```json
{
    "extends": "@manuth/tsconfig/recommended",
    "compileOnSave": true,
    "compilerOptions": {
        "rootDir": "./src",
        "module": "commonjs",
        "lib": [
            "es7"
        ],
        "target": "es6",
        "outDir": "./lib"
    }
}
```

By setting this option your tsconfig-file will inherit the `recommended.json`-settings located in the `@manuth/tsconfig`-module.

### Configurations
Currently `TypeScriptRecommendations` provides following configuration-presets:
  - `@manuth/tsconfig/recommended`:  
    manuth's recommended settings
npm package: @manuth/tslint-presets
Description: A set of personal linting-rulesets for TypeScript
Author: Manuel Thalmann
Latest version: 1.0.5

# THIS PACKAGE IS DEPRECATED
As it is recommended to move from `tslint` to `eslint`, this package is now deprecated.  
You might want to move on to using `eslint` and install use the presets of the [`@manuth/eslint-plugin-typescript` package](https://github.com/manuth/ESLintPresets.git).

# TSLintPresets
A set of personal linting-rulesets for TypeScript

## Usage
The provided linting-presets can be used by setting the `extends`-option of the `tslint.json`-file:  
***tslint.json:***
```json
{
    "extends": "@manuth/tslint-presets/recommended"
}
```

By setting this option your `tslint.json`-file will inherit the `recommended`-file located in the `@manuth/tsconfig`-module.

## Presets
Following presets are available in this module:
  * `@manuth/tslint-presets`:  
    The short form of `@manuth/tslint-presets/recommended`
  * `@manuth/tslint-presets/recommended`:
    manuth's recommended settings
  * `@manuth/tslint-presets/weak`:  
    manuth's weak settings
npm package: @manuth/typescript-eslint-plugin
Description: A plugin for TypeScript which provides eslint-reports to your IDE.
Author: Manuel Thalmann
Latest version: 1.4.2
Deprecated: This package is deprcated. This package currently doesn't work as ESLint v8 is asynchronous while TypeScript Language Services must be written synchronously.

# TypeScriptESLintPlugin
A plugin for TypeScript which provides eslint-reports to your IDE.

## Getting Started
First you need to have `eslint` installed.
You can install it by invoking this command:
```sh
npm install -D eslint
```

Next go ahead and install this plugin:
```
npm install -D @manuth/typescript-eslint-plugin
```

As a last step open up your project's `tsconfig.json`-file and add this plugin to the settings:
```json
{
    "compilerOptions": {
        "plugins": [
            {
                "name": "@manuth/typescript-eslint-plugin",
                "configFile": "./my.eslintrc.js"
            }
        ]
    }
}
```

## Configuration
You might want to change the behaviour of this plugin to your likings.
Following settings are supported:

  * `ignoreJavaScript`:  
    Allows you to disable eslint-reports in JavaScript files (default is `false`)
  * `ignoreTypeScript`:  
    Allows you to disable eslint-reports in TypeScript files (default is `false`)
  * `allowInlineConfig`:  
    Allows you to disable eslint configuration-comments (default is `true`)
  * `reportUnusedDisableDirectives`:  
    Use this setting to disable errors when useless `eslint-disable-next-line`-comments are reported (default is `true`).
  * `useEslintrc`:  
    You can disable the processing of `.eslintrc.*`-files by setting this to `false` (default is `true`)
  * `configFile`:  
    Allows you to specify a custom config-file to use (default is `undefined`)
  * `alwaysShowRuleFailuresAsWarnings`:  
    By setting this to `true` all rule-failures, regardless whether you set `warn` or `error` are represented as warnings (default is `false`)
  * `suppressWhileTypeErrorsPresent`:  
    Allows you to disable `eslint` while there are other errors present (default is `false`)
  * `suppressDeprecationWarnings`:  
    Usually this plugin reports warnings when deprecated rules are in use. Use this setting to disable this feature. (default is `false`)
  * `suppressConfigNotFoundError`:  
    By setting this option to `true` you can enable errors if no eslint-configuration could be found (default `true`)
  * `packageManager`:  
    Set this option either to `npm`, `pnpm` or `yarn` to load global modules correctly and get proper commands in error messages. (default is `npm`)
  * `logLevel`:  
    Allows you to set the verbosity of this plugin in the `TS Server log` either to `none`, `normal` or `verbose`. (default is `none`)

### Note
When updating the configuration of the plugin using a `ConfigurePluginRequest`, the settings made in `tsconfig.json` will persist, as `tsconfig.json`-settings have a higher priority than the dynamic settings sent using a `ConfigurePluginRequest`.  
Please let me know if this is not the behaviour you'd expect.