open-index/open-npm huggingface dataset:
npm package: @shettysamarth/component-library
Description: Personal Storybook Library
Author: samarth
Latest version: 0.1.5

# Storybook design system tutorial

The Storybook design system tutorial is a subset of the full [Storybook design system](https://github.com/storybookjs/design-system/), created as a learning resource for those interested in learning how to write and publish a design system using best in practice techniques.

Learn more in [Storybook tutorials](https://storybook.js.org/tutorials/).

// "homepage": "https://github.com/perpetualmotion/ant-storybook#readme"
<!-- "bugs": {
    "url": "https://github.com/perpetualmotion/ant-storybook/issues"
  } -->
npm package: @shevernitskiy/persistent-object
Description: Every mutation of the object synced to storage
Author: shevernitskiy
Latest version: 1.2.0

# JS/TS Persistent object

This tiny function provide persistences for json serializable object. It's possible with using proxy and set/get
callbacks. Everytime you mutate the object, it calls defined `save` callback. Default value needed for deep nesting
support.

## Example

Example with storage in simple json file.

```ts
import { persistent } from "https://deno.land/x/persistent@v1.2.0/mod.ts";

type Schema = {
  name: string;
  age: number;
  job: {
    salary: number;
  };
};

const path = "./state.json";
const defaults: Schema = {
  name: "",
  age: 0,
  job: {
    salary: 0,
  },
};

const state = await persistent<Schema>(defaults, {
  read: () => {
    let data: Schema = defaults;
    try {
      data = JSON.parse(Deno.readTextFileSync(path));
    } catch {
      //
    }
    return data;
  },
  save: (value: Schema) => Deno.writeTextFileSync(path, JSON.stringify(value, null, 2)),
}); // read json from path and return proxyfied object

state.job.salary = 35; // saved with provided callback
```

# Contribution

Pull request, issues and feedback are very welcome. Code style is formatted with `deno fmt`.

# License

Copyright 2023, shevernitskiy. MIT license.
npm package: @shevernitskiy/post-calculator
Description: RussianPost calculator API client
Author: shevernitskiy
Latest version: 0.1.3

# 📦RussianPost calculator API client

[![npm](https://img.shields.io/npm/v/@shevernitskiy/post-calculator?logo=npm&style=flat&labelColor=000)](https://www.npmjs.com/package/@shevernitskiy/post-calculator)
[![JSR](https://jsr.io/badges/@shevernitskiy/post-calculator)](https://jsr.io/@shevernitskiy/post-calculator)
![dependencies](https://img.shields.io/badge/dependencies-0-green?style=flat&labelColor=000)
[![license](https://img.shields.io/github/license/shevernitskiy/post-calculator?style=flat&labelColor=000)](https://github.com/shevernitskiy/post-calculator/blob/main/LICENSE)

This is super simple typed API client for RussianPost Calculator API.
It just fetch calculator response from the API.

# Installation

## Node.js

```sh
npm i @shevernitskiy/post-calculator
```

```sh
npx jsr add @shevernitskiy/post-calculator
```

## Deno

```sh
deno add @shevernitskiy/post-calculator
```

# Usage

Call the `postCalculator` function with the required parameters (typed as well).

```ts
import { postCalculator } from "@shevernitskiy/post-calculator";

const result = await postCalculator({
  object: 27030,
  from: 115211,
  to: 620000,
  weight: 1000,
});

// result will be typeof PostCalcResponse (typed json)

const result2 = await postCalculator({
  format: "html",
  object: 27030,
  from: 115211,
  to: 620000,
  weight: 1000,
});

// result2 will be typeof string
```

# Contribution

Pull request, issues and feedback are very welcome. Code style is formatted with deno fmt.

# License

Copyright 2024, shevernitskiy. MIT license.
npm package: @shevernitskiy/post-tracking
Description: RussianPost tracking API client
Author: shevernitskiy
Latest version: 0.1.2

# 📦RussianPost tracking API client

[![npm](https://img.shields.io/npm/v/@shevernitskiy/post-tracking?logo=npm&style=flat&labelColor=000)](https://www.npmjs.com/package/@shevernitskiy/post-tracking)
[![JSR](https://jsr.io/badges/@shevernitskiy/post-tracking)](https://jsr.io/@shevernitskiy/post-tracking)
![dependencies](https://img.shields.io/badge/dependencies-0-green?style=flat&labelColor=000)
[![license](https://img.shields.io/github/license/shevernitskiy/amo?style=flat&labelColor=000)](https://github.com/shevernitskiy/post-tracking/blob/main/LICENSE)

This is super simple API client for RussianPost Traking API.
It just fetch the tracking history from the API.

# Installation

## Node.js

```sh
npm i @shevernitskiy/post-tracking
```

```sh
npx jsr add @shevernitskiy/post-tracking
```

## Deno

```sh
deno add @shevernitskiy/post-tracking
```

# Usage

Create an instance and call method `tracking`. That's it.

```ts
const client = new PostTracking("your_login", "your_password");
const history = await client.tracking(1116949696969);
console.log(history);
```

You can pass `options` object as a third argument.

```ts
const client = new PostTracking("your_login", "your_password", { language: "ENG" });
```

As as result you will get the history:

```js
{
  history: [
    {
      index: 111024,
      place: "Москва 24",
      operation_type: "Прием",
      operation_desc: "Единичный",
      datetime: 2024-07-10T10:31:41.000Z
    },
    {
      index: 111024,
      place: "Москва 24",
      operation_type: "Обработка",
      operation_desc: "Покинуло место приёма",
      datetime: 2024-07-10T13:08:20.000Z
    },
    {
      index: 111974,
      place: "Москва МСП-3 Цех-4 МПКО-Восток",
      operation_type: "Обработка",
      operation_desc: "Прибыло в сортировочный центр",
      datetime: 2024-07-10T14:18:07.001Z
    },
    {
      index: 111974,
      place: "Москва МСП-3 Цех-4 МПКО-Восток",
      operation_type: "Обработка",
      operation_desc: "Сортировка",
      datetime: 2024-07-10T14:32:54.000Z
    }
  ],
  last_operation: "Обработка",
  duration: 434992
}
```

# Contribution

Pull request, issues and feedback are very welcome. Code style is formatted with deno fmt.

# License

Copyright 2024, shevernitskiy. MIT license.
npm package: @shevi/logger
Description: A pluggable logging utility for frontend developers.
Author: Brion Mario
Latest version: 0.1.0

<p align="center" style="color: #343a40">
  <h1 align="center">@shevi/logger 💖</h1>
</p>

<p align="center" style="font-size: 1.2rem;">A
<strong style="color: #F0F">pluggable</strong>
 logging utility for frontend developers.</p>
 
<div align="center">
  <img alt="npm (scoped)" src="https://img.shields.io/npm/v/@shevi/logger">
  <img alt="npm" src="https://img.shields.io/npm/dw/@shevi/logger">
  <a href="./LICENSE"><img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg" alt="License"></a>
</div>

## Installation

To install `@shevi/logger`, run the following command:

```sh
# With npm
npm install @shevi/logger

# With pnpm
pnpm add @shevi/logger

# With yarn
yarn add @shevi/logger
```

## Usage

Here's an example of how to use `@shevi/logger`:

### Basic Usage

```ts
import Logger from '@shevi/logger';

// Initialize the logger
const logger = new Logger({
  level: 'info', // Logging level (e.g., 'info', 'warn', 'error')
  prefix: '[App]', // Optional prefix for each log message
  format: 'json',  // Optional format (e.g., 'text', 'json')
});

// Log messages at different levels
logger.info('This is an info message');
logger.warn('This is a warning message');
logger.error('This is an error message');

// Example with dynamic data
logger.info('User logged in', { userId: '1234' });
```

### Advanced Usage with Plugins

You can extend the logger by adding custom plugins. Here's how you can add a plugin to handle log storage:

```ts
import Logger from '@shevi/logger';

// Define a custom plugin
const customPlugin = {
  handle(log) {
    // Save the log to a database or send it to an external service
    console.log('Custom plugin handling log:', log);
  },
};

// Initialize the logger with the plugin
const logger = new Logger({
  plugins: [customPlugin],
});

// Log a message
logger.info('This log will be handled by the custom plugin');
```

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
npm package: @shevky/base
Description: Shared base utilities and types for Shevky core and plugins.
Author: Fatih Tatoğlu
Latest version: 0.0.5

# @shevky/base

Shared base utilities and types used across Shevky core and plugins.

## What is this?

This package provides small, stable utilities and shared TypeScript types
that other Shevky packages depend on. It is published as ESM and includes
type definitions.

## Install

```bash
npm install @shevky/base
```

## Usage

```js
import { plugin } from "@shevky/base";

// schema helpers
plugin.isSchemaType("job-listing"); // true
plugin.schema.JOB_LISTING; // "job-listing"
```

## Plugin API Quick Reference

- Hooks: `dist:clean`, `assets:copy`, `content:load`, `content:ready`, `page:meta`
- Schema types:
  - `post`
  - `job-post`
  - `job-listing`
  - `page`
  - `home`
  - `about`
  - `contact`
  - `help`
  - `faq`
  - `press`
  - `collection`
  - `policy`
- Collection types: `tag`, `category`, `series`

## License

MIT
npm package: @shevky/core
Description: A minimal, dependency-light static site generator.
Author: Fatih Tatoğlu
Latest version: 0.0.10

# shevky

![Shevky Process Flow](https://tatoglu.net/assets/images/shevky-process-flow.webp)

A minimal, dependency-light static site generator.

## Quick Start

For the quick start you should execute the following commands.

```bash
npm init -y
npm install --save-dev shevky
npm install

npx shevky --init
```

The system provides a simple blog for you. Then you can build with following commands.

```bash
npm run build
npm run dev
```

## Build Memory Setting

For large projects you can limit in-memory page buffering during build:

```json
{
  "build": {
    "pageBufferLimit": 20
  }
}
```

- `pageBufferLimit`: Number of rendered pages kept in memory before flushing to disk.
- Default: `20`
- Environment override: `SHEVKY_PAGE_BUFFER_LIMIT`

## Output Aliases

If you want to keep markdown generation (plugins/layout/meta) but publish an
additional file path, you can define build aliases:

```json
{
  "build": {
    "outputAliases": [
      { "from": "~/404/", "to": "~/404.html" },
      { "from": "~/en/404/", "to": "~/en/404.html" }
    ]
  }
}
```

- `from`: Generated page URL/path.
- `to`: Extra copied output URL/path.

## Content Root Directories

You can copy selected `src/content` directories directly to dist root:

```json
{
  "build": {
    "contentRootDirectories": [".well-known"]
  }
}
```

- Default: `[".well-known"]`
- Example: `src/content/.well-known/apple-app-site-association` -> `dist/.well-known/apple-app-site-association`

## Technical Documentation

The tech documentation is preparing for Shevky with Shevky. You will find it under [Shevky Project](https://tatoglu.net/project/shevky) page.
npm package: @shevky/plugin-esbuild
Description: Shevky plugin that runs esbuild during builds.
Author: Fatih Tatoğlu
Latest version: 0.0.3

# Shevky Plugin: esbuild

A simple Shevky plugin that runs esbuild during builds and outputs the bundled assets.

## Features

- Bundles `src/js/app.js` into `dist/output.js`
- Uses ESM output targeting `es2018`
- Minifies output when `build.minify` is enabled
- Drops `console` and `debugger` statements in minified builds
- Generates sourcemaps in minified builds

## Installation

```bash
npm i shevky-esbuild
```

## Usage

Add the plugin to your Shevky config:

```json
{
  "plugins": [
    "shevky-esbuild"
  ]
}
```

If you enable `build.minify`, the bundled output is minified, console/debugger statements are dropped, and sourcemaps are generated.

```json
{
  "build": {
    "minify": true
  }
}
```

## License

MIT
npm package: @shevky/plugin-robots-txt
Description: Shevky plugin that generates robots.txt during builds.
Author: Fatih Tatoğlu
Latest version: 0.0.3

# Shevky Plugin: Robots.txt

A simple Shevky plugin that generates `robots.txt`. It runs on the `dist:clean` hook, uses allow/disallow lists from the config, and adds a `Sitemap` line based on the site root URL.

## Features

- Automatically generates `robots.txt`
- Reads `Allow` and `Disallow` rules from config
- Writes `Sitemap` as `<site-url>/sitemap.xml`

## Installation

```bash
npm i shevky-robots-txt
```

## Usage

The example config below uses `identity.url`, `robots.allow`, and `robots.disallow`:

```json
{
  "identity": {
    "url": "https://example.com",
  },
  "robots": {
    "allow": ["/", "/blog/"],
    "disallow": ["/admin/", "/private/"],
  },
  "plugins": [
    "shevky-robots-txt",
  ],
}
```

Example generated `robots.txt` output:

```text
User-agent: *
Allow: /
Allow: /blog/
Disallow: /admin/
Disallow: /private/

Sitemap: https://example.com/sitemap.xml
```

## License

MIT
npm package: @shevky/plugin-rss
Description: Shevky plugin that generates RSS feeds during builds.
Author: Fatih Tatoğlu
Latest version: 0.0.4

# Shevky Plugin: RSS

Generate RSS 2.0 feeds for Shevky sites. The plugin scans content files, applies RSS filters, builds feed items, and writes `feed.xml` to the `dist` folder (and per-language feeds when i18n is enabled).

## Features

- Builds `feed.xml` during `content:ready`
- Supports multilingual feeds (`/tr/feed.xml`, etc.)
- Uses post title, description, dates, categories, and tags
- Adds Atom self/alternate links and basic metadata
- Supports schema/category-based filtering via plugin config

## Installation

```bash
npm i @shevky/plugin-rss
```

## Usage

Add the plugin to your config:

```json
{
  "identity": {
    "url": "https://example.com",
    "author": "Jane Doe",
    "email": "jane@example.com"
  },
  "pluginConfigs": {
    "shevky-rss": {
      "feedFilename": "feed.xml",
      "feedTtl": 1440,
      "feedItemCount": 50,
      "includedSchemaTypes": ["post", "job-post"],
      "includedCategories": ["engineering", "career"]
    }
  },
  "plugins": [
    "@shevky/plugin-rss"
  ]
}
```

The feed will be generated at:

```txt
dist/feed.xml
```

With i18n enabled, each language gets its own feed:

```txt
dist/tr/feed.xml
dist/en/feed.xml
```

To enable i18n feeds, configure `content.languages` in `site.json`:

```json
{
  "content": {
    "languages": {
      "default": "tr",
      "supported": ["tr", "en"]
    }
  }
}
```

The feed output path is derived from each language’s `canonical` URL in `content.languages.canonical`. If a canonical base is set for a language, the feed URL follows it (e.g. `/en/` -> `/en/feed.xml`).

### Config Options

- `feedFilename`: Output file name (default: `feed.xml`)
- `feedTtl`: RSS TTL value in minutes (default: `1440`)
- `feedItemCount`: Max items per feed (default: no limit)
- `includedSchemaTypes`: Schema type allow-list. Default is `["post", "job-post"]`. If provided, only listed schema types are included.
- `includedCategories`: Optional category allow-list. If provided, only listed categories are included after schema filtering.

### Filtering Rules

1. `isPublished` must be `true` (always required).
2. `schemaType` must match `includedSchemaTypes`.
3. If `includedCategories` exists, `category` must match this list.

## License

MIT
npm package: @shevky/plugin-sitemap
Description: Shevky plugin that generates sitemap.xml during builds.
Author: Fatih Tatoğlu
Latest version: 0.0.4

# Shevky Plugin: Sitemap

Generate `sitemap.xml` for Shevky sites. The plugin collects published pages, optionally includes paginated listings and configured collections, then writes the sitemap into `dist/sitemap.xml`.

## Features

- Builds `sitemap.xml` during `content:ready`
- Optional pagination URLs (when `seo.includePaging` is enabled)
- Optional collection URLs (when `seo.includeCollections` is enabled)
- Generates absolute URLs based on `identity.url`

## Installation

```bash
npm i @shevky/plugin-sitemap
```

## Usage

Add the plugin to your config:

```json
{
  "identity": {
    "url": "https://example.com"
  },
  "pluginConfigs": {
    "shevky-sitemap": {
      "sitemapFilename": "sitemap.xml"
    }
  },
  "seo": {
    "includePaging": true,
    "includeCollections": true
  },
  "plugins": [
    "@shevky/plugin-sitemap"
  ]
}
```

The sitemap will be generated at:

```txt
dist/sitemap.xml
```

### Config Options

- `sitemapFilename`: Output file name (default: `sitemap.xml`)

## License

MIT
npm package: @shevky/plugin-tailwindcss
Description: Shevky plugin that runs Tailwind CSS during builds.
Author: Fatih Tatoğlu
Latest version: 0.0.5

# Shevky Plugin: Tailwind CSS

A simple Shevky plugin that runs Tailwind CSS during builds and outputs the compiled styles into your site assets.

## Features

- Runs Tailwind CSS during build
- Outputs compiled CSS to your site assets
- Works with your existing Tailwind config

## Installation

```bash
npm i shevky-tailwindcss
```

## Usage

Add the plugin to your Shevky config:

```json
{
  "plugins": [
    "shevky-tailwindcss"
  ]
}
```

If you enable `build.minify`, the generated CSS output is minified as well.

```json
{
  "build": {
    "minify": true
  }
}
```

## License

MIT
npm package: @shevsky/cache-deferred
Description: ## Example
Author: Konstantin Shevsky
Latest version: 2.0.0

# Method decorator to cache promises

## Example

```typescript
import { CacheDeferred } from '@shevsky/cache-deferred';

class Foo {
  private counter: number = 0;

  @CacheDeferred
  getDeferredValue(): Promise<number> {
    return this.resolveDeferredValue();
  }

  private resolveDeferredValue(): Promise<number> {
    return Promise.resolve(++this.counter);
  }
}

const foo = new Foo();

foo.getDeferredValue().then(console.log); // 1
foo.getDeferredValue().then(console.log); // 1
```

# Reset cache

```typescript
import { CacheDeferred } from '@shevsky/cache-deferred';

class Foo {
  counter: number = 0;
  
  @CacheDeferred.Reset('getDeferredValue')
  reset(): void {
    console.log('Called reset');
  }

  @CacheDeferred
  getDeferredValue(): Promise<number> {
    return this.resolveDeferredValue();
  }

  private resolveDeferredValue(): Promise<number> {
    return Promise.resolve(++this.counter);
  }
}

const foo = new Foo();

foo.getDeferredValue().then(console.log); // 1
foo.getDeferredValue().then(console.log); // 1
foo.reset();
foo.getDeferredValue().then(console.log); // 2
foo.getDeferredValue().then(console.log); // 2
```
npm package: @shevsky/di
Description: ## Example
Author: Konstantin Shevsky
Latest version: 1.0.1

# Simple dependency injection for classes via decorators

## Example

```typescript
import { Autowired, Inject, Injectable } from '@shevsky/di';

@Injectable
class Foo {
  @Inject('123')
  value: string;
  
  getValue(): string {
    return this.value;
  }
}

class Bar {
  @Autowired
  readonly foo: Foo;
  
  getFooValue(): string {
    return this.foo.getValue();
  }
}

console.log(new Bar().getFooValue()); // '123'
```

## Usage with functions

```typescript
import { provider, Inject, Injectable } from '@shevsky/di';

@Injectable
class Foo {
  @Inject('123')
  value: string;

  getValue(): string {
    return this.value;
  }
}

function getFooValue(): string {
  return provider.resolveDependency(Foo).getValue();
}

console.log(getFooValue()); // '123'
```

## With custom provider

```typescript
import { Autowired, Provider, Target, Inject, Injectable } from '@shevsky/di';

const customProvider = new Provider();
const anotherCustomProvider = new Provider();

@Injectable
@Target(customProvider)
class FooCustomProvided {

}

@Injectable
@Target(anotherCustomProvider)
class FooAnotherCustomProvided {

}

@Target(customProvider)
class BarCustomProvided {
  @Autowired
  foo: FooCustomProvided;
}

@Target(anotherCustomProvider)
class BarAnotherCustomProvided {
  @Autowired
  foo: FooAnotherCustomProvided;
}

console.log(customProvider.getDependencies()); // [instanceof FooCustomProvided]
console.log(anotherCustomProvider.getDependencies()); // [instanceof FooAnotherCustomProvided]
```
npm package: @shevsky/via-portal
Description: ## Example
Author: Konstantin Shevsky
Latest version: 1.0.1

# Wrap components to portal

## Example

```typescript jsx
import { viaPortal } from '@shevsky/via-portal';
import React, { PropsWithChildren } from 'react';

type TFooProps = PropsWithChildren<{}>;

export const Foo = viaPortal((props: TFooProps): JSX.Element => {
  return (
    <div className="foo">
      {props.children}
    </div>
  );
}, 'foo'); // Would be rendered to <div data-foo-portal/> at the end of <body/>
```
npm package: @shewaberr/cz-conventional-changelog
Description: Commitizen adapter following the conventional-changelog format.
Author: Simon Belete
Latest version: 0.0.0-semantically-released.0

# cz-conventional-changelog

[![Greenkeeper badge](https://badges.greenkeeper.io/commitizen/cz-conventional-changelog.svg)](https://greenkeeper.io/)

Status:
[![npm version](https://img.shields.io/npm/v/cz-conventional-changelog.svg?style=flat-square)](https://www.npmjs.org/package/cz-conventional-changelog)
[![npm downloads](https://img.shields.io/npm/dm/cz-conventional-changelog.svg?style=flat-square)](http://npm-stat.com/charts.html?package=cz-conventional-changelog&from=2015-08-01)
[![Build Status](https://img.shields.io/travis/commitizen/cz-conventional-changelog.svg?style=flat-square)](https://travis-ci.org/commitizen/cz-conventional-changelog)

Part of the [commitizen](https://github.com/commitizen/cz-cli) family. Prompts for [conventional changelog](https://github.com/conventional-changelog/conventional-changelog) standard.

## Configuration

### package.json

Like commitizen, you specify the configuration of cz-conventional-changelog through the package.json's `config.commitizen` key.

```json5
{
// ...  default values
    "config": {
        "commitizen": {
            "path": "./node_modules/cz-conventional-changelog",
            "disableScopeLowerCase": false,
            "disableSubjectLowerCase": false,
            "maxHeaderWidth": 100,
            "maxLineWidth": 100,
            "defaultType": "",
            "defaultScope": "",
            "defaultSubject": "",
            "defaultBody": "",
            "defaultIssues": "",
            "types": {
              ...
              "feat": {
                "description": "A new feature",
                "title": "Features"
              },
              ...
            }
        }
    }
// ...
}
```

### Environment variables

The following environment varibles can be used to override any default configuration or package.json based configuration.

* CZ_TYPE = defaultType
* CZ_SCOPE = defaultScope
* CZ_SUBJECT = defaultSubject
* CZ_BODY = defaultBody
* CZ_MAX_HEADER_WIDTH = maxHeaderWidth
* CZ_MAX_LINE_WIDTH = maxLineWidth

### Commitlint

If using the [commitlint](https://github.com/conventional-changelog/commitlint) js library, the "maxHeaderWidth" configuration property will default to the configuration of the "header-max-length" rule instead of the hard coded value of 100.  This can be ovewritten by setting the 'maxHeaderWidth' configuration in package.json or the CZ_MAX_HEADER_WIDTH environment variable.
npm package: @sheweny/backup
Description: Module for create backups of server discord and load this backups
Author: Smaug6739
Latest version: 1.0.11

# Discord-backup

A library for simplify the creation of backup system with mongodb database.
This module work with discord.js V13

## Getting Started

### Prerequisites

- Node.js 16.6.0 or newer is required.

- Discord.js 13.0.0 or newer is required.

### Instalation

With npm :

```sh-session
npm install @sheweny/backup
```

With yarn :

```sh-session
yarn add @sheweny/backup
```

## Usage

Import the module from node_modules :

With CommonJS syntax :

```js
const { DiscordBackup } = require("@sheweny/backup");
```

With module syntax :

```js
import { DiscordBackup } = from "@sheweny/backup";
```

Create a new instance of `DiscordBackup` with the client as a parameter and the database in options :

```js
const backup = new DiscordBackup(client, {
  database: "mongodb://localhost:27017/discord-backup",
});
```

## [async] DiscordBackup#create(guild)

Create a backup and save it to database.

Parameters :

- guild : The guild from create the backup (Guild).

Return : The id of the backup (Promise\<Snowflake>).

## [async] DiscordBackup#load(guild, options)

Load a backup from database to a specific guild.

Parameters :

- guild : The guild from load the backup (Guild).
- options : The options from load the backup (Object).
  - options.id : The id of the backup (Snowflake).
  - options.force : If the bot should delete the old server (Boolean).

Return : Promise\<boolean>.

## Example

```js
const { Client, Intents } = require("discord.js");
const { DiscordBackup } = require("@sheweny/backup");
const client = new Client({ intents: ["GUILDS", "GUILD_MESSAGES"] });
const backup = new DiscordBackup(client, {
  database: "mongodb://localhost:27017/discord-backup",
});
client.on("messageCreate", async (msg) => {
  const args = msg.content.split(" ");
  if (args[0] === "!create-backup") {
    console.log(await backup.create(msg.guild));
  }
  if (args[0] === "!load-backup") {
    backup.load(msg.guild, {
      id: args[1],
      force: true,
    });
  }
});
client.login("<discord bot token>");
```

## Authors

- [Smaug6739](https://github.com/Smaug6739)
npm package: @shewulong/micro-pack
Description: ## Description
Author: shewulong
Latest version: 1.0.6

# MICRO PACK

## Description

### 微型打包工具

## Installation

```bash
npm install -g @shewulong/micro-pack
```

## Use in Scripts

### 在`package.json`中添加脚本

```json
{
  "scripts": {
    "micro": "micro-pack --entry src/index.js --output dist"
  }
}
```

### 运行脚本

```bash
npm run micro
```

## Use in typescript

```ts
import { build } '@shewulong/micro-pack';

build({
  entry: 'src/index.ts',
  output: 'dist',
});
```
npm package: @shexjs/examples
Description: Shape Expressions example schemas
Author: Eric Prud'hommeaux
Latest version: 1.0.0

ShEx Examples

A collection of scenarios with ShEx schemas and associated data and ShapeMaps. The examples in this shape repository are deliberately simple. This is not meant to hold particularly useful schemas, but intstead smallish schemas that demonstrate ShEx or some its feature.

* [Issues](scenario/Issues/) - A simple issue-tracking database example.
npm package: @shexjs/term
Description: Shape Expressions triple expression evaluator - simple regexp returning 1 error.
Author: Eric Prud'hommeaux
Latest version: 1.0.0-alpha.27

[![NPM Version](https://badge.fury.io/js/@shexjs%2Fterm.png)](https://npmjs.org/package/shex)
[![ShapeExpressions Gitter chat https://gitter.im/shapeExpressions/Lobby](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/shapeExpressions/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.1213693.svg)](https://doi.org/10.5281/zenodo.1213693)

# @shexjs/term
Internal shexjs library subject to revision at any time.

## install

``` shell
npm install --save @shexjs/term
```

# Lerna Monorepo

This repo uses [lerna](https://github.com/lerna/lerna) to manage multiple NPM packages. These packages are located in `packages/*`:

- [`shape-map`](../shape-map#readme) -- a [ShapeMap](https://shexspec.github.io/shape-map/) parser
- [`@shexjs/parser`](../shex-parser#readme) -- parse ShExC into ShExJ
- [`@shexjs/writer`](../shex-writer#readme) -- serialize ShExK as ShExC
- [`@shexjs/term`](../shex-term#readme) -- RDF terms uses in ShEx
- [`@shexjs/util`](../shex-util#readme) -- some utilities for transforming schemas or validation output
- [`@shexjs/visitor`](../shex-visitor#readme) -- a [visitor](https://en.wikipedia.org/wiki/Visitor_pattern) for schemas
- [`@shexjs/validator`](../shex-validator#readme) -- validate nodes in an RDF graph against shapes in a schema
- [`@shexjs/eval-validator-api`](../eval-validator-api#readme) -- API called by [`@shexjs/validator`](../shex-validator#readme) for validating Shapes, with tripleExpressions and EXTENDS etc.
- [`@shexjs/eval-simple-1err`](../eval-simple-1err#readme) -- Implementation of [`@shexjs/eval-validator-api`](../eval-validator-api#readme) which reports only one error.
- [`@shexjs/eval-threaded-nerr`](../eval-threaded-nerr#readme) -- Implementation of [`@shexjs/eval-validator-api`](../eval-validator-api#readme) which exhaustively enumerate combinations of ways the data fails to satisfy a shape's expression.
- [`@shexjs/loader`](../shex-loader#readme) -- an API for loading and using ShEx schemas
- [`@shexjs/node`](../shex-node#readme) -- additional API functionality for a node environment
- [`@shexjs/cli`](../shex-cli#readme) -- a set of command line tools for transformaing and validating with schemas
- [`@shexjs/webapp`](../shex-webapp#readme) -- the shex-simple WEBApp
- [`@shexjs/shape-path-query`](../shex-shape-path-query#readme) -- traverse ShEx schemas with a path language
- [`@shexjs/extension-test`](../extension-test#readme) -- a small language for testing semantic actions in ShEx implementations ([more](http://shex.io/extensions/Test/))
- [`@shexjs/extension-map`](../extension-map#readme) -- an extension for transforming data from one schema to another ([more](http://shex.io/extensions/Map/))
- [`@shexjs/extension-eval`](../extension-eval#readme) -- simple extension which evaluates Javascript semantic action code ([more](http://shex.io/extensions/Eval/))