open-index/open-npm huggingface dataset:
npm package: @hurtigruten/svelte-table
Description: A simple, sortable svelte table component
Author: Hurtigruten
Latest version: 3.0.8-rc11

# Svelte Table

[Documentation](https://hurtigruten.github.io/svelte-table/)

[Live Demo](https://svelte.dev/repl/235af12d2e8a4d5991a19f77e1cbfd24?version=3.48.0)

## Quick start

```bash
npm i @hurtigruten/svelte-table --save
```

### Simple example

```html
<SvelteTable {rows} {columns} />
```

### Table with custom components

```html
<SvelteTable {rows} {columns} let:cell let:column>
  <span class="text-white bg-gray-800" slot="head">{column.title}</span>
  <span class="flex items-center bg-blue-100" slot="cell">{cell}</span>
</SvelteTable>
```
npm package: @hurum/core
Description: Predictable state management for TypeScript — Intent, Command, Executor, Event, Store
Latest version: 0.0.2

# @hurum/core

> **Warning** — Hurum is in early development (`0.0.x`). APIs may change without notice. Do not use in production yet.

Predictable state management for TypeScript where every state change follows one path:

```
Intent -> Command -> Executor -> Event -> Store.on
```

A counter increment and a complex async API call with retries and error handling go through the exact same pipeline. No shortcuts. No special cases.

## Install

```bash
npm install @hurum/core
```

## Quick Example

```ts
import { Events, Event, Store } from '@hurum/core'

const CounterEvent = Events('Counter', {
  incremented: Event<{ amount: number }>(),
  reset: Event<{}>(),
})

const CounterStore = Store({ state: { count: 0 } })
  .on(CounterEvent, {
    incremented: (state, { amount }) => ({ ...state, count: state.count + amount }),
    reset: () => ({ count: 0 }),
  })
```

## Features

- **Single path** — All state changes flow through Intent -> Command -> Executor -> Event -> Store.on
- **Framework-agnostic** — Zero runtime dependencies, works anywhere TypeScript runs
- **Type-safe** — Full TypeScript inference for state, events, commands, and computed values
- **Testable** — Built-in `@hurum/core/testing` utilities for unit testing stores
- **Nested stores** — Parent-child store composition with event forwarding and bubbling
- **Middleware** — Logger, devtools, persist, undo-redo
- **CJS + ESM** — Dual build, tree-shakeable

## Docs

[hurum.dev](https://hurum.dev)

## License

MIT
npm package: @hurum/react
Description: React bindings for @hurum/core — useStore, StoreProvider, withProvider
Latest version: 0.0.2

# @hurum/react

> **Warning** — Hurum is in early development (`0.0.x`). APIs may change without notice. Do not use in production yet.

React bindings for [`@hurum/core`](https://www.npmjs.com/package/@hurum/core).

## Install

```bash
npm install @hurum/core @hurum/react
```

Requires React 18+.

## API

### `useStore(Definition)`

Access a store instance. Inside a `StoreProvider`, returns the scoped instance. Outside, falls back to a singleton.

```tsx
import { useStore } from '@hurum/react'

function Counter() {
  const store = useStore(CounterStore)
  return <button onClick={() => store.send.increment()}>
    {store.state.count}
  </button>
}
```

### `<StoreProvider>`

Provide a scoped store instance to a subtree.

```tsx
import { StoreProvider } from '@hurum/react'

<StoreProvider of={CounterStore}>
  <Counter />
</StoreProvider>

// or with options
<StoreProvider of={CounterStore} initialState={{ count: 10 }}>
  <Counter />
</StoreProvider>

// or with an existing instance
<StoreProvider of={CounterStore} store={myInstance}>
  <Counter />
</StoreProvider>
```

### `withProvider(Definition, Component)`

HOC that wraps a component with a `StoreProvider`.

```tsx
import { withProvider } from '@hurum/react'

const CounterPage = withProvider(CounterStore, Counter)
```

## Docs

[hurum.dev](https://hurum.dev)

## License

MIT
npm package: @hurx/gitignore-deserializer
Description: Check if a path is ignored by git or not by finding the closest .gitignore file in its directory or in its parent directories.
Author: Stan Hurks
Latest version: 1.0.1

# Gitignore deserializer
by [Hurx (Stan Hurks) 📧](mailto://stan@hurx.digital)

Checks a path to see if it is ignored by any .gitignore files in its directory or its parents directories.

Automatically caches each .gitignore file and uses the cache if the file hasn't been modified since.

## Example
```typescript
import path from 'path'
import Deserializer from '@hurx/gitignore-deserializer'

// Check if a path is ignored
if (Deserializer.isIgnored(path.resolve('node_modules'))) {
    // <...>
}
```

## Made with ♥️

[Buying me a coffee ☕](https://www.buymeacoffee.com/hurx) contributes to making easy to use and efficient software tools and products for free!
npm package: @hurx/regex
Description: A builder for regular expressions
Author: Stan Hurks
Latest version: 1.0.3

# Regex builder
A fully typed, documented and easy to use textmate language grammar builder in Typescript by [Hurx (Stan Hurks) 📧](mailto://stan@hurx.digital)

The documentation and example should give you a basic understanding on how to create a language grammar with text mate.

## Example
```typescript
import path from "path"
import Regex from "@hurx/regex"

// Provide a union type of repository names
type RepositoryNames = 'string'

// Provide a union type of pattern names
type PatternNames = `${
    `constant${
        `.character${
            `.escape`
        }`
    }`|
    `punctuation${
        `.definition${
            `.string${
                `.begin`|
                `.end`|
                `.template${
                    `.begin`|
                    `.end`
                }`
            }`
        }`
    }`|
    `string${
        `.quoted${
            `.double`
        }`|
        `.template`
    }`
}.language-name`

// Make the grammar
Grammar

// Declare the name and included repositories/patterns in the root of your grammar
.root<RepositoryNames, PatternNames>('language-name', '#string')

// Adds a repository to match strings
.repository('string',
    {
        name: 'string.quoted.double.language-name',
        begin: [
            /\"/
        ],
        beginCaptures: {
            1: 'punctuation.definition.string.begin.language-name'
        },
        end: [
            /\"/
        ],
        endCaptures: {
            1: 'punctuation.definition.string.end.language-name'
        },
        children: [
            {
                name: 'constant.character.escape.language-name',
                match: [
                    /\\\"/
                ]
            }
        ]
    },
    {
        name: 'string.template.language-name',
        begin: [
            /\`/
        ],
        beginCaptures: {
            1: 'punctuation.definition.string.template.begin.language-name'
        },
        end: [
            /\`/
        ],
        endCaptures: {
            1: 'punctuation.definition.string.template.end.language-name'
        },
        children: [
            {
                name: 'constant.character.escape.language-name',
                match: [
                    /\\\`/
                ]
            }
        ]
    }
)

// Builds the grammar at the path: /[project root]/language/grammars/[name].tmLanguage.json
.build(path.resolve('./language', 'grammars'))
```

## Made with ♥️

[Buying me a coffee ☕](https://www.buymeacoffee.com/hurx) contributes to making easy to use and efficient software tools and products for free!
npm package: @hurx/textmate-grammar-builder
Description: A grammar builder for text mate languages
Author: Stan Hurks
Latest version: 1.1.0

# Textmate grammar builder
A fully typed, documented and easy to use textmate language grammar builder in Typescript by [Hurx (Stan Hurks) 📧](mailto://stan@hurx.digital)

The documentation and example should give you a basic understanding on how to create a language grammar with text mate.

## Example
```typescript
import path from "path"
import Grammar from "@hurx/textmate-grammar-builder"

// Provide a union type of repository names
type RepositoryNames = 'string'

// Provide a union type of pattern names
type PatternNames = `${
    `constant${
        `.character${
            `.escape`
        }`
    }`|
    `punctuation${
        `.definition${
            `.string${
                `.begin`|
                `.end`|
                `.template${
                    `.begin`|
                    `.end`
                }`
            }`
        }`
    }`|
    `string${
        `.quoted${
            `.double`
        }`|
        `.template`
    }`
}.language-name`

// Make the grammar
Grammar

// Declare the name and included repositories/patterns in the root of your grammar
.root<RepositoryNames, PatternNames>('language-name', '#string')

// Adds a repository to match strings
.repository('string',
    {
        name: 'string.quoted.double.language-name',
        begin: [
            /\"/
        ],
        beginCaptures: {
            1: 'punctuation.definition.string.begin.language-name'
        },
        end: [
            /\"/
        ],
        endCaptures: {
            1: 'punctuation.definition.string.end.language-name'
        },
        children: [
            {
                name: 'constant.character.escape.language-name',
                match: [
                    /\\\"/
                ]
            }
        ]
    },
    {
        name: 'string.template.language-name',
        begin: [
            /\`/
        ],
        beginCaptures: {
            1: 'punctuation.definition.string.template.begin.language-name'
        },
        end: [
            /\`/
        ],
        endCaptures: {
            1: 'punctuation.definition.string.template.end.language-name'
        },
        children: [
            {
                name: 'constant.character.escape.language-name',
                match: [
                    /\\\`/
                ]
            }
        ]
    }
)

// Builds the grammar at the path: /[project root]/language/grammars/[name].tmLanguage.json
.build(path.resolve('./language', 'grammars'))
```

## Made with ♥️

[Buying me a coffee ☕](https://www.buymeacoffee.com/hurx) contributes to making easy to use and efficient software tools and products for free!
npm package: @husam287/adminjs
Description: Admin panel for apps written in node.js
Author: Wojciech Krysiak
Latest version: 6.0.8

# AdminJS

[AdminJS](https://softwarebrothers.github.io/adminjs-dev/) is An automatic admin interface which can be plugged into your application. You, as a developer, provide database models (like posts, comments, stores, products or whatever else your application uses), and AdminJS generates UI which allows you (or other trusted users) to manage content.

Inspired by: [django admin](https://docs.djangoproject.com), [rails admin](https://github.com/sferik/rails_admin) and [active admin](https://activeadmin.info/).

## How it looks

<img src='./docs/anim.gif'>

## Example application

Check out the example application with mongodb and postgres models here:

- login: `test@example.com`
- password: `password`

https://admin-bro-example-app-staging.herokuapp.com/admin/login

## Getting started

- Check out the [documentation](https://adminjs.co)
- Try the [live demo](https://admin-bro-example-app-staging.herokuapp.com/admin/login) as mentioned above

## OpenSource SoftwareBrothers community

- [Join the community](https://join.slack.com/t/adminbro/shared_invite/zt-1c7z4k0v9-kBNAivB8lX3OWLWu6TLE7A) to get help and be inspired.
- subscribe to our [newsletter](http://opensource.softwarebrothers.co)

# What kind of problems it solves

So you have a working service built in Node.js. It uses (for example) [Hapi.js](https://hapijs.com/) for rendering a couple of REST routes and [mongoose](https://mongoosejs.com/) as the _connector_ to the database.

Everything works fine, but now you would like to:
* see all the data in the app,
* perform custom _business_ actions on objects in the database,
* bootstrap the tables with the _initial_ data,
* build custom report pages,
* allow other team members (not necessary programmers) to see what is going on in the application.

And all these cases can be solved by AdminJS. By adding couple of lines of code you have a running admin interface.

# Features

* CRUD any data in any resource
* Custom actions
* Form validation based on schema in your resources
* Full featured dashboard with widgets
* Custom resource decorators

## Contribute

If you would like work on an adminjs and develop new features - take a look at our dev repository: https://github.com/SoftwareBrothers/adminjs-dev

You can find there instructions on how to run adminjs for development.

## License

AdminJS is Copyright © 2021 SoftwareBrothers.co. It is free software, and may be redistributed under the terms specified in the [LICENSE](LICENSE.md) file.

## About SoftwareBrothers.co

<img src="https://softwarebrothers.co/assets/images/software-brothers-logo-full.svg" width=240>

We’re an open, friendly team that helps clients from all over the world to transform their businesses and create astonishing products.

* We are available for [hire](https://softwarebrothers.co/contact).
* If you want to work for us - check out the [career page](https://softwarebrothers.co/career).