open-index/open-npm huggingface dataset:
npm package: @servicetitan/ld-type-generator
Description: CLI for generating TypeScript types for LaunchDarkly feature flags
Author: Fleet Pro Frontend team
Latest version: 0.2.0

CLI for generating TypeScript types for LaunchDarkly feature flags.

## Usage

```
Usage
  $ npx @servicetitan/ld-type-generator [options]

Options
  --apiKey                    LaunchDarkly API key (required)
  --projectKey                LaunchDarkly project key (required)
  --sdkAvailability, --sdk    SDK availability, available values: client, mobile, anyClient, server (default: client)
  --state                     State, available values: live, deprecated, archived (default: live)
  --camelCase                 Convert flag keys to camelCase (default: true)

Examples
  $ npx @servicetitan/ld-type-generator --apiKey=your-api-key --projectKey=your-project-key
  $ npx @servicetitan/ld-type-generator --apiKey=your-api-key --projectKey=your-project-key --sdkAvailability=server
  $ npx @servicetitan/ld-type-generator --apiKey=your-api-key --projectKey=your-project-key --sdk=server
  $ npx @servicetitan/ld-type-generator --apiKey=your-api-key --projectKey=your-project-key --state=archived
  $ npx @servicetitan/ld-type-generator --apiKey=your-api-key --projectKey=your-project-key --sdk=server --state=archived
  $ npx @servicetitan/ld-type-generator --apiKey=your-api-key --projectKey=your-project-key --camelCase=false
```

## Getting an API key

1. Navigate to https://app.launchdarkly.com/settings/authorization.
1. Click on the "Create token".
1. In the popup fill required fields. Set "This is a service token" checkbox and click "Save token".
1. The generated token will be passed as --apiKey of this CLI tool.

## Getting the project key

1. Navigate to https://app.launchdarkly.com/settings/projects.
1. Click on the copy button under the names of your project.
1. That's the project key value (--projectKey CLI argument).
npm package: @servicetitan/startup
Description: CLI to create multi-package Lerna projects with TypeScript and React
Latest version: 36.0.0

# @servicetitan/startup

## Run Locally

### Initial Setup

1. Globally install the `yalc` package

```
$ npm i yalc -g
```

2. Build the `uikit` packages

```
$ cd <path-to-uikit>
$ npm run build
```

3. Run `yalc publish` in the `startup` package folder

```
$ cd .\packages\startup\
$ yalc publish
```

4. Run `yalc add @servicetitan/startup` in your dependent project, which will use the current version of the startup package

```
$ cd <path-to-your-project>
$ yalc add @servicetitan/startup
```

5. Update your dependencies

```
$ npm run bootstrap
```

### Fetch Changes

1. Build the `uikit` packages

```
$ cd <path-to-uikit>
$ npm run build
```

2. Run `yalc push` in the `startup` package folder

```
$ cd .\packages\startup\
$ yalc push
```

3. Update your dependencies

```
$ cd <path-to-your-project>
$ npm run bootstrap
```
npm package: @servicetitan/startup-mfe-compat
Description: This CLI verifies that light bundles of given MFEs (microfrontends) will be loaded given host applications by analyzing package.json dependencies.
Latest version: 0.3.0

This CLI verifies that light bundles of given MFEs (microfrontends) will be loaded given host applications by analyzing package.json dependencies.

## Usage

```
Usage
  $ npx @servicetitan/startup-mfe-compat check [options]

Options
  --hostPackageJson             host application package.json path (required)
  --packageJson                 MFE package.json path (required)

Output
  Success: process exits with status 0
  Failure: process exits with status 1, error messages are logged

Examples
  $ npx @servicetitan/startup-mfe-compat check --hostPackageJson=<host-package-json-path> --packageJson=<mfe-package-json-path>
  $ npx @servicetitan/startup-mfe-compat check --hostPackageJson=<host1-package-json-path> --hostPackageJson=<host2-package-json-path> --packageJson=<mfe1-package-json-path> --packageJson=<mfe2-package-json-path> # host package.json files are merged from left to right: host1, host2, ...
```
npm package: @servicetitan/tokens
Description: ## Usage for Android (Kotlin)
Latest version: 12.9.0

# Design Tokens for Anvil Design System

## Usage for Android (Kotlin)

### Steps
1. Copy the `AnvilColorToken.kt` and `AnvilThemeToken.kt` from `build/kotlin/{theme}` folder
2. Adjust the package in each file to match your file structure as necessary

### Files
- `AnvilColorToken.kt` contains base colors.
- `AnvilThemeToken.kt` contains color pairings for the light and the dark mode.

### Example of using the themed color
```Kotlin
AnvilThemeToken.AppBackground.forTheme()
```

### Example of using the base color
```Kotlin
AnvilColorToken.Neutral10
```

## Usage for iOS (Swift)

### Add as dependencies
To include this package, add to your `Package.swift`:
```Swift
dependencies: [
    .package(
        url: "https://github.com/servicetitan/tokens.git",
        from: "12.0.0"
    )
]
```

### Example of using the base color
```Swift
import AnvilCore

Text("Hello World")
.foregroundColor(.anvil(.neutral10))
```

## Usage for Web

### Installation using npm

```shell
$ npm i @servicetitan/tokens
```

### JavaScript/TypeScript

```ts
import { core } from "@servicetitan/tokens";
```

```ts
import { light, dark, tokens } from "@servicetitan/tokens/core";
```

### Less

```less
@import (reference) '@servicetitan/tokens/core/tokens.less';
```

### CSS Variables

```css
@import '@servicetitan/tokens/core/tokens.css';
```

.

# How to Contribute

All of the design tokens and assets for Anvil are in this package. It generates assets for iOS (Swift), Android (Kotlin), and web.

To get started, run:
```
$ npm install
$ npm run build
```

The `npm run build` command runs style-dictionary build steps to generate the files for each platform. Every time you change something in the style dictionary, such as changing a color value or adding a new design token, you'll have to run this command again to generate the updated assets.

# Making changes
> Don't forget that we also have Figma counterpart that requires update when there is any change (May 2022).
> <br />Link to Figma guide: https://www.figma.com/file/N0wRgro1ZHxK0VTIyoj2li/Anvil-Theme-Core?node-id=1204%3A1733

## Updating an existing token

1. Make a new branch
2. Update the token object located under `tokens/themes/<theme name>` with the new value
3. Run `npm run build` to update the assets in the `build` folder
4. Create a PR

## Adding a new design token

> Adding a new design token requires all existing themes to have respective token defined. This only applies to color related tokens for now (May 2022).

Steps to adding new design token:
1. Make a new branch 
2. Update `tokens/themes/theme.d.ts` with the new token
3. Add the new design token key and value to all of the themes
4. Run `npm run build` to update the assets in the `build` folder
5. Create a PR

## Adding a new theme

Copy a theme to base on, for example `tokens/themes/core`, and make changes to the values.