open-index/open-npm huggingface dataset:
npm package: @hla4ts/create-spacekit
Description: Scaffold a minimal @hla4ts/spacekit rover app
Latest version: 0.1.1

# @hla4ts/create-spacekit

Scaffold a minimal `@hla4ts/spacekit` lunar rover app.

The generated project is intentionally simpler than the repo's validation
examples. It creates one `PhysicalEntity`, drives it with `SpacekitApp.run()`,
and keeps the common RTI/Spacekit knobs in `.env`.

## What It Generates

- a Bun + TypeScript project
- a single-file rover runtime built on `@hla4ts/spacekit`
- `.env` defaults for RTI host/port/TLS, federation, federate, frame, timing,
  and rover motion

## Local Workspace Usage

From this repo checkout:

```bash
bun run --filter @hla4ts/create-spacekit cli -- my-rover
```

## Intended Published Usage

The package is structured with a `bin` entry so it is ready for:

```bash
bunx @hla4ts/create-spacekit my-rover
```

That one-line path still depends on publishing the package to the npm registry.

## Options

- `--template lunar-rover`
- `--list-templates`
- `--federation-name <name>`
- `--federate-name <name>`
- `--federate-type <type>`
- `--rti-host <host>`
- `--rti-port <port>`
- `--rti-use-tls`
- `--parent-reference-frame <frame>`
- `--rover-name <name>`
- `--rover-type <type>`
- `--rover-speed-mps <value>`
- `--lookahead-micros <value>`
- `--update-period-micros <value>`
- `--reference-frame-timeout-ms <value>`
- `--reference-frame-missing-mode <mode>`
- `--workspace-deps`
- `--yes`

`--workspace-deps` is for local monorepo validation. It writes
`"@hla4ts/spacekit": "workspace:*"` into the generated project instead of the
published semver range.

`--reference-frame-missing-mode` controls what the generated rover does when
its parent reference frame has not been published yet. The template default is
`continue`.

## Generated App

After scaffolding:

```bash
cd my-rover
bun install
bun run start
```

Edit `.env` to point at your RTI and federation.
npm package: @hla4ts/spacefom
Description: Thin SpaceFOM helper layer with bundled XML modules, coders, and constants
Latest version: 0.1.1

# @hla4ts/spacefom

Thin SpaceFOM asset/helper layer beneath `@hla4ts/spacekit`.

This package is no longer the main application entry point for SEE users.
Start with `@hla4ts/spacekit` unless you specifically need one of the raw
SpaceFOM building blocks below:

- bundled base SpaceFOM XML modules
- `loadSpaceFomModules()` for inline/path module loading
- SpaceFOM constants such as execution modes and sync point labels
- low-level encode/decode helpers and coders
- optional dashboard launcher via `serveDashboard()`

## Install

```bash
bun add @hla4ts/spacefom
```

## Load Base Modules

```ts
import { loadSpaceFomModules } from "@hla4ts/spacefom";

const baseModules = await loadSpaceFomModules({ format: "inline" });
```

## Encode/Decode SpaceFOM Values

```ts
import {
  decodeHLAunicodeString,
  encodeHLAunicodeString,
  encodeSpaceTimeCoordinateState,
} from "@hla4ts/spacefom";
```

## Execution and Sync Constants

```ts
import {
  SpaceFomExecutionMode,
  SpaceFomMtrMode,
  SpaceFomSyncPointLabels,
} from "@hla4ts/spacefom";
```

## Dashboard Loader

`serveDashboard()` remains here because it is an optional SpaceFOM-oriented
tooling hook:

```ts
import { serveDashboard } from "@hla4ts/spacefom";

const server = await serveDashboard();
await server.close();
```

This requires `@hla4ts/spacefomapp-dashboard` to be installed separately.

## When To Use `@hla4ts/spacekit` Instead

Use `@hla4ts/spacekit` if you need any of the following:

- `SpacekitApp`
- `PhysicalEntity`, `DynamicalEntity`, `ReferenceFrame`, `ExecutionConfiguration`
- `ModeTransitionRequest`
- `SpaceFomLateJoinerBootstrap`
- `createSpaceFomConfig()` or `declareSpaceFom()`
- runtime adapter generation from decorated classes
- SEE run loop and reference-frame-aware registration
npm package: @hlang-org/editor
Description: ![](https://github.com/xyflow/web/blob/main/assets/codesandbox-header-ts.png?raw=true)
Latest version: 1.0.0

![](https://github.com/xyflow/web/blob/main/assets/codesandbox-header-ts.png?raw=true)

# React Flow starter (Vite + TS)

We've put together this template to serve as a starting point for folks
interested in React Flow. You can use this both as a base for your own React
Flow applications, or for small experiments or bug reports.

**TypeScript not your thing?** We also have a vanilla JavaScript starter template,
just for you!

## Getting up and running

You can get this template without forking/cloning the repo using `degit`:

```bash
npx degit xyflow/vite-react-flow-template your-app-name
```

The template contains mostly the minimum dependencies to get up and running, but
also includes eslint and some additional rules to help you write React code that
is less likely to run into issues:

```bash
npm install # or `pnpm install` or `yarn install`
```

Vite is a great development server and build tool that we recommend our users to
use. You can start a development server with:

```bash
npm run dev
```

While the development server is running, changes you make to the code will be
automatically reflected in the browser!

## Things to try:

- Create a new custom node inside `src/nodes/` (don't forget to export it from `src/nodes/index.ts`).
- Change how things look by [overriding some of the built-in classes](https://reactflow.dev/learn/customization/theming#overriding-built-in-classes).
- Add a layouting library to [position your nodes automatically](https://reactflow.dev/learn/layouting/layouting)

## Resources

Links:

- [React Flow - Docs](https://reactflow.dev)
- [React Flow - Discord](https://discord.com/invite/Bqt6xrs)

Learn:

- [React Flow – Custom Nodes](https://reactflow.dev/learn/customization/custom-nodes)
- [React Flow – Layouting](https://reactflow.dev/learn/layouting/layouting)
npm package: @hlcloud/components
Description: @hlcloud components library
Author: hlcloud
Latest version: 1.0.0

# @hlcloud/components

Vue 3 组件库，基于 Vue 3 + TypeScript 构建的现代化组件库。

## 特性

- 🚀 基于 Vue 3 + TypeScript 构建
- 📦 支持按需引入
- 💪 使用 Monorepo + pnpm 工作区管理
- 📝 完整的类型定义
- 🔧 完善的开发工具链

## 安装

```bash
npm install @hlcloud/components

yarn add @hlcloud/components

pnpm add @hlcloud/components
```

## 快速开始

### 全局引入

```ts
// main.ts
import { createApp } from 'vue';
import App from './App.vue';

import HLUI from '@hlcloud/components';
import '@hlcloud/components/style.css';

const app = createApp(App);
app.use(HLUI);
app.mount('#app');
```

### 按需引入

```ts
// main.ts
import { createApp } from 'vue';
import App from './App.vue';

import { Button } from '@hlcloud/components';
import '@hlcloud/components/style.css';

const app = createApp(App);
app.use(Button);
app.mount('#app');
```

## 使用示例

```vue
<template>
  <HlButton type="primary">按钮</HlButton>
</template>

<script setup lang="ts">
import { HlButton, HlButton } from '@hlcloud/components';
import { ref } from 'vue';
</script>
```
npm package: @hlcloud/custom-themes
Description: 用于多个 `app` 公用的样式文件
Author: hlcloud
Latest version: 0.0.1

# @hlcloud/custom-themes

用于多个 `app` 公用的样式文件

## 用法

### 添加依赖

```bash
pnpm add @hlcloud/custom-themes
```

### 自定义主题

```ts
import '@hlcloud/custom-themes/element-plus';
import '@hlcloud/custom-themes/antd';
import '@hlcloud/custom-themes/tdesign';
```

## element-plus 主题

### 文件目录

```bash
packages/custom-themes/src/element-plus/index.scss 自定义样式
packages/custom-themes/src/element-plus/variables.scss 主题变量
packages/custom-themes/src/element-plus/reset.scss 重置样式
```

### 打包后文件目录

```bash
packages/custom-themes/dist/element-plus/index.css 包含element-plus主题的样式文件
packages/custom-themes/dist/element-plus/src/variables.scss 主题变量源文件
packages/custom-themes/dist/element-plus/src/index.scss 自定义样式源文件
```

### 使用方法

1. 全局引入

```ts
import '@hlcloud/custom-themes/element-plus';
or
import '@hlcloud/custom-themes/element-plus/src/index.scss';
```

2. Vite按需引入

```ts
import { defineConfig } from 'vite';
import vue from '@vitejs/plugin-vue';
import AutoImport from 'unplugin-auto-import/vite';
import Components from 'unplugin-vue-components/vite';
import { ElementPlusResolver } from 'unplugin-vue-components/resolvers';

// https://vitejs.dev/config/
export default defineConfig({
  css: {
    preprocessorOptions: {
      scss: {
        additionalData: `@use "@hlcloud/custom-themes/element-plus/src/variables.scss" as *;`
      }
    }
  },
  plugins: [
    vue(),
    AutoImport({
      resolvers: [ElementPlusResolver()]
    }), // 如果是全局引入则无需配置这个ElementPlusResolver()
    Components({
      resolvers: [ElementPlusResolver({ importStyle: 'sass' })]
    }) // 如果是全局引入则无需配置这个ElementPlusResolver()
  ],
  // ...
});

```

## tdesign 主题

### 文件目录

```bash
packages/custom-themes/src/tdesign/index.scss 自定义样式
packages/custom-themes/src/tdesign/variables.scss 主题变量
```

### 打包后文件目录

```bash
packages/custom-themes/dist/tdesign/index.css 包含tdesign主题的样式文件
packages/custom-themes/dist/tdesign/src/variables.scss 主题变量源文件
packages/custom-themes/dist/tdesign/src/index.scss 自定义样式源文件
```

### 使用方法

1. 全局引入

```ts
import '@hlcloud/custom-themes/tdesign';
or
import '@hlcloud/custom-themes/tdesign/src/index.scss';
```

2. Vite按需引入

```ts
import { defineConfig } from 'vite';
import vue from '@vitejs/plugin-vue';
import AutoImport from 'unplugin-auto-import/vite';
import Components from 'unplugin-vue-components/vite';
import { TDesignResolver } from 'unplugin-vue-components/resolvers';

// https://vitejs.dev/config/
export default defineConfig({
  css: {
    preprocessorOptions: {
      scss: {
        additionalData: `@use "@hlcloud/custom-themes/tdesign/src/variables.scss" as *;`
      }
    }
  },
  plugins: [
    vue(),
    AutoImport({
      resolvers: [TDesignResolver()]   // 如果是全局引入则无需配置这个TDesignResolver()
    }),
    Components({
      resolvers: [TDesignResolver()] // 如果是全局引入则无需配置这个TDesignResolver()
    })
  ]
})
npm package: @hldprk/tokens
Description: A recursive-descent parsing library.
Author: Holden Perkins
Latest version: 0.0.3


`tokens` is a recursive descent parsing library where class structure defines a syntax tree.
# Usage
```js
const Number = Token.register('Number', /\d+/, 'a number');
const Whitespace = Token.register('Whitespace', /[ \t]+/, 'a whitespace');
const Operator = Token.register('Operator', /[\+\*\\\-]/, 'an operator');

class Expression extends Sequence {

	left = new Number();
	operator = new Operator();
	right = new Expression.Right();

	static Right = class extends Choice {

		static choices = [Expression, Number];

	}

}

let state = new State('1 + 2 * 3');

let expression = new Expression();

expression.parse(state);

```
In this example:

* `Token.register` defines `Number`, `Whitespace`, and `Number` tokens, which makes them available while tokenizing.
* `Expression` defines the syntax tree for a binary expression, which can be parsed from a `State` object initialised by some input string.