open-index/open-npm huggingface dataset:
npm package: @lernato/common
Description: JavaScript utilities for writing code the Lernato way.
Author: Lernato, LLC
Latest version: 4.2.0
Deprecated: this package has been deprecated

# @lernato/common

These are utility functions to help build a solid foundation of reliable data in JavaScript applications.

## Installation

To install the package:

    npm install @lernato/common

To use a function, import it from the common folder. For example,

    import { getString } from '@lernato/common';
npm package: @lernetz/gulp-serve
Description: Gulp-compatible wrapper functions around `docker-compose` to start Docker containers with proper project name and port listing.
Author: Michael Heimann
Latest version: 0.2.0

# @lernetz/gulp-serve

Gulp-compatible wrapper functions around `docker-compose` to start Docker containers with proper project name and port listing.


## Usage

This package exports two asynchronous functions `serve` and `stopServe`. Because they follow the error-first callback pattern, they can be used with Gulp as follows:

```javascript
// In your Gulpfile:

// Using classic Gulp syntax:
const gulp = require('gulp');
const {serve, stopServe} = require('@lernetz/gulp-serve');
gulp.task('serve', serve());
gulp.task('serve:stop', stopServe());

// Or, using the newer Gulp 4 syntax:
const {serve, stopServe} = require('@lernetz/gulp-serve');
module.exports = {
    'serve': serve(),
    'serve:stop': stopServe(),
};
```

Then run the defined tasks from the command line:

```shell
npx gulp serve
npx gulp serve:stop
```


## Options

The two functions can be configured to use non-default options via an `options` argument:

```javascript
module.exports = {
    'serve': serve(options),
    'serve:stop': stopServe(options),
};
```

The `options` object allows you to specify the following properties:

 * `folder`: The path to the folder containing the `docker-compose.yml` file. The default is `'docker/dev'`.

 * `name`: The project name to be used by `docker-compose`. Every container will be prefixed with that project name. By default, the name of the current directory will be used.
npm package: @lernetz/gulp-stylus
Description:  A Gulp task that compiles Stylus files (including sourcemaps), minifies them, and applies the Autoprefixer PostCSS processor.
Author: Michael Heimann
Latest version: 0.1.1

# @lernetz/gulp-stylus

A Gulp task that compiles [Stylus](http://stylus-lang.com/) files, applies the Autoprefixer PostCSS processor, generates sourcemaps and a minified version.


## Usage

The following example will compile all the files referenced by `stylus/main.styl` and produce a bundle in the output folder `public`, using the base file name `demo`:

```javascript
const gulp = require('gulp');
const cssTask = require('@lernetz/gulp-stylus');

gulp.task('css', cssTask({ src:'stylus/main.styl', dest: 'public', name: 'demo' }));
```

This task will create the following files:

* `public/demo.css` - non-minified `.css` bundle including the sourcemap definition
* `public/demo.min.css` - minified `.css` bundle


## Options

The task accepts a parameter object with the following attributes:

```javascript
{
    name: 'name', // the file name of the generated files
    src: 'src/**.ts', // the source parameter for the gulp.src( .. )
    dest: 'public', // the destination used in gulp.dest( .. )
    stylus: {}, // options for the stylus compiler used in gulp-stylus: https://www.npmjs.com/package/gulp-stylus#options
    prefixer: { cascade: true } // options for the gulp-autoprefixer: https://github.com/sindresorhus/gulp-autoprefixer#options
}
```
npm package: @lernetz/gulp-typescript-template
Description: A gulp taks to convert html templates into typescript code
Author: Michael Heimann
Latest version: 0.1.5

HTML Templates to Typescript
============================

This Gulp plugin converts HTML files with template definitions into TypeScript modules.

With the preprocessing step, plain HTML templates can be used in TypeScript as regular imports. It reads files with the following structure:

```html
<template name="app.dashboard">
  <div class="app-dashboard">
    <h1>My Dashboard</h1>
    <p>[[ number ]] new messages</p>
  </div>
</template>
<template name="ui.tooltip">
  <div class="tooltip">
    My Tooltip
  </div>
</template>
```

And outputs the templates with their names into namespaced TypeScript modules:

```typescript
// app.ts
export const dashboard = '<div class="app-dashboard"><h1>My Dashboard</h1><p>[[ number ]] new messages</p></div>';
```

```typescript
// ui.ts
export const tooltip = '<div class="tooltip">My Tooltip</div>';
```

Now the templates can be imported as regular strings:

```typescript
import { dashboard } from './templates/app';
import { tooltip } from './templates/ui';
```


Usage
-----

An example usage with Gulp:

```javascript
var gulp     = require('gulp');
var template = require('@lernetz/gulp-typescript-template');

gulp.task('template', function() {
    return gulp.src( 'src/**.html' )
               .pipe( template() )
               .pipe( gulp.dest( 'src/templates' ) );
});
```
npm package: @lernib/calendar
Description: Event tracking and recurrence across time zones
Author: Carlos Kieliszewski
Latest version: 0.3.0

# @lernib/calendar

This library handles various event recurrence shenanigans. We use it to help keep track of things like session times across timezones and billing dates.

## Install

```
npm i @lernib/calendar
```

## Usage

```
import { Event } from "@lernib/calendar";

const start = new Event("2025-01-01", "12:00", "America/New_York").every({
  weeks: 1,
});

// Get the next 10 sessions, including the first one
console.info(start.next(10));
```