open-index/open-npm huggingface dataset:
npm package: @simpleryo/syw-form
Description: SimplerYo Form
Author: SimplerYO
Latest version: 0.1.19

# SimplerYo Form Web Component

### What is this repository for? ###
* Provide common form related components.
* Implement the fields style base on syw-uikit 
* Support the validation for the fields

### Plugins ###
* syw-uikit

### Contribution guidelines ###
* Code review
* Writing tests (Better to have)

### Who do I talk to? ###
* SimplerYo Development Team
npm package: @simpleryo/syw-uikit
Description: This README would normally document whatever steps are necessary to get your application up and running.
Author: SimplerYo
Latest version: 0.6.12

### What is this repository for? ###

* This is the internal ui library for simpleryo
* Version 0.4.3

### Contribution guidelines ###
* Writing tests
* Code review
* [Learn Markdown](https://guides.github.com/features/mastering-markdown/)

### Who do I talk to? ###

* Repo owner or admin

### Code standard ###

- Branch name
  - Feature/dropdown (such as the development of new modules dropdown)

  - Bugfix/dropdown-not-work-on-ie (such as repair dropdown does not work on ie)

  - Spike/animation (such as trying a animation)
npm package: @simplesat/n8n-nodes-simplesat
Description: Simplesat's n8n community node
Author: Simplesat
Latest version: 1.0.4

# Simplesat's n8n node

This is an n8n community node. It lets you connect to the Simplesat API in your n8n workflows to manage surveys, responses, answers, customers, and team members.

[n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/reference/license/) workflow automation platform.

[Installation](#installation)  
[Operations](#operations)  
[Credentials](#credentials)
[Usage](#usage)  
[Resources](#resources)

## Installation

Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.

## Operations

### Surveys

- **List** - Retrieve all surveys with pagination
- **Send by Email** - Send a survey to a customer via email with optional team member and ticket information

### Questions

- **List** - Get questions with filtering by survey ID and metric type (NPS, CSAT, 5-Star, CES, Custom)

### Responses

- **Get** - Retrieve a specific response by ID
- **Search** - Advanced search with date ranges, filters, and pagination

### Answers

- **Get** - Retrieve a specific answer by ID
- **Search** - Advanced search with date ranges, filters, and pagination

### Customers

- **List** - Get customers with date filtering and subscription status
- **Get** - Retrieve a specific customer by ID
- **Create or Update** - Create new customers or update existing ones

### Team Members

- **Get** - Retrieve a specific team member by ID
- **Create or Update** - Create new team members or update existing ones

## Credentials

To use this node, you need a Simplesat account with an API key:

1. Log into your Simplesat account
2. Navigate to [Workspace Settings](https://app.simplesat.io/settings/workspace/)
3. Copy your API key
4. Use the API key in the Simplesat API credentials in n8n

The node uses the `X-Simplesat-Token` header for authentication.

## Usage

For detailed usage information, API endpoints, and examples, please refer to the [Simplesat API documentation](https://developer.simplesat.io/api).

## Resources

- [Simplesat n8n help guide](https://help.simplesat.io/en/articles/12679403-simplesat-s-n8n-community-node)
- [Simplesat API Documentation](https://developer.simplesat.io/api)
- [Simplesat Website](https://simplesat.io/)
- [n8n community nodes documentation](https://docs.n8n.io/integrations/#community-nodes)
npm package: @simplestack/query
Description: Add client JS to your Astro components, without the query selectors
Author: bholmesdev
Latest version: 0.3.0

# Simple stack query

A simple library to query the DOM from your Astro components.

```astro
<RootElement>
  <button data-target="btn">Click me</button>
</RootElement>

<script>
  RootElement.ready(($) => {
    $('btn').addEventListener('click', () => {
      console.log("It's like JQuery but not!");
    });
  });
</script>
```

📚 Visit [the docs](https://simple-stack.dev/query) for more information and usage examples.
npm package: @simplestack/store
Description: A simple storage solution for React
Author: bholmesdev
Latest version: 0.7.7

# Simple Store

<div>
    <a href='https://github.com/bholmesdev/simplestack-store' rel='nofollow'>
        <img alt='stars' src='https://img.shields.io/github/stars/bholmesdev/simplestack-store?color=blue'>
    </a>
    <a href='https://www.npmjs.com/package/@simplestack/store' rel='nofollow'>
        <img alt='npm' src='https://img.shields.io/npm/v/@simplestack/store?color=blue'>
    </a>
</div>

[![I fixed Zustand's BIGGEST problem](https://img.youtube.com/vi/gXz-lLIJbMI/0.jpg)](https://www.youtube.com/watch?v=gXz-lLIJbMI)

A simple, `select`-xcellent state management library for React.

The goal: make a storage solution as powerful as Zustand or Redux, without complicated functions to set and select state.

Here's an overview of how stores are created, and how you can operate on parts of a store using `.select()`:

```tsx
import { store } from "@simplestack/store";
import { useStoreValue } from "@simplestack/store/react";

// Define your store with an initial state
const documentStore = store({
  title: "Untitled",
  authors: ["Ada", "Ben"],
  meta: {
    pages: 3,
    tags: ["draft", "internal"],
  },
});

function Document() {
  // Update your UI with the store's current state
  const {
    title,
    meta: { tags },
  } = useStoreValue(documentStore);
  return (
    <div>
      {title} {tags.join(", ")}
    </div>
  );
}

// Or, select parts of a store to listen to individually
const titleStore = documentStore.select("title");
const tagsStore = documentStore.select("meta", "tags");

function Title() {
  // And scope updates with selected stores for fine-grained control
  const title = useStoreValue(titleStore);
  return (
    <input value={title} onChange={(e) => titleStore.set(e.target.value)} />
  );
}
```

📚 For a complete usage guide and API reference, [visit our documentation](https://simple-stack.dev/store).

## Contributing

We are open to contributions! **Before submitting your feature request**, please read the [CONTRIBUTING.md](CONTRIBUTING.md) for our issue and PR process.

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details.
npm package: @simplesteps/local
Description: Local execution runtime for SimpleSteps — test AWS Step Functions workflows locally with mock services
Latest version: 0.2.0

# @simplesteps/local

[![npm](https://img.shields.io/npm/v/@simplesteps/local)](https://www.npmjs.com/package/@simplesteps/local)
[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/DevNamedZed/simplesteps/blob/main/LICENSE)

Local execution runtime for [SimpleSteps](https://github.com/DevNamedZed/simplesteps). Compile TypeScript workflows to ASL with `@simplesteps/core`, then run and test them locally with mock services — no AWS account needed.

## Install

```bash
npm install @simplesteps/local
```

## Usage

```typescript
import { compile } from '@simplesteps/core';
import { LocalRunner } from '@simplesteps/local';

// Compile your workflow
const result = compile({ sourceFiles: ['workflow.ts'] });
const asl = result.stateMachines[0].asl;

// Execute locally with mock services
const runner = new LocalRunner(asl, {
  services: {
    'arn:aws:lambda:us-east-1:123456789:function:MyFn': async (input) => {
      return { status: 'ok' };
    },
  },
});

const output = await runner.execute({ orderId: '123' });
console.log(output);
```

### Execution Traces

Use `executeWithTrace` to inspect the full state-by-state execution path:

```typescript
const { output, trace } = await runner.executeWithTrace({ orderId: '123' });

for (const entry of trace.states) {
  console.log(`${entry.name} (${entry.type})`);
}
```

## Features

- Supports all 8 ASL state types (Task, Pass, Choice, Wait, Succeed, Fail, Parallel, Map)
- Both JSONata and JSONPath query languages
- All 18 `States.*` intrinsic functions
- Choice state comparison operators and compound rules
- Full data flow pipeline (InputPath, Parameters, ResultSelector, ResultPath, OutputPath)
- Error handling (Catch/Retry)
- Execution tracing for test assertions

## Documentation

- [Getting Started](https://github.com/DevNamedZed/simplesteps/blob/main/docs/getting-started.md)
- [Language Reference](https://github.com/DevNamedZed/simplesteps/blob/main/docs/language-reference.md)

[Playground](https://devnamedzed.github.io/simplesteps/) | [GitHub](https://github.com/DevNamedZed/simplesteps)

## License

MIT
npm package: @simpletext/client
Description: A type-safe client for SimpleText API
Author: Charlie Meyer
Latest version: 1.0.8

<div align="center">

<a href="https://simpletext.dev" target="_blank" title="Go to the simpletext website"><img width="150px" alt="gowebly logo" src="https://staging.simpletext.dev/png/logo.png"></a>

<a name="readme-top"></a>

# simpletext client

</div>

<div align="center">
  <a href="https://simpletext.dev">Home</a> | <a href="https://docs.simpletext.dev">Docs</a> | <a href="https://docs.simpletext.dev/roadmap">Roadmap</a> | <a href="https://news.simpletext.dev/roadmap">Newsletter</a>
</div>

## Table of Contents

This repository contains the client, `@simpletext/client` for simpletext (stupidly simple sms).

## Contributing

simpletext welcomes contributions to make sms even simpler. We are especially looking for talented developers to help build our APIs as per our [roadmap](https://docs.simpletext.dev/roadmap) to contribute to a couple key contributions (among others)!

To contribute:

1. Fork and clone the repository
2. Ensure you have installed the packages with `npm install` and have the most recent version of typescript.
3. Make your changes and create a pull request!
npm package: @simpleview/async-cron
Description: Async cron job runner using cron syntax
Author: Owen Allen
Latest version: 0.1.0

# async-cron
Simple cron job runner for Node that handles async functions and uses a `Mutex` that keeps the same job from running more than once simultaneously.

# Installation

```
npm install @simpleview/async-cron
```

# Example

```js
const { Job } = require("@simpleview/async-cron");

const job = new Job({
	schedule : "*/5 * * * * *"
}, async function() {
	const results = await doSomething();
	return someResult;
});

// Required: Handle errors, or they will be black-holed resulting in not knowing that your crons are failing
job.on("error", function(e) {
	console.log("Cron Error", e);
});

// Not required: if you care about the returned result from a cronJob, you can do something with it here
job.on("result", function(result) {
	
});

// Starts the job running the background
job.start();
```

## Error Handling

If your job errors, the error will be blackholed unless you subscribe to the error handler.

```js
job.on("error", function(e) {
	// do something with the error
});
```

If you want to differentiate errors from the job running from code errors, you can check the error `code`.

```js
const { Job, E_RUNNING } = require("@simpleview/async-cron");

const job = new Job(...args...);

job.on("error", function(e) {
	if (e.code === E_RUNNING) {
		console.log("Still running!");
	} else {
		console.log("An actual code problem!");
	}
});
```

# Package API

## Job

`Job` represents a single cron job.

* args
	* schedule - `string` - The schedule in [cron-parser](https://www.npmjs.com/package/cron-parser) syntax.
* fn - `function` or `async function` - The function that will execute your job. It should either run fully synchronously, or be an async method/promise-based method. Do not utilize callbacks here, or else the async locking mechanism will not function properly. When this function returns, the job must be complete.

### Job.start()

Starts the job running in the background.

### Job.stop()

Stops the job. This will not halt functions that are currently executing at this very moment, but it will present new runs from queuing up.

### Job.run()

Manually executes the job. If the job errors, then this will throw, this includes throwing if the job is currently executing.

```js
const result = await job.run();
```

### Job.isRunning()

Check if the job is currently running.

```js
const isRunning = job.isRunning();
```

## E_RUNNING

Symbol reference for `error.code` when an `Error` is thrown due to an a job already running. See error handling.
npm package: @simpleview/crm-client
Description: Client for communicating with sv-crm
Author: Sean Albert
Latest version: 1.0.6

# sv-crm-client
Client and tools for communicating with sv-graphql and crm-graphql-server.

# installation

```
npm install @simpleview/sv-crm-client
```

## crm_query

For all queries, a bearer token must be proved in Authorization header. To acquire your token, you must login first to get the token:
	```
	{
		auth {
			login(email: String!, password: String!) {
				success
				token
			}
		}
	}
	```

For all queries, acct_id must be passed at the root.
	```
	{
		crm(acct_id: String!) {
			...
		}
	}
	```

- **get_contact**
	- Returns an array of contacts, which can be filtered by recId.
	- See schema browser for all fields.
	```
	query getContact {
		crm(acct_id: String!) {
			get_contact(filter: {
				recId: Int
			}) {
				recId
				FirstName
				LastName
				Email {
					EmailAddress
				}
			}
		}
	}
	```

## crm_mutation

For all mutations, a bearer token must be proved in Authorization header. To acquire your token, you must login first to get the token:
	```
	{
		auth {
			login(email: String!, password: String!) {
				success
				token
			}
		}
	}
	```

For all mutations, acct_id must be passed at the root.
	```
	{
		crm(acct_id: String!) {
			...
		}
	}
	```

- **set_contact**
	- Sets a contact, and returns the ID
	- See schema browser for all possible inputs.
	```
	mutation setContact {
		crm(acct_id: String!) {
			set_contact(input: {
				FirstName: "test",
				LastName: "user",
				Email: [
					{
						type: "contact",
						EmailAddress: "test@test.com"
					}
				]
			})
		}
	}
	```
npm package: @simpleview/sv-certs-client
Description: Client for communicating with sv-certs
Author: Owen Allen
Latest version: 1.9.5

# sv-certs-client
Client for communicating with sv-certs. This npm package contains classes for communicating with the [sv-certs](https://github.com/simpleviewinc/sv-certs/) GraphQL system.

# Installation

```
npm install @simpleview/sv-certs-client
```

# GraphQL Endpoints

This section is provided to provide additional information about the GraphQL endpoints. To see the input parameters and output of each endpoint, please view the Schema in the GraphQL Explorer at https://graphql.simpleviewinc.com/.

All calls can only be made via an SV users. Bearer token must be provided in Authorization header per most sv-graphql projects.

## certificates_query
### list
* Returns all certificates for an account.
* See schema browser for filters/options.

```graphql
query {
  certificates(acct_id: "test-certificates") {
    list {
      count
      docs {
        acct_id
        name
        domains
        challenge_type
        active
      }
    }
  }
}
```

## certificates_mutation
### upsert
* Provided an acct_id and an array of certificate data, updates each associated certificate or inserts one if it does not exist.
* See [sv-certs](https://github.com/simpleviewinc/sv-certs/) to choose the right challenge.
* Password is only necessary if retrieving certs via https such as when using `curl`.
* See schema browser for all keys.

```graphql
mutation {
  certificates(acct_id: "0") {
    upsert(
      input: [
        {
          name: "your_name1"
          domains: ["your_url1.com", "*.your_url1.com"]
          challenge_type: dns01
          active: true
          password: "yourpassword1"
        }
        {
          name: "your_name2"
          domains: ["your_url1.com"]
          challenge_type: http01
          active: true
          password: "yourpassword2"
        }
      ]
    ) {
      success
      message
      results {
        success
        message
        doc {
          acct_id
          name
          domains
          challenge_type
          active
        }
      }
      errors {
        success
        message
        doc {
          acct_id
          name
          domains
          challenge_type
          active
        }
      }
    }
  }
}
```

### remove
* Provided an acct_id and name, deletes the associated certificate from the system.
* Take care not to call this endpoint without any filters as this will hard delete all certificates on the account, unless that is your intent.

```graphql
mutation {
  certificates(acct_id: "0") {
    remove(input: { name: "your_name1" })  {
      success
      message
    }
  }
}
```
npm package: @simpleview/sv-pubsub-client
Description: Client for communicating with Google Pub/Sub
Author: Paul Riding
Latest version: 1.0.13

# sv-pubsub-client

Client for communicating with the Google Pub/Sub service.

[Google Pub/Sub](https://docs.cloud.google.com/pubsub/docs/overview) is the message broker typically used by microservices to communicate events that occur in one system to the other. These events are typically changes in data, e.g. `accounts-update`.

The most important concepts in Google Pub/Sub are [Topics](https://docs.cloud.google.com/pubsub/docs/create-topic), [Subscriptions](https://docs.cloud.google.com/pubsub/docs/subscription-overview) and [Messages](https://docs.cloud.google.com/pubsub/docs/publisher).

Publishing a Message to a Topic without any Subscriptions will result in that message being lost.
A Topic can and should be created by both Producers and Consumers of that Topic, to ensure that it exists before either end attempt to interact with it.
Subscriptions are created from Topics.

These hold Messages, which Consumers consume via the persistent bidirectional connection it maintains with the Google Pub/Sub service. This is called a "streaming pull", not to be confused with polling/pull, which relies on the Consumer polling for new Messages on an interval.

## Authorising with Google Pub/Sub

Authorisation should be done through service accounts. Each microservice typically has a service account. A service account will need permissions to create topics, subscriptions, attach to subscriptions and publish messages in order to authorise.

The credentials required are:
- `projectId`, e.g. **sv-shared-231700**
- `credentials`, i.e. the Application Default Credentials of your Google Service Account

## Conventions

Topics should be named after the environment, producer, and event name of the events that pass through it.
For example, if a Camber user updates an Account on the live app, we would be broadcasting that events to all Consumers of a Topic named `live-camber-accounts-updated`.

Subscriptions should be named after the consuming app, e.g. `live-auth-live-camber-accounts-updated` and set an appropriate retention period. Subscriptions are never automatically cleaned up, however the Messages stored within them are deleted after an hour, by default, although this can be changed.