open-index/open-npm huggingface dataset:
npm package: @nasa-jpl/seq-json-schema
Description: [![npm (scoped)](https://img.shields.io/npm/v/@nasa-jpl/seq-json-schema)](https://www.npmjs.com/package/@nasa-jpl/seq-json-schema) [![PyPI](https://img.shields.io/pypi/v/seq-json-schema)](https://pypi.org/project/seq-json-schema/)
Latest version: 1.3.1

[![npm (scoped)](https://img.shields.io/npm/v/@nasa-jpl/seq-json-schema)](https://www.npmjs.com/package/@nasa-jpl/seq-json-schema)
[![PyPI](https://img.shields.io/pypi/v/seq-json-schema)](https://pypi.org/project/seq-json-schema/)

# seq-json-schema

Standardized [JSON Schema](https://json-schema.org/) for authoring multi-mission sequences. You can read the schema definition [here](https://github.com/NASA-AMMOS/seq-json-schema/blob/develop/schema.json).  
You can use our [validation site](https://nasa-ammos.github.io/seq-json-schema/) to validate a `.seq.json` document against the latest schema.

## Why a Sequence Schema?

Spacecraft are often controlled via sets of time ordered commands called sequences. Although spacecraft are built with a variety of different on-board flight softwares, each of which have different commanding interfaces, there are sufficient commonalities between these interfaces to justify creating a common sequencing specification that works for a number of flight software types.

If organizations must support operating different missions with different flight software, operators can use this common specification (with potential customization) for these different missions. Operators would author and transport the set of commands they want to send to the spacecraft in this common specification and then perform a final translation from this specification to the format required by the flight software for final verification.

## Propose a Change

Interested in proposing a change to the schema? Begin by writing a [change request issue](https://github.com/NASA-AMMOS/seq-json-schema/issues).

## JavaScript or TypeScript

### Install

```sh
npm install @nasa-jpl/seq-json-schema --save
```

### Basic Usage

```ts
import seqSchema from '@nasa-jpl/seq-json-schema/schema.json' assert { type: 'json' };
console.log(seqSchema);
```

### TypeScript Types

This library also ships with automatically generated TypeScript types from the schema. For example:

```ts
import type { Command, SeqJson } from '@nasa-jpl/seq-json-schema/types';

const command: Command = {
  args: [],
  stem: 'SEND_DATA',
  time: { type: 'COMMAND_COMPLETE' },
  type: 'command',
};

const seqJson: SeqJson = {
  id: 'sequence0',
  metadata: {},
  steps: [command],
};

console.log(seqJson);
```

## Python

### Install

```sh
pip install seq-json-schema
```

### Basic Usage

```py
import importlib.resources
import json

with importlib.resources.path('seq-json-schema', 'schema.json') as schemaPath:
  file = open(schemaPath)
  schema = json.load(file)
  print(schema)
```

Note if you are using a Python version lower than 3.7 you will have to import the schema using the [importlib-resources](https://pypi.org/project/importlib-resources/) library.
npm package: @nasa-jpl/svelte-css-grid
Description: ## Installation
Latest version: 0.0.1

# @nasa-jpl/svelte-css-grid

## Installation

```sh
npm install @nasa-jpl/svelte-css-grid --save
```

## Usage

```svelte
<script>
  import { CssGrid, CssGridGutter } from '@nasa-jpl/svelte-css-grid';
</script>

<CssGrid columns="1fr 5px 1fr 5px 1fr">
  <div />

  <CssGridGutter track={1} type="column" />

  <CssGrid rows="1fr 5px 1fr">
    <div />
    <CssGridGutter track={1} type="row" />
    <div />
  </CssGrid>

  <CssGridGutter track={3} type="column" />

  <div />
</CssGrid>
```
npm package: @nasa-jpl/svelte-stellar
Description: Svelte components for the [Stellar](https://github.com/nasa-jpl/stellar) design system.
Latest version: 0.0.1

# @nasa-jpl/svelte-stellar

Svelte components for the [Stellar](https://github.com/nasa-jpl/stellar) design system.

## Installation

```sh
npm install @nasa-jpl/svelte-stellar @nasa-jpl/stellar --save
```

## Usage

More detailed usage examples can be found on the [examples page](https://nasa-jpl.github.io/svelte-stellar/) ([implementation](https://github.com/nasa-jpl/svelte-stellar/blob/develop/src/routes/%2Bpage.svelte)).

Before usage make sure you import the base Stellar CSS files. For example if you need everything:

```svelte
<script lang="ts">
  import '@nasa-jpl/stellar/css/index.css';
  import '@nasa-jpl/stellar/font/inter/inter.css';
  // ...
</script>
```

### Button

```svelte
<script lang="ts">
  import { Button } from '../lib/index.js';
</script>

<Button>Primary</Button>
```
npm package: @nasa-terra/components
Description: A collection of NASA Earthdata components
Author: NASA GES DISC
Latest version: 0.0.173

# Terra UI Components

Intro

### Forking the Repo

Start by [forking the repo](https://github.com/nasa/terra-ui-components/fork) on GitHub, then clone it locally and install dependencies.

```bash
git clone https://github.com/YOUR_GITHUB_USERNAME/components terra-ui-components
cd terra-ui-components
npm install
```

### Developing

Once you've cloned the repo, run the following command.

```bash
npm start
```

This will spin up the dev server. After the initial build, a browser will open automatically. There is currently no hot module reloading (HMR), as browser's don't provide a way to reregister custom elements, but most changes to the source will reload the browser automatically.

### Building

To generate a production build, run the following commands.

```bash
npm run build # to build the Lit components
```

### Creating New Components

To scaffold a new component, run the following command, replacing `terra-tag-name` with the desired tag name.

```bash
npm run create terra-tag-name
```

This will generate source files, a stylesheet, a Jupyter widget, and a docs page for you. When you start the dev server, you'll find the new component in the "Components" section of the sidebar. Do a `git status` to see all the changes this command made.

### Testing Components in Jupyter Lab

Install the `uv` package manager (https://github.com/astral-sh/uv), it's a lightweight tool that makes working with virtual environments and packages much easier.

Then run the following:

-   `uv venv` - create a virtual environment (only have to do this the first time)
-   `source .venv/bin/activate` - activate it
-   `uv pip install -e ".[dev]"` - install dependencies (see pyproject.toml)
-   open base.py and point dependencies to localhost (do not commit these changes) TODO: fix this so we auto-detect local development
-   `npm run start:python` - spins up Jupyter lab and should open the browser for you

For an example of how to use the components in a Jupyter Notebook, open the `/notebooks/playground.ipynb` notebook in Jupyter Lab.

### Publishing to NPM and PyPI

The Lit components are available on NPM at: https://www.npmjs.com/package/@nasa-terra/components
The Python widgets are available on PyPI: https://pypi.org/project/terra_ui_components/

To build a new version and publish it, you can use NPM commands. The Python equivalents will be run automatically for you (see the "scripts" in package.json for details). You will need access to both repositories in order to publish.

```bash
# commit all your changes first
npm version patch # bump the version, you can use "major", "minor", "patch", etc.
npm publish --access=public
```

## License

Terra UI Components were created by the NASA GES DISC team, on top of the amazing library Shoelace.

Shoelace was created by [Cory LaViska](https://twitter.com/claviska) and is available under the terms of the MIT license.