open-index/open-npm huggingface dataset:
npm package: @inlang/detect-json-formatting
Description: Detects the formatting of a JSON file and returns a function to serialize the JSON file in the same format.
Latest version: 1.0.0
Deprecated: no longer used

# @inlang/detect-json-formatting

Detects the formatting of a JSON file and returns a function to serialize the JSON file in the same format.

- useful to minimize git diffs and merge conflicts

## Usage

```ts
import { detectJsonFormatting } from '@inlang/detect-json-formatting'

const file = fs.readFileSync('./messages.json', 'utf-8')
const json = JSON.parse(file)
const stringify = detectJsonFormatting(file)
const serialized = stringify(json)

// serialized === file (same formatting)
```
npm package: @inlang/github-lint-action
Description: This action checks for translation issues within your PRs.
Latest version: 0.2.3
Deprecated: use the inlang sdk directly https://www.npmjs.com/package/@inlang/sdk

# 🥷 Ninja i18n - GitHub Lint Action

Automate your i18n workflow and ensure that your i18n files are always up to date with the latest changes in your source code.

#### Features

- Automated i18n linting for pull requests
- Detection of new broken inlang projects
- Comment creation with issue report
- Link creation to fix issues directly in [Fink localization editor](https://inlang.com/m/tdozzpar/app-inlang-finkLocalizationEditor)

## Setup

Make sure you have an inlang project set up in your repository. If you don't have one yet, you can create one [here](https://inlang.com/documentation/concept/project).

Add the following workflow file to your repository in this path `.github/workflows/ninja-i18n.yml`

```yml
name: Ninja i18n action

on:
  pull_request_target:

# explicitly configure permissions, in case your GITHUB_TOKEN workflow permissions are set to read-only in repository settings
permissions: 
  pull-requests: write

jobs:
  ninja-i18n:
    name: Ninja i18n - GitHub Lint Action
    runs-on: ubuntu-latest

    steps:
      - name: Checkout
        id: checkout
        uses: actions/checkout@v4

      - name: Run Ninja i18n
        id: ninja-i18n
        uses: opral/ninja-i18n-action@v0.2.3
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          
```

### Environmental Variables:

| Name                  | Requirement | Description |
| --------------------- | ----------- | ----------- |
| `GITHUB_TOKEN`        | _required_ | Usage: `GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}`,  Ninja i18n action uses this in-built GitHub token to make the API calls for interacting with GitHub. It is built into Github Actions and does not need to be manually specified in your secrets store. [More Info](https://help.github.com/en/actions/configuring-and-managing-workflows/authenticating-with-the-github_token)|

## Workflow

- When a pull request is opened or updated, the action will run and check for new i18n issues.
- If any issues are found, the action will create a comment on the pull request with a link to the Fink localization editor to fix the issues.
- After the issues are fixed, the action will automatically update the comment on the pull request to reflect the changes.
- If no issues are found, the action will simply not create any comments.
npm package: @inlang/json-types
Description: JSON types that are used across inlang's codebase (and hopefully useful to external developers as well!).
Latest version: 1.1.0
Deprecated: no longer used

JSON types that are used across inlang's codebase (and hopefully useful to external developers as well!).

### Usage

#### As type

Importing any JSONObject as `type` will prune runtime validation code.

```ts
import type { JSONObject } from "@inlang/json-types"

type MyType = JSONObject<{
	foo: string
	bar: number
}>
```

#### Validation

Every JSONObject is defined as [JSONSchema](https://json-schema.org/) with [typebox](https://github.com/sinclairzx81/typebox) and can be used for validation

```ts
import { JSONObject } from "@inlang/json-types"

const isValid = someJsonSchemaValidator(
	JSONObject({
		foo: string(),
		bar: number(),
	}),
)
```
npm package: @inlang/language-tag
Description: [BCP-47 language tags](https://en.wikipedia.org/wiki/IETF_language_tag) types and validators.
Latest version: 1.5.1
Deprecated: use the inlang sdk directly https://www.npmjs.com/package/@inlang/sdk


[BCP-47 language tags](https://en.wikipedia.org/wiki/IETF_language_tag) types and validators.

> Always bear in mind that the golden rule is to keep your language tag as short as possible. Only add further subtags to your language tag if they are needed to distinguish the language from something else in the context where your content is used.

## What is a language tag?

A language tag is a code that represents a language. It is used to identify the language of a text or other content. Language tags are defined by the [IETF](https://en.wikipedia.org/wiki/IETF_language_tag) in [BCP-47](https://www.rfc-editor.org/info/bcp47).

## Validation

Further information on choosing the language tag for your content can be found in the [W3C article on choosing language tags](https://www.w3.org/International/questions/qa-choosing-language-tags).

```js
/^(
  (?<grandfathered>
    (en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|i-klingon|i-lux|
    i-mingo|i-navajo|i-pwn|i-tao|i-tay|i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)|
    (art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang)
  )|
  (
    (?<language>
      ([A-Za-z]{2,3}(-(?<extlang>[A-Za-z]{3}(-[A-Za-z]{3}){0,2}))?)
      ([A-Za-z]{2,3}(-(?<extlang>[A-Za-z]{3}(-[A-Za-z]{3}){0,2}))?)|
      [A-Za-z]{4}|[A-Za-z]{5,8}
    )
    (-(?<script>[A-Za-z]{4}))?
    (-(?<region>[A-Za-z]{2}|[0-9]{3}))?
    (-(?<variant>[A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*
    (-(?<extension>[0-9A-WY-Za-wy-z](-[A-Za-z0-9]{2,8})+))*
    (-(?<privateUse>x(-[A-Za-z0-9]{1,8})+))?
  )
  |
  (?<privateUse>x(-[A-Za-z0-9]{1,8})+)
)$/;
```

## How to use

Use this library to validate language tags in your application.

You can import the types to validate language tags in your application:

```ts
import { LanguageTag } from "@inlang/language-tag"


myLanguageTag = exampleTag as LanguageTag
```

## Install

You can install the @inlang/cli with this command:

```sh
npm install @inlang/language-tag
```

or

```sh
yarn add @inlang/language-tag
```
npm package: @inlang/marketplace-manifest
Description: ```json { 	"$schema": "https://inlang.com/schema/marketplace-manifest", 	"id": "plugin.inlang.mFunctionMatcher", 	"icon": "./assets/m.png", 	"publisherName": "inlang", 	"publisherIcon": "https://inlang.com/favicon/safari-pinned-tab.svg", 	"license": "Apac
Latest version: 1.5.0

# Marketplace manifest

## Example

```json
{
	"$schema": "https://inlang.com/schema/marketplace-manifest",
	"id": "plugin.inlang.mFunctionMatcher",
	"icon": "./assets/m.png",
	"publisherName": "inlang",
	"publisherIcon": "https://inlang.com/favicon/safari-pinned-tab.svg",
	"license": "Apache-2.0",
	"displayName": {
		"en": "m-function-matcher"
	},
	"description": {
		"en": "Enables the inlang Visual Studio Code extension (Sherlock) to work with paraglide"
	},
	"pages": {
		"/": "./README.md",
		"/changelog": "./CHANGELOG.md"
	},
	"keywords": [
    "example"
	],
}
```