open-index/open-npm huggingface dataset:
npm package: @swlkr/req
Description: Zero dependency promise-based http library for the browser
Author: swlkr
Latest version: 2.1.3

# req

Zero dependency json http client for the browser

## Install

```bash
$ yarn add @swlkr/req
```

## Use

```javascript
import Http from "@swlkr/req";

// Get request
Http
.send({ url: "http://your-api.com/some-url", method: "get" })
.then(res => console.log(res))
.catch(err => console.log(err))

// Post request
Http
.send({ url: "http://your-api.com/some-url", body: { prop: "value", prop1: "value1", prop2: "value2" }, method: "POST" })
.then(res => console.log(res))
.catch(err => console.log(err))

// Custom headers with delete request
Http
.send({ url: "http://your-api.com/some-url", method: "delete", headers: { Authorization: "super secure json web token" } })
.then(res => console.log(res))
.catch(err => console.log(err))

// Using async/await
try {
  const response = await Http.send({ url: "http://your-api.com/some-url", method: "get" });
  // use response
} catch(error) {
  console.log(error.message);
  console.log(error.status);
}

// Handling the unfortunate event of a timeout
// timeout should be an integer that represents milliseconds
Http
.send({ url: "http://your-api.com/some-url", method: "GET", timeout: 1000 })
.then(res => console.log(res))
.catch(err => console.log(err))
```

### Test
```bash
yarn
yarn test
```
npm package: @swlynch99/actions-cache-gcs
Description: This package provides an interface that is mostly compatible with the `@actions/cache` NPM package but instead uses a GCS bucket to store the artifacts.
Author: swlynch99
Latest version: 0.1.2

# @swlynch99/actions-cache-gcs

This package provides an interface that is mostly compatible with the `@actions/cache`
NPM package but instead uses a GCS bucket to store the artifacts.

## Configuration
This library uses two pieces of external configuration, depending on its setup:
- GCS credentials are read via Application Default Credentials
- The bucket to use is taken from the `ACTIONS_CACHE_GCS_BUCKET` environment
  variable, if not provided as an option.

## API

This package exposes the following API. It roughly mirrors that exported by the
`@actions/cache` package although it only supports a subset of the options.
```typescript
interface CommonOptions {
    /**
     * The GCS bucket used to store cache entries.
     *
     * If not set this will default to the value of the `ACTIONS_GCS_CACHE_BUCKET`
     * environment variable.
     *
     * If still unset then an error will be thrown.
     */
    bucket?: string;
}

export interface UploadOptions extends CommonOptions {}

export interface DownloadOptions extends CommonOptions {
    /**
     * Whether to skip downloading the cache entry.
     *
     * If lookupOnly is set to true, the restore function will only check if a matching
     * cache entry exists and return the cache key if it does.
     *
     * @default false
     */
    lookupOnly?: boolean;
}

/**
 * isFeatureAvailable checks whether the cache service is available.
 *
 * @returns true - with the right configuration it should always be possible to
 *          use GCS as a cache.
 */
export declare function isFeatureAvailable(): boolean;

/**
 * Saves a list of files with the specified key.
 *
 * @param paths a list of file paths to be cached
 * @param key an explicit key for restoring the cache
 * @param options cache upload options
 * @throws an error if the save fails
 */
export declare function saveCache(
  paths: string[],
  key: string,
  options?: UploadOptions
): Promise<void>;

/**
 * Restores cache from keys.
 *
 * @param paths a list of file paths to restore from the cache.
 * @param primaryKey and explicit key for restoring from the cache. Lookup is done with prefix matching.
 * @param restoreKeys an optional ordered list of keys to use for restoring the cache if no cache hit occurred for primaryKey.
 * @param options cache download options.
 */
export declare function restoreCache(
  paths: string[],
  primaryKey: string,
  restoreKeys?: string[],
  options?: DownloadOptions
): Promise<string | undefined>;
```
npm package: @swlynch99/purgecss-from-lit
Description: Extract css selectors for use by purgecss from lit components
Author: Sean Lynch
Latest version: 0.1.1

# purgecss-from-lit

This package is a [purgecss extractor][extractors] for extracting css selectors
from typescript files containing [lit] web components. Specifically, it will
parse the `html`-tagged templates within your source code and extract classes
from the HTML within.

## Caveats
- This plugin parses all included code as typescript. This shouldn't cause any
  issues when parsing javascript but there may be code that causes issues.

- This plugin only looks for template literals of the form
  ```js
  html`<div>HTML here</div>`
  ```
  If you end up directly invoking the `html` function somehow then that will
  not be caught by `purgecss-from-lit`.

- Elements, attributes, classes, and ids added as template values will not be
  picked up. If you find that those selectors are being stripped by purgecss
  then you will need to add them to the `safelist` in your purgecss config.

  For example, `purgecss-from-lit` will not detect the `button` tag in the
  element below
  ```js
  const button = literal`button`;
  const demoClass = "demo-button";

  html`<${button} class=${demoClass}>Click Me</button>`
  ```
  If you use the `button` tag nowhere else in your page or app then you would
  need to add the `button` selector to the `safelist` in order to preserve it.
  The same applies for the `.demo-button` class here.

[extractors]: https://purgecss.com/extractors.html
[lit]: https://lit.dev/

## Installation
### npm
```
npm install --save-dev @swlynch99/purgecss-from-lit
```

### yarn
```
yarn install -D @swlynch99/purgecss-from-lit
```

### pnpm
```
pnpm install -D @swlynch99/purgecss-from-lit
```

## Usage
List the function as one of the extractors in your `purgecss` config
```js
import purgeLit from '@swlynch99/purgecss-from-lit';

export default {
    extractors: [
        {
            extractor: purgeLit(),
            extensions: ['js', 'ts']
        }
    ],
    ...
}
```

You can optionally pass a config for
[`@typescript-eslint/typescript-estree`][estree] in order to configure how the
files are parsed. This can be used to generate a lit extractor that supports
JSX (although it will not parse classes from said JSX).
```js
import purgeLit from '@swlynch99/purgecss-from-lit';

export default {
    extractors: [
        {
            extractor: purgeLit({ jsx: true }),
            extensions: ['jsx', 'tsx'],
        }
    ]
}
```

[estree]: https://typescript-eslint.io/packages/typescript-estree/#parsecode-options
npm package: @swmansion/traveling-fastlane-darwin
Description: Bundled up fastlane
Author: Edgar Aroutiounian
Latest version: 1.5.0-swmansion
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

This is traveling ruby `2.2.2` packaged with a gem dependency on
fastlane and with some expo specific scripts, included is a ruby
interpreter for OS X.
npm package: @swmansion/traveling-fastlane-linux
Description: Bundled up fastlane
Author: Edgar Aroutiounian
Latest version: 1.5.0-swmansion
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

This is traveling ruby `2.2.2` packaged with a gem dependency on
fastlane and with some expo specific scripts, included is a ruby
interpreter for Linux.
npm package: @swmansion/xdl
Description: The Expo Development Library
Author: support@expo.io
Latest version: 50.2.0-swmansion
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# xdl
The Expo Development Library.
[Documentation](https://docs.expo.io/versions/devdocs/index.html)

If you have problems with the code in this repository, please file issues & bug reports
at https://github.com/expo/expo. Thanks!

## Building Watchman
Configure with `./configure --disable-statedir --without-pcre` to use TMPDIR for the watchman state.

## Testing Against Local Schema
Use `LOCAL_XDL_SCHEMA=1` to test with the schema at EXPONENT_UNIVERSE_DIR/server/www/xdl-schemas/UNVERSIONED-schema.json
npm package: @swmm-js/swmm-node
Description: TypeScript package for performing data operations on EPA-SWMM and swmmReact files.
Author: Issac Gardner
Latest version: 0.0.7

# swmmNode info

swmmNode is a TypeScript package for performing operations on EPA-SWMM files via Node.js or through websites built with swmmReact, swmmVue or swmmLink.

## How to link to your project

Use npm to install swmmNode (swmm-node) into your projects:
```
npm install @swmm-js/swmm-node
```
## Core functions

Some of the core elements of swmmNode are detailed below:

### swmmOut

swmmOut(ArrayBuffer): Creates an interactive class instance for .out files.
npm package: @swnb/exam-monitor-sdk-win32-ia32-msvc
Description: This is the **i686-pc-windows-msvc** binary for `@swnb/exam-monitor-sdk`
Latest version: 0.1.16

# `@swnb/exam-monitor-sdk-win32-ia32-msvc`

This is the **i686-pc-windows-msvc** binary for `@swnb/exam-monitor-sdk`
npm package: @swnb/exam-monitor-sdk-win32-x64-msvc
Description: This is the **x86_64-pc-windows-msvc** binary for `@swnb/exam-monitor-sdk`
Latest version: 0.1.16

# `@swnb/exam-monitor-sdk-win32-x64-msvc`

This is the **x86_64-pc-windows-msvc** binary for `@swnb/exam-monitor-sdk`
npm package: @swoft/core-architecture
Description: Official compatibility package for @swoft/core-architecture → @swoft/core/architecture
Author: Swoft Platform Team
Latest version: 1.0.0

# @swoft/core-architecture (Compatibility Package)

🔄 **Official compatibility package** for domains migrating from `@swoft/core-architecture` to the new unified `@swoft/core` package.

## Purpose

This package provides seamless backward compatibility during the platform refactoring. It re-exports all functionality from `@swoft/core/architecture` using the old package name.

## Migration Path

### Old Way (still works)

```typescript
import { AggregateRoot, Entity, DomainEvent } from '@swoft/core-architecture';
```

### New Way (recommended)

```typescript
import { AggregateRoot, Entity, DomainEvent } from '@swoft/core/architecture';
```

## What's Included

All DDD architecture patterns:

- `AggregateRoot<T>` - Domain aggregate base class
- `Entity<T>` - Domain entity base class
- `EntityId` - Strongly-typed entity identifiers
- `DomainEvent` - Domain event base class
- `ValueObject` - Value object base class
- `BusinessAction` - Business action patterns
- And more...

## Timeline

- ✅ **Phase 1**: Compatibility package available (no changes needed)
- 🔄 **Phase 2**: Gradual migration to `@swoft/core/architecture`
- 🗓️ **Phase 3**: Deprecation warnings (6+ months notice)
- 🗓️ **Phase 4**: Package removal (major version bump)

## Status

**Current**: ✅ Production Ready  
**Deprecation**: Not before v3.0.0  
**Support**: Full compatibility maintained

---

Part of the [Swoft Platform](https://github.com/derickrethans/swoft-workspaces) compatibility layer.
npm package: @swoft/ddd
Description: Domain-Driven Design (DDD) strategic and tactical design tools for domain modeling and bounded context management.
Latest version: 0.1.30

# @swoft/ddd

Domain-Driven Design (DDD) strategic and tactical design tools for domain modeling and bounded context management.

## 📋 Overview

This package provides comprehensive DDD tools including strategic design for domain modeling, bounded context definition, and tactical design for aggregate implementation.

## 🏗️ Architecture

- **Strategic Design**: Domains, Bounded Contexts, Context Mapping
- **Tactical Design**: Aggregates, Entities, Value Objects, Domain Events
- **Analysis Tools**: Package alignment, domain health checks
- **Repositories**: DomainRepository, BoundedContextRepository, AggregateRepository

## 🚀 Installation

```bash
pnpm add @swoft/ddd
```

## 📖 Usage

```typescript
import { Domain, BoundedContext, Aggregate } from '@swoft/ddd';

// Create a domain
const domain = Domain.create({
  name: 'Customer Management',
  description: 'Core customer relationship management',
  domainType: 'core',
  projectId: 'project-123'
});

// Define bounded context
const context = BoundedContext.create({
  name: 'Customer Identity',
  domainId: domain.id,
  description: 'Customer identity and authentication',
  ubiquitousLanguage: ['Customer', 'Identity', 'Authentication']
});

// Create aggregate
const aggregate = Aggregate.create({
  name: 'Customer',
  boundedContextId: context.id,
  description: 'Customer aggregate root',
  purpose: 'Manage customer identity and profile'
});
```

## 🎯 DDD Capabilities

- **Strategic Design**: Domain identification and context boundaries
- **Tactical Design**: Aggregate and entity modeling
- **Context Mapping**: Relationship patterns between contexts
- **Package Analysis**: Technical-to-domain alignment
- **Health Monitoring**: DDD compliance and architecture validation

## 🏷️ Keywords

- ddd, domain-driven-design, strategic-design, tactical-design, bounded-context, aggregate

## 📚 Documentation

- [DDD & Clean Architecture Guide](../../docs/01-current/architecture/DDD-CLEAN-ARCHITECTURE.md)
- [Strategic Design Patterns](../../docs/01-current/reference/strategic-design-patterns.md)

---

**Status**: Production Ready  
**Maintained by**: Swoft Development Team