open-index/open-npm huggingface dataset:
npm package: @schickling-tmp/react-notion-x
Description: Fast and accurate React renderer for Notion.
Author: Travis Fischer
Latest version: 4.8.7

<p align="center">
  <img alt="React Notion X" src="https://raw.githubusercontent.com/NotionX/react-notion-x/master/media/notion-ts.png" width="689">
</p>

# React Notion X

> Fast and accurate React renderer for Notion.

[![NPM](https://img.shields.io/npm/v/react-notion-x.svg)](https://www.npmjs.com/package/react-notion-x) [![Build Status](https://travis-ci.com/NotionX/react-notion-x.svg?branch=master)](https://travis-ci.com/NotionX/react-notion-x) [![Prettier Code Formatting](https://img.shields.io/badge/code_style-prettier-brightgreen.svg)](https://prettier.io)

## Install

```bash
npm install react-notion-x
```

## Usage

First you'll want to fetch the content for a Notion page:

```ts
import { NotionAPI } from '@schickling-tmp/notion-client'

const api = new NotionAPI()

// fetch the page's content, including all async blocks, collection queries, and signed urls
const recordMap = await api.getPage('067dd719a912471ea9a3ac10710e7fdf')
```

Once you have the data for a Notion page, you can render it:

```tsx
import React from 'react'
import { NotionRenderer } from 'react-notion-x'

export default ExampleNotionPage({ recordMap }) => (
  <NotionRenderer
    recordMap={recordMap}
    fullPage={true}
    darkMode={false}
  />
)
```

## Styles

You'll need to import some CSS styles as well. If you're using Next.js, we recommend you put these in `pages/_app.js`:

```ts
// core styles shared by all of react-notion-x (required)
import 'react-notion-x/src/styles.css'

// used for code syntax highlighting (optional)
import 'prismjs/themes/prism-tomorrow.css'

// used for collection views (optional)
import 'rc-dropdown/assets/index.css'

// used for rendering equations (optional)
import 'katex/dist/katex.min.css'
```

## License

MIT © [Travis Fischer](https://transitivebullsh.it)

Support my OSS work by <a href="https://twitter.com/transitive_bs">following me on twitter <img src="https://storage.googleapis.com/saasify-assets/twitter-logo.svg" alt="twitter" height="24px" align="center"></a>
npm package: @schickling-tmp/stackbit-sdk
Description: Stackbit SDK
Author: Stackbit Inc.
Latest version: 0.5.6-staging.2

# Stackbit SDK

Stackbit SDK contains set of utilities to work with stackbit.yaml file. 


## Add to your project

```bash
npm install @stackbit/sdk
```


## Generate stackbit.yaml

Create a `FileBrowser` with `FileSystemFileBrowserAdapter` or `GitHubFileBrowserAdapter`:

- Analyzing a local project:

    ```js
    import { FileSystemFileBrowserAdapter, FileBrowser } from '@stackbit/sdk';
  
    const fileBrowserAdapter = new FileSystemFileBrowserAdapter({ dirPath: inputDir });
    const fileBrowser = new FileBrowser({ fileBrowserAdapter });
    ```

- Analyzing a remote GitHub project:

    ```js
    import { GitHubFileBrowserAdapter, FileBrowser } from '@stackbit/sdk';
  
    const fileBrowserAdapter = new GitHubFileBrowserAdapter({
        owner: 'stackbit',
        repo: 'theme',
        branch: 'master',
        auth: GITHUB_PERSONAL_ACCESS_TOKEN
    });
    const fileBrowser = new FileBrowser({ fileBrowserAdapter });
    ```

Then, pass the `fileBrowser` to the `analyzeSite()` method, get the result and save the `config` as `stackbit.yaml`:

```js
import { writeConfig, analyzeSite } from '@stackbit/sdk';

const analyzeResult = await analyzeSite({ fileBrowser });
await writeConfig({ dirPath: inputDir, config: analyzeResult.config });
```


## Validate stackbit.yaml

Load and validate `stackbit.yaml`. Any errors will be returned within the `errors` array.

```js
import { loadConfig } from '@stackbit/sdk';

const configResult = await loadConfig({ dirPath: inputDir });

configResult.errors.forEach((error) => {
    console.log(error.message);
});
```

If `configResult.config` is not null, pass it to load and validate web-site's content. Any errors will be returned within the `errors` array, and loaded content within the `contentItems`:

```js
import { loadContent } from '@stackbit/sdk';

if (configResult.config) {
    return;
}

const contentResult = await loadContent({ dirPath: inputDir, config: configResult.config });

contentResult.contentItems.forEach((contentItem) => {
    console.log(contentItem.__metadata.filePath);
});

contentResult.errors.forEach((error) => {
    console.log(error.message);
});
```
npm package: @schickling-tmp/vite
Description: Native-ESM powered web dev build tool
Author: Evan You
Latest version: 4.4.9-dev.0

# vite ⚡

> Next Generation Frontend Tooling

- 💡 Instant Server Start
- ⚡️ Lightning Fast HMR
- 🛠️ Rich Features
- 📦 Optimized Build
- 🔩 Universal Plugin Interface
- 🔑 Fully Typed APIs

Vite (French word for "fast", pronounced `/vit/`) is a new breed of frontend build tool that significantly improves the frontend development experience. It consists of two major parts:

- A dev server that serves your source files over [native ES modules](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules), with [rich built-in features](https://vitejs.dev/guide/features.html) and astonishingly fast [Hot Module Replacement (HMR)](https://vitejs.dev/guide/features.html#hot-module-replacement).

- A [build command](https://vitejs.dev/guide/build.html) that bundles your code with [Rollup](https://rollupjs.org), pre-configured to output highly optimized static assets for production.

In addition, Vite is highly extensible via its [Plugin API](https://vitejs.dev/guide/api-plugin.html) and [JavaScript API](https://vitejs.dev/guide/api-javascript.html) with full typing support.

[Read the Docs to Learn More](https://vitejs.dev).
npm package: @schiffy/template.js
Description: template.js is a very simple templating engine.
Latest version: 0.1.4

# template.js
template.js is a templating engine for websites. It can copy html from one file to another; it can also evaluate javascript and include its output in another file. 

## Usage
Templates are included by a filename enclosed in brackets.

`index.template.html`
```
<body>
	[header.html]
	<h1>Hello, World</h1>
	[images.js]
</body>
```

`header.html`
```
<div class="navbar">...</div>
```

`images.js`
```
exports.main = function(currentPath) {
	let fs = require('fs');

	var html = [];
	html.push("<div class=\"grid\">");
	fs.readdirSync("img/").forEach(file => {
		let src = `img/${file.toString()}`;
		let img = `\t\t<img src="${src}"/>`;
		html.push(img);
	})
	html.push("\t</div>")
	return html.join('\n');
}
```

To evaluate the templates and build the output:

```
node template.js index.template.html index.html
```

`index.html`
```
<body>
	<div class="navbar">...</div>
	<h1>Hello, World</h1>
	<div class="grid>
		<img src=.../>
	</div>
</body>

```
npm package: @schilderlabs/pitown
Description: Globally installable CLI for Pi Town
Latest version: 0.2.7

# @schilderlabs/pitown

The installable Pi Town CLI.

Pi Town is an experimental orchestration tool for Pi.

## Credits

Pi Town is built on top of Pi. Credit to [Mario Zechner](https://github.com/badlogic) and the Pi project for the underlying coding agent runtime Pi Town orchestrates.

Pi Town was also inspired by [Gastown](https://github.com/steveyegge/gastown). Credit to [Steve Yegge](https://github.com/steveyegge) for pushing on multi-agent orchestration ideas that made this project worth exploring.

For the full project overview, roadmap, and architecture context, see the main repo:

- https://github.com/schilderlabs/pitown

## Install

```bash
npm install -g @schilderlabs/pitown
npm install -g @mariozechner/pi-coding-agent
```

`pitown run` requires Pi to be installed and authenticated.
Verify Pi first:

```bash
pitown doctor
pi -p "hello"
```

## Usage

```bash
pitown --help
pitown
pitown mayor
pitown mayor "plan the next milestones"
pitown run --repo /path/to/repo --plan /path/to/private/plans --goal "continue from current scaffold state"
pitown status
```

If you are already inside a repo, `pitown` and `pitown mayor` use the current working repo by default.

The main workflow is:

1. `cd` into a repo
2. run `pitown` or `pitown mayor`
3. use `/plan` inside the mayor session when you want a read-only plan first
4. use `pitown board`, `pitown peek mayor`, or `pitown msg mayor "..."` as needed

Inside the mayor session:

- `/plan` toggles read-only planning mode
- `/todos` shows the captured numbered plan
- leaving `/plan` returns the mayor to normal execution and delegation mode

## Runtime storage

By default, Pi Town stores local runtime state under `~/.pi-town` and keeps private plans outside the target repo.
npm package: @schimufa/design-system
Description: Configurable design system with versioned components
Author: Your Organization
Latest version: 5.2.0

# Design System

A configurable and version-controlled design system for modern web applications.

## Features

- 🎨 Configurable themes
- 📦 Version-controlled components
- 🔧 Built with React & Material-UI
- 📱 Responsive and accessible components
- 🧪 Fully tested components
- 📚 Storybook documentation

## Installation

```bash
pnpm add @schimufa/design-system
```

## Quick Start

```tsx
import { ThemeProvider } from '@mui/material/styles';
import { Button, getTheme } from '@schimufa/design-system';

function App() {
  return (
    <ThemeProvider theme={getTheme('default')}>
      <Button variant="contained">Hello World!</Button>
    </ThemeProvider>
  );
}
```

## Development

1. Start Storybook:

```bash
# From the design system package directory
pnpm storybook

# Or from the root directory
pnpm turbo storybook
```

2. Create new components in `src/components`

3. Add stories in `src/stories`

4. Document changes with changesets:

```bash
pnpm changeset
```

## Themes

The design system supports customizable themes:

```tsx
import { getTheme } from '@schimufa/design-system';

// Use with ThemeProvider
<ThemeProvider theme={getTheme('default')}>
  {/* Your app content */}
</ThemeProvider>;
```

## Component Versioning

Components are versioned using changesets. To update versions:

1. Make your changes
2. Create a changeset: `pnpm changeset`
3. Commit changes
4. Version will be updated automatically by CI

## Contributing

Please read our [Contributing Guide](../../CONTRIBUTING.md) for details on our code of conduct and the process for submitting pull requests.

## License

Private - Internal Use Only
npm package: @schirkan/bring-api
Description: API for https://getbring.com shopping list
Author: Martin Pietschmann
Latest version: 0.1.0

# bring-api

```javascript
import { BringApi } from "@schirkan/bring-api";

const options = { username: "your@mail", password: "secret" };
const bring = new BringApi(options);
const list = await bring.getDefaultList();
console.debug(list.items);
```
npm package: @schirrel/footer-stick-observable
Description: A helper to listen when a position:sticky at bottom is stuck
Author: @schirrel
Latest version: 1.0.1

# footer-stick-observable

A helper to listen to `position:sticky` when used for bottom, when it is stuck or not

## Install

- ` npm install @schirrel/footer-stick-observable`

### Usage

Have your position:sticky at bottom identified

```html
<style>
  .my-sticky-footer {
    bottom: 0;
    position: sticky;
  }
</style>
<footer class="my-sticky-footer"></footer>
```

Import the observe functions from the lib

- `import { observe } from '@schirrel/footer-stick-observable'`

```js
observe({
  selector: ".my-sticky-footer",
  callback: ({ isStuck }) => {},
});
```
npm package: @schirrel/module-federation-enhanced-plugin
Description: Add feature for improve load and offline management of remotes
Author: @schirrel
Latest version: 2.0.2

# ModuleFederationEnhacedPlugin
Module Federation with a little bit more and all remotes async by default

Take a look at the full [docs](https://schirrel.dev/ModuleFederationEnhancedPlugin/)


Dont want o read the docs? Here's a TL/DR:

## Features
- Modules' Name List
- Remotes' Name List
- Remotes' URL List and Map
- Remote definition with object
- Default async 


## Install
```sh
npm i @schirrel/module-federation-enhanced-plugin
```

## Config
```js
const ModuleFederationEnhacedPlugin = require("@schirrel/module-federation-enhanced-plugin");
module.export = {
  //... rest of your config
  plugins: [
    new ModuleFederationEnhancedPlugin({
    // same as the ModuleFederationPlugin config
      exposes: {
        Button: "./src/Button",
        Input: "./src/Input"
      },
    }),
  ],
};
```

# Disclaimer
The need of these features is part of my Master Degree with Embrapa at UFMS, and so them must to be like are writen here.
Also some of these features will be present or are being proposed to the oficial Enhanced module federation plugin.  
You can take a look at:
- https://github.com/schirrel/enhanced
- https://github.com/module-federation/enhanced/pull/2
npm package: @schirrel/module-federation-enhanced-plugin-helper
Description: A helper to dynamic load remotes and modules
Author: @schirrel
Latest version: 2.0.2

# Dynamic Load

Utilities for dynamic load content for remotes, if you need to pre initialize it (in case of offline PWA for example)

## Install

```sh
npm i @schirrel/module-federation-enhanced-plugin-helper
```

## Usage

```js
import {
  loadRemoteAndModules,
  getModule,
} from "@schirrel/module-federation-enhanced-plugin-helper";

loadRemoteAndModules();

const module = getModule({ remote: "myApp", module: "./Component" });
```

## Features

### loadRemoteAndModules

This function load all needed and available for consumption, step:

- Get `remoteUrlMap` to know remotes
- Dynamic register by calling `getModule`
- List all remotes available for consumption using `moduleNameList` for each remote
- Load all modules for each remote
- Return all modules the app-shell, root-remote.

The scenario where we built this uppon was a scenario where the app shell only have remotes that only exposes what it is needed here. In our screnario, we need to offline install a PWA and cache all features, include remotes.
As many of then where being used im some sort of "lazy chunk load", "manualy" deal with ensure all ealy registration was being a pain.

With `dynamicLoad` we ensure all files needs for remotes are laoded and cached.

### getModule

Load a module from a remote using low level API, once dynamic import `impot()` dont work with dynamic passed names, as can bee read about [here](https://github.com/module-federation/module-federation-examples/issues/1323)
npm package: @schirrel/request
Description: A simple wrapper for fetch api
Author: @schirrel
Latest version: 1.3.0

# Request
A simple promise based and single file wrapper for newers to start using Fetch API.

For those who dont want a big library to simple requests, and yet want to simplify the fetch use.

[![npm version](https://badge.fury.io/js/%40schirrel%2Frequest.svg)](https://badge.fury.io/js/%40schirrel%2Frequest)

## Installing

Just import the `Request.js` file or run `npm i @schirrel/request`.

## Examples

See [Example Folder](https://github.com/schirrel/request/tree/master/docs)

#### GET

```javascript
Request.get("https://jsonplaceholder.typicode.com/todos/1")
.then((res) => {})
.catch((err) => {});

```
#### POST
```javascript
Request.post('https://jsonplaceholder.typipre.com/posts', {
    body: {
        title:'Ahoy'
    }
})
.then((res) => {})
.catch((err) => {});

```
#### PUT
```javascript
Request.put('https://jsonplaceholder.typicode.com/posts/1', {
body: {
   id:1,
   title:'Ahoy'
    }
 })
.then((res) => {})
.catch((err) => {});

```
#### DELETE
```javascript
Request.delete('https://jsonplaceholder.typicode.com/posts/1')
.then((res) => {})
.catch((err) => {});

```


For a http client you can also check [api-request](https://github.com/schirrel/api-request) current under development
npm package: @schisma/nh
Description: npm helpers
Author: Jona Hugger
Latest version: 0.3.1

# nh

[![NPM](https://nodei.co/npm/nh.png)](https://nodei.co/npm/nh/)

nh is a wrapper around the `npm` API, designed to make installing and updating packages a breeze.

See the docs at http://nh.readthedocs.org