open-index/open-npm huggingface dataset:
npm package: @grainbridge/grainbridge-aws-mock
Description: Mock AWS SDK
Latest version: 2.1.0

# @grainbridge/grainbridge-aws-mock

[![npm (scoped)](https://img.shields.io/npm/v/@fayezbarbari/grainbridge-aws-mock.svg)](https://github.com/grainbridge/grainbridge-aws-mock)

AWS Mock
npm package: @grainlogic/cache
Description: Caching strategy library
Author: Artyom Kayun
Latest version: 0.1.0

# Template [![Build Status][travis-image]][travis-url] [![Coverage][coverage-image]][coverage-url] ![License][license-url] [![JavaScript Style Guide][code-style-image]][code-style-url] ![Type Definitions][type-definitions-url] [![Npm Version][npm-version-image]][npm-version-url]

[travis-image]: https://img.shields.io/travis/grainlogic/stack/master?style=flat-square&logo=travis-ci
[travis-url]: https://travis-ci.org/grainlogic/stack
[coverage-image]: https://img.shields.io/codecov/c/gh/grainlogic/stack?style=flat-square&logo=codecov
[coverage-url]: https://codecov.io/gh/grainlogic/stack
[code-style-image]: https://img.shields.io/badge/code_style-standard-brightgreen.svg?style=flat-square&logo=eslint
[code-style-url]: https://standardjs.com
[npm-version-image]: https://img.shields.io/npm/v/@grainlogic/stack?style=flat-square
[npm-version-url]: https://www.npmjs.com/package/@grainlogic/stack
[license-url]: https://img.shields.io/github/license/grainlogic/stack?style=flat-square
[type-definitions-url]: https://img.shields.io/npm/types/typescript?style=flat-square&logo=typescript
npm package: @grainmarket/quill-placeholder-module
Description: Quill module for inserting placeholders
Author: James Paine
Latest version: 0.3.7

# Why was this forked?

* Expose typescript for compilation as part of build. 
* Compatability with Quill 2

This is maintained for elementsuite software but of course anyone is welcome to it :)

# quill-placeholder-module
Quill module for adding placeholders. [Demo](https://codepen.io/jspaine/pen/MozyNp)
## Install
```
npm install --save quill-placeholder-module
```

## Usage
```js
import getPlaceholderModule from 'quill-placeholder-module'
// es5
var getPlaceholderModule = require('quill-placeholder-module').default
// umd
var getPlaceholderModule = PlaceholderModule.default

Quill.register('modules/placeholder', getPlaceholderModule(Quill, {
  className: 'ql-placeholder-content'  // default
}))

var quill = new Quill('#editor', {
  modules: {
    toolbar: {container: `#toolbar`},
    placeholder: {
      delimiters: ['{', '}'],  // default
      placeholders: [
        {id: 'foo', label: 'Foo'},
        {id: 'required', label: 'Required', required: true}
      ]
    }
  },
  placeholder: 'Compose an epic...',
  theme: 'snow'  // or 'bubble'
});
```
Define the toolbar menu (a more complete example can be found in the [demo](https://codepen.io/jspaine/pen/MozyNp)):
```html
<div id="toolbar">
  <select class="ql-placeholder">
    <option value="foo">Foo</option>
    <option value="required">Required</option>
  </select>
</div>
<div id="editor"></div>
```
And include the css from `dist/toolbar.css`.

The markup will contain (with default options) `<span class="ql-placeholder-content" data-id="placeholder-id" data-label="placeholder-label">...</span>`

To transform the output check out https://github.com/jspaine/html-ast-transform
npm package: @grainrigi/express-date-parser
Description: Express JSON Date Parser
Author: grainrigi
Latest version: 1.0.0

# express-date-parser

Express JSON Date Parser (with body-parser)

## Usage

```js
import expressDateParser from '@grainrigi/express-date-parser';
import express from 'express';

const app = express();

app.use(expressDateParser);

```
npm package: @grainrigi/vue-fragment
Description: fragment component for vuejs
Author: Julien Barbay
Latest version: 1.5.1

# vue-fragment [![npm version](https://badge.fury.io/js/vue-fragment.svg)](https://badge.fury.io/js/vue-fragment)


---

## Disclaimer

To all enthousiasts and users of this package, first, thank you. I'm quite busy since i've published 1.5.0 and totally let go of this repo. I know it sucks, but we're all busy from time to time, right?
If someone is interested in taking lead on this, please open an issue or contact me. I'd be more than happy if someone would feel helping until Vue 3 comes up.

Cheers to all,
J.

---


## what
a very candide fragment component for Vue.js


## why
If you arrived here, I think you searched hard and you know why you're here.

For others, fragments are basically _root-less_ components. They come useful in many situations where you don't want to pollute the DOM with a useless container, or you want to return many elements at once.

## how
It's impossible to use functional components or slots, since Vue.js vDOM diffing has a "you should return one root element" limitation… Instead, I'm using an (internal) directive which will dump all the children of the fragment root node in its place. Since directives can manipulate DOM, we can act after rendering and bypass Vue limitation.

The component is called `Fragment` so you won't have to change much code when Vue3 native fragments arrive. That said, **I'm not a core developer of Vue.js, and I don't have any view of their implementation. I only know what fragments are and how they should work, and did my best to reproduce it ; so it _should_ be fine.**

## use
-  download the package `npm i -s vue-fragment`

From here, you can:

- Plugin:
    ```
    import Fragment from 'vue-fragment'
    Vue.use(Fragment.Plugin)

    // or

    import { Plugin } from 'vue-fragment'
    Vue.use(Plugin)

    // …

    export const MyComponent {
      template: '
      <fragment>
        <input type="text" v-model="message">
        <span>{{ message }}</span>
      </fragment>
      ',
      data() { return { message: 'hello world }}
    }
    ```

- Component:
    ```
    import { Fragment } from 'vue-fragment'

    export const MyComponent {
      components: { Fragment },
      template: '
      <fragment>
        <input type="text" v-model="message">
        <span>{{ message }}</span>
      </fragment>
      ',
      data() { return { message: 'hello world }}
    }
    ```
npm package: @grainular/create-nord
Description: CLI tool to scaffold new Nørd applications
Author: Sebastian Heinz
Latest version: 1.1.1

<!-- @format -->

# @grainular/create-nord

`@grainular/create-nord` is a efficient way to create new [Nørd](https://github.com/iamsebastiandev/nord) applications, based on a set of provided templates.

## Scaffolding a new Project

```bash
yarn create @grainular/nord
# or with npm
npm create @grainular/nord
```

This command will start the CLI and guide you through setting up your new Nørd app.

Using `.` for the project directory will create the project in the current directory.

## Contributing

We welcome contributions to `@grainular/create-nord`! If you're interested in contributing, please check out our [contribution guidelines](./contributing.md).

## License

`@grainular/create-nord` is made available under the MIT License. For more details, see the [license](./license.md) file.
npm package: @grainular/nord-router
Description: <!-- @format -->
Author: Sebastian Heinz
Latest version: 1.0.0

<!-- @format -->

# @grainular/nord-router

[![Npm package version](https://badgen.net/npm/v/@grainular/nord-router)](https://www.npmjs.com/package/@grainular/nord-router)
[![Npm package total downloads](https://badgen.net/npm/dt/@grainular/nord-router)](https://npmjs.com/package/@grainular/nord-router)
[![Npm package license](https://badgen.net/npm/license/@grainular/nord-router)](https://npmjs.com/package/@grainular/nord-router)

`@grainular/nord-router` is a powerful client-side routing library for Nørd applications. It provides an intuitive and flexible API to manage navigation and route handling in modern web applications, leveraging Nørd's reactive and component-based architecture.

## Installation

You can install `@grainular/nord-router` using npm or yarn:

```bash
# Using yarn
yarn add @grainular/nord-router

# Using npm
npm install @grainular/nord-router
```

## Features

-   **Declarative Routing**: Define routes in a simple and intuitive manner, with support for dynamic route parameters, nested routes, and redirects.
-   **Reactive Route Handling**: Utilize Nørd's reactive system to respond to route changes and manage route state.
-   **Component-Based**: Seamlessly integrate routing with Nørd components, enabling dynamic component rendering based on the current route.

## Documentation

The complete documentation can be found [here](https://nordjs.dev/packages/router/overview.html)

## Usage

### Basic Routing Setup

```ts
import { createComponent, render } from '@grainular/nord';
import { createRouter, Route } from '@grainular/nord-router';
import { Home } from './pages/home.page.ts';

const routes: Route[] = [
    {
        path: '/',
        redirect: '/home',
    },
    {
        path: '/home',
        component: Home,
    },
    // ... more routes ...
];

const router = createRouter(routes, { notFound: '/404' });

const App = createComponent((html) => {
    return html`<div>
        <nav>
            <!-- Navigation links -->
            <a href="/home" ${router.link}>Home</a>
        </nav>
        ${router.outlet}
    </div>`;
});

render(App, { target: document.querySelector('#app') });
```

This example demonstrates defining routes, creating a router, and setting up an outlet for rendering components based on the current route.

## Contributing

We welcome contributions to `Nørd-Router`! If you're interested in contributing, please check out our [contribution guidelines](./contributing.md).

## License

`Nørd-Router` is made available under the MIT License. For more details, see the [license](./license.md) file.
npm package: @grakeice/circular-array
Description: A TypeScript utility for circular array access. Allows you to access array elements cyclically with positive or negative indices.
Author: grakeice
Latest version: 0.1.0

# circular-array

A TypeScript utility for circular array access. Allows you to access array elements cyclically with positive or negative indices.

## Features

-   Wrap any array and access elements cyclically (positive/negative indices)
-   Get one full cycle as an array, infinite iterator, and for...of support
-   TypeScript compatible

## Installation

```bash
npm install @grakeice/circular-array
```

## Usage

```ts
import { CircularArray } from "./src/CircularArray";

const arr = new CircularArray([1, 2, 3]);
console.log(arr.at(4)); // 2
console.log(arr.at(-1)); // 3

for (const v of arr) {
	console.log(v); // 1, 2, 3
}

const gen = arr.cycle();
console.log(gen.next().value); // 1
console.log(gen.next().value); // 2
console.log(gen.next().value); // 3
console.log(gen.next().value); // 1 (infinite loop)
```

## License

MIT
npm package: @gram-data/gram-builder
Description: AST builder for gram data graph format
Author: Andreas Kollegger
Latest version: 0.3.11

`()-[build]->(ast)`

Build valid `gram` AST.

## How to gram-builder

### Install:

``` bash
npm install @gram-data/gram-builder
```

### Build an AST:

``` TypeScript
import { node, edge } from '@gram-data/gram-builder';

const left = node('a');
const right = node('b');
const ast = edge([left, right], 'right');
```

## Next Steps

- Enrich record properties with js objects using [[gram-value]]
- Serializes to a string using [[gram-stringify]]
- Introspect the AST using [[gram-ast]]
npm package: @gram-data/gram-ops
Description: gram data graph operations
Author: Andreas Kollegger
Latest version: 0.3.11

`(ast)-[ops]->(features)`

Utility operations for extracting path features from `gram` AST.

## How to gram-ops

### Install:

``` bash
npm install @gram-data/gram-ops
```

### Build a path 

Use [[gram-builder]] to create a path. 

``` TypeScript
import { node, edge } from '@gram-data/gram-builder';

const left = node('a');
const right = node('b');
const path = edge([left, right], 'right');
```

### Extract features from the path

Extract a node list:

``` TypeScript
import { nodes } from '@gram-data/gram-ops';

const ns:GramPath[] = nodes(path); 
```

Extract an edge list:

``` TypeScript
import { nodes } from '@gram-data/gram-ops';

const es:GramPath[] = edges(path); 
```

## Next Steps

- Write back to a string using [[gram-stringify]]
- Introspect the AST using [[gram-ast]]
npm package: @gram-data/gram-stringify
Description: Pretty print gram data graphs
Author: Andreas Kollegger
Latest version: 0.3.11

From gram AST to text literal `(a)-->(b)`.

## How to gram-stringify

### Install:

``` bash
npm install @gram-data/gram-stringify
```

### Build an AST using [[gram-builder]], then pretty print with gram-stringify:

``` TypeScript
import { node, edge } from '@gram-data/gram-builder';
import { stringify } from '@gram-data/gram-stringify'; 

const left = node('a');
const right = node('b');
const ast = edge([left, right], 'right');

console.log(stringify(ast));
```

### Parse to AST using [[gram-parse]], then pretty print with gram-stringify:

``` TypeScript
import { toAST } from '@gram-data/gram-parse'; 
import { stringify } from '@gram-data/gram-stringify'; 

const src = '(a)-->(b)';
const ast = toAST(src);

console.log(stringify(ast));
```

## Next Steps

- Save to a file to share a gram with a friend!
npm package: @gramble/cli
Description: Command line interface to Gramble
Author: Patrick Littell
Latest version: 0.0.2

# `@gramble/cli`

> Run your Gramble spreadsheets!

Install
-------

    npm install -g @gramble/cli

Usage
-----

Gramble has a few subcommands:

 1. generate
 2. parse
 3. sample

For general help, type

    gramble help

For help for a **specific command**, type

    gramble help <command>


### Generate

Generate all words from your Gramble grammar:

    gramble generate [--max=n][--otier=tier] [--output|-o file] <source>

### Parse

Parse or analyze forms using your Gramble grammar:

    gramble parse --itier=tier [--otier=tier] [--random] [--max=n] <source>
    gramble parse --tokenize --itier=tier --otier=tier [--random] <source>

### Sample

Sample a few words from your Gramble grammar:

    gramble sample [--output|-o file] <source>
npm package: @gramex/chartbase
Description: Base utilities for charts
Author: S Anand
Latest version: 1.0.4

# @gramex/chartbase

Base utilities for charts

## Example

```js
import { layer, getSVG } from "https://cdn.jsdelivr.net/npm/@gramex/chartbase@1";
// Create a new g.layer under <svg id="chart-svg"> ONLY IF it does not exist
layer(d3.select("svg#chart-svg"), "g", "layer");
// Get the viewBox width and height of <svg id="chart-svg">
const { width, height } = getSVG("svg#chart-svg");
```

## Installation

Install via `npm`:

```bash
npm install @gramex/chartbase
```

Use locally as an ES module:

```html
<script type="module">
  import chartbase from "./node_modules/@gramex/chartbase/dist/chartbase.js";
</script>
```

Use via CDN as an ES Module:

```html
<script type="module">
  import chartbase from "https://cdn.jsdelivr.net/npm/@gramex/chartbase@1";
</script>
```

## API

[See API documentation](docs/api.md ":include :type=markdown")

## Release notes

- 1.0.3: 18 Aug 2024. Security update
- 1.0.2: 24 Nov 2023. Fix `getSVG()` width and height calculation
- 1.0.0: 31 Oct 2023. Initial release

## Authors

Anand S <s.anand@gramener.com>

## License

[MIT](https://spdx.org/licenses/MIT.html)
npm package: @gramex/escomplexity
Description: Cyclomatic complexity calculator for JavaScript projects
Author: Shraddheya Shrivastava
Latest version: 0.0.3

# ES Complexity

`@gramex/escomplexity` measures the cyclomatic complexity of your JavaScript / TypeScript code.

## Usage

In a shell, run:

```sh
npx @gramex/escomplexity
```

To use in your JS code as an API:

```js
import { esComplexity } from "@gramex/escomplexity";
for await (const result of esComplexity(path)) {
  // process result for each file under path
}
```

esComplexity() returns an async iterator that yields results for each file under `path`. Each result is an object with the following keys:

- `path`: the path of the file relative to the `path` argument
- `complexity`: the cyclomatic complexity of the file
- `type`: this can be
  - `"complexity"` if the complexity is calculated
  - `"estimate"` if the file could not be processed, and the complexity is estimated based on lines of code
  - `"total"` if it's the total entry summing up all files
- `error`: the error object when parsing the file. Only if `type` is `"estimate"`.

## Development

To run automated tests and validate the library:

```sh
npm install
npm test
```

To publish, run:

```sh
npm publish
```

Create a `tests/js-<anything>` folder. Add files to test there. Add a `tests/js-<anything>/expected.json` that has the expected output of the test. Run `npm test` to validate the test.
npm package: @grammable/sdk
Description: Grammable SDK is available on npm as @grammable/sdk. This single package contains all components required to build a design editor.
Author: Edward Tanoto
Latest version: 0.1.6

# Grammable SDK

Grammable SDK is available on npm as @grammable/sdk. This single package contains all components required to build a design editor.

```sh
# using yarn
yarn add @grammable/sdk

# using npm
npm install @grammable/sdk
```