open-index/open-npm huggingface dataset:
npm package: @loyalekoinu/workiom-basic-mcp-server
Description: MCP Server generated from OpenAPI spec for workiom
Latest version: 1.3.0


# workiom

API server for Workiom with basic app/data functionality. This is for (CRUD) creating, reading, updating, and deleting records, lists and apps.

## Getting Started

1. Install dependencies:
```
npm install
```

2. Start the server:
```
npm start
```

## Configuration

The server can be configured using environment variables. See the `.env.example` file for available options.

## API Documentation
This can be run as a streaming HTTP mcp server or an STDIO server. 

In your MCP json file add (make sure to replace the API key with your own so it can acccess your apps):
```
{
  "mcpServers": {
      "workiom-basic": {
        "command": "npx",
        "args": [
          "-y",
          "@loyalekoinu/workiom-basic-mcp-server"
        ],
        "env": {
          "WORKIOM_BASE_URL": "https://api.workiom.com",
          "WORKIOM_API_KEY": "REPLACE-WITH-YOUR-API-KEY"
        }
      }
}  }
```

## Tool Scopes

You can configure which tools are exposed by the MCP server by using the --tools option at start time.

Available scopes:
`workiom-workiom-data`, `workiom-workiom-apps`, `workiom-workiom-lists`

Available permissions:
- all
- create
- read
- update
- delete
npm package: @loyall/react-medium-editor-loyall
Description: Customized react wrapper for medium-editor for Loyall
Author: Wang Zuo
Latest version: 1.8.2

# react-medium-editor-loyall
Customized version for Loyall. Completely based on react-medium-editor

React wrapper for [medium-editor](https://github.com/daviferreira/medium-editor)

For better rich text editing with react, check [draft-js](http://draftjs.org/).

### Demo
[http://wangzuo.github.io/react-medium-editor](http://wangzuo.github.io/react-medium-editor)
### Installation
``` sh
npm install react-medium-editor-loyall --save
```
### Usage
``` javascript
// load theme styles with webpack
require('medium-editor/dist/css/medium-editor.css');
require('medium-editor/dist/css/themes/default.css');

// ES module
import React, { Component } from 'react';
import Editor from '../lib/editor';


class App extends Component {
  
  getInitialState() {
    return {
      text: 'Etiam Fringilla Magna Quam'
    };
  }

  render() {
    return (
      <div className="app">
        <h1>react-medium-editor</h1>
        <h3>Html content</h3>
        <div>{this.state.text}</div>

        <h3>Editor #1 (&lt;pre&gt; tag)</h3>
        <Editor
          tag="pre"
          className="editor"
          onFocus={this.handleFocus}
          onBlur={this.handleBlur}
          text={this.state.text}
          onChange={this.handleChange}
          options={{toolbar: {buttons: ['bold', 'italic', 'underline']}}}
        />

        <h3>Editor #2</h3>
        <Editor
          text={this.state.text}
          onChange={this.handleChange}
        />

        <h3>Editor #3 (editing disabled)</h3>
        <p>Useful for using the toolbar with customized buttons/actions</p>
        <Editor
          style={{ outline: 'dotted 1px', padding: 10 }}
          text={this.state.text}
          options={{disableEditing: true, toolbar: false }}
        />
      </div>
    );
  }

  handleFocus() {
    console.log('onFocus');
  }

  handleBlur() {
    console.log('onBlur');
  }

  handleChange(text, medium) {
    this.setState({
      text: text
    });

    console.log('medium', medium);
  }
}
export default App;
```
### License
MIT
npm package: @loyalops/web-core
Description: Framework-agnostic core for the LoyalOps SDK
Latest version: 0.1.0-beta.7

# @loyalops/web-core

Framework-agnostic HTTP client and shared types for the
[LoyalOps](https://loyalops.com) SDK.

> **Note:** This package is bundled into `@loyalops/react`, `@loyalops/vue`, and
> `@loyalops/react-native`. You do not need to install it directly unless you
> are building a custom framework integration.

## Installation

```bash
npm install @loyalops/web-core
```

## Usage

```ts
import { LoyalOpsClient } from "@loyalops/web-core";

const client = new LoyalOpsClient({
    tenantPublicKey: "your-tenant-public-key",
    userToken: userToken,
    // baseUrl: "https://api.loyalops.com/v1", // default
});

const missions = await client.request<Mission[]>("/missions");
```

## Exports

### `LoyalOpsClient`

Configured HTTP client for the LoyalOps API.

| Constructor Option | Type     | Required | Description                                              |
| ------------------ | -------- | -------- | -------------------------------------------------------- |
| `tenantPublicKey`  | `string` | ✓        | Your tenant public key.                                  |
| `userToken`        | `string` | ✓        | JWT identifying the current user.                        |
| `baseUrl`          | `string` |          | API base URL. Defaults to `https://api.loyalops.com/v1`. |

#### `.request<T>(path, options?)`

Makes an authenticated request to the LoyalOps API. Throws `LoyalOpsApiError` on
non-2xx responses.

### `LoyalOpsApiError`

Error class thrown on non-2xx API responses. Exposes `status: number` and
`body: unknown`.

### `parseUserIdFromToken(token)`

Parses the `sub` claim from a JWT string without verifying the signature.

### Types

All TypeScript types are re-exported for convenience:

`Mission`, `MissionSubmission`, `MissionReward`, `MissionType`, `MissionStatus`,
`MissionFrequency`, `SubmissionStatus`, `RewardType`, `CurrencyRewardConfig`,
`MultiplierRewardConfig`, `ExternalRewardConfig`, `Currency`, `Platform`,
`LoyalOpsConfig`, `UserBalance`, `UserMultiplier`, `UserRank`,
`LeaderboardEntry`, `Leaderboard`.

## License

MIT
npm package: @loyalove/dxf-parser
Description: Parse dxf files into a readable, logical js object.
Author: GDS Storefront Estimating
Latest version: 0.6.1


# Dxf-Parser

**Dxf Parser** is a javascript parser for dxf files. It reads dxf files into one large javascript object with readable properties and a more logical structure.

Also, keep an eye on [three-dxf](https://github.com/gdsestimating/three-dxf), a browser module for rendering the output of Dxf-Parser in the browser.

#### Install
```
npm install dxf-parser
```
Browsers -- As of 0.1.3 standalone browserify version is in the dist/ folder. Copy it out of the install directory or just download it from the GitHub repo directly. We may evetually publish this to bower, but the build environment needs a little work first.

#### Usage
```
// Grab fileText in node.js or browser
var fileText = ...;

var parser = new DxfParser();
try {
    var dxf = parser.parseSync(fileText);
}catch(err) {
    return console.error(err.stack);
}
```

See the [wiki Example Output page](https://github.com/gdsestimating/dxf-parser/wiki/Example-Output) to get an idea of what the results look like.

#### Run Samples
node.js
```
node samples/parseSync
node samples/parseStream
```

browser - the [three-dxf repo](https://github.com/gdsestimating/three-dxf) has a sample for viewing dxf cad in the browser 

#### What's Supported

Support
* Header
* Most 2D entities
* Layers
* LType table
* Block table and inserts
* VPort table
* Text and some MTEXT
* Some XData

Does not yet support
* 3DSolids
* All types of Leaders
* other less common objects and entities.

### Contributing

See the [wiki](https://github.com/gdsestimating/dxf-parser/wiki) for info on contributing

#### Run Tests
```
npm install -g mocha
//Then
npm test
//OR
mocha test
```
npm package: @loyalove/egg-nuxt
Description: egg framework for nuxt
Author: loyalove
Latest version: 1.1.4


# Egg-Nuxt

> [Egg](https://eggjs.org/) + [Nuxt.js](https://nuxtjs.org) 

[![NPM version][npm-image]][npm-url]
[![build status][travis-image]][travis-url]
[![Test coverage][codecov-image]][codecov-url]
[![David deps][david-image]][david-url]
[![npm download][download-image]][download-url]
[![lincense image][lincense-image]][lincense-url]

## Requirement

- `node >= 8.9.0`
npm package: @loyalty-corp/analytics
Description: > Loyalty Corp Analytics wrapper
Author: LoyaltyCorp
Latest version: 0.0.0-rc10

# LC Analytics

[![NPM version](https://img.shields.io/npm/v/@loyalty-corp/analytics.svg?style=fla)](http://npmjs.org/gh-jira)
[![NPM downloads](http://img.shields.io/npm/dm/@loyalty-corp/analytics.svg?style=flat)](http://npmjs.org/gh-jira)
[![Codeship](https://img.shields.io/codeship/918898c0-f367-0135-fd72-3e09b2bc026f.svg)](https://app.codeship.com/projects/272366)

> Loyalty Corp Analytics wrapper

We wrapped the most used analytics providers for you. Enjoy!

## Usage

> Before start, make sure you load the providers SDKs. This library rely on their global variables.

1.  Install it via NPM: `yarn add @loyalty-corp/analytics`
2.  Configure the providers you want to use:

```js
import { Analytics } from "@loyaltycorp/analytics";

const analytics = new Analytics({
  use: ["segment", "ensighten"]
});
```

3.  Start tracking:

```js
analytics.page();
analytics.track("Added to Cart", {
  cart: {
    currency: "AUD",
    total: 100,
    products: [{ name: "Optus Benefit Card", price: 50, quantity: 2 }]
  }
});
analytics.identify("ciro@loyaltycorp.com.au");
```

## API

| Method   | Usage                                                                        |
| -------- | ---------------------------------------------------------------------------- |
| Track    | `analytics.track(eventName: string, eventProperties: any, isLazy?: boolean)` |
| Identify | `analytics.identify(userId: string, userProperties: any, isLazy?: boolean)`  |
| Page     | `analytics.page(name?: string, customProperties?: any)`                      |

The `isLazy` property saves `track` and `identify` calls and trigger them in the next page load.

## Providers

| Provider  | Name      |
| --------- | --------- |
| Segment   | segment   |
| Ensighten | ensighten |

## Team

Built with ❤️ by the [Loyalty Corp](https://loyaltycorp.com.au) team.
npm package: @loyaltylion/headless-api-client
Description: Lightweight JS client to interact with the LoyaltyLion Headless API
Author: LoyaltyLion
Latest version: 0.0.7

# loyaltylion/headless-api-client

This is a lightweight (~4KB gzipped) TypeScript/JavaScript client that can be used to interact
with the [LoyaltyLion Headless API](https://developers.loyaltylion.com/headless-api).

All API requests and responses are fully typed based on our OpenAPI spec. You
can also import and use the types directly and make your own HTTP requests.

Note that this client is exclusively for server-side use, as it requires private
API keys which must not be exposed to the client.

# How to use

## Create and use a client

To use the client, you'll need your LoyaltyLion Site ID and an [API
key](https://developers.loyaltylion.com/api-reference/authentication/api-keys).

```ts
import { createHeadlessApiClient } from "@loyaltylion/headless-api-client";

const client = createHeadlessApiClient({
  siteId: parseInt(process.env.LOYALTYLION_SITE_ID),
  apiKey: process.env.LOYALTYLION_API_KEY,
  channel: "web",
});

// retrieve the full site configuration
const configuration = await client.getConfiguration();
```

## Use a custom fetch implementation

By default, API calls will use the global `fetch` implementation. You can
instead pass a custom fetch implementation when creating a client provided it
implements the `(input: Request) => Promise<Response>` type.

```ts
const client = createHeadlessApiClient({
  siteId: parseInt(process.env.LOYALTYLION_SITE_ID),
  apiKey: process.env.LOYALTYLION_API_KEY,
  channel: "web",
  customFetch: (input) => {
    // do request using your own HTTP client
  },
});
```

## Import and use types

All request and response types can be imported and used directly.

```ts
import type { SiteConfiguration } from "@loyaltylion/headless-api-client";

function renderConfiguration(configuration: SiteConfiguration) {}

renderConfiguration(await client.getConfiguration());
```

You can also import types from the underlying OpenAPI spec:

```ts
import type {
  components,
  operations,
  paths,
} from "@loyaltylion/headless-api-client";
```

If you wanted to make your own request to, for example, the `Initialize Session`
endpoint without using our client, you could do something like the following:

```ts
import type {
  CustomersInitializeSessionRequestBody,
  CustomersInitializeSessionResponseBody,
} from "@loyaltylion/headless-api-client";

const siteId = 1;
const apiKey = "key";
const merchantId = "1001";

const res = await fetch(
  "https://api.loyaltylion.com/headless/2025-06/${siteId}/customers/${merchantId}/sessions",
  {
    headers: {
      Authorization: `Bearer ${apiKey}`,
      "X-LoyaltyLion-Channel": "web",
    },
    body: JSON.stringify({
      customer: {
        email: "alice@example.com",
      },
      session: {
        page_url: "https://example.com/collections",
      },
    } satisfies CustomersInitializeSessionRequestBody),
  }
);

if (!res.ok) {
  throw new Error("API request failed");
}

const data: CustomersInitializeSessionResponseBody = await res.json();
```