open-index/open-npm huggingface dataset:
npm package: @luke-mml/quickedit
Description: SLW (Super-light weight) jQuery plugin to create HTML editors for webpages
Latest version: 1.0.0

# quickedit
SLW (Super-light weight) jQuery plugin to create HTML editors for webpages. 

Features

- Changes can be either saved automatically (via ajax) when the editable area loses focus, or inputs updated (to submit changes with a normal form submit)
- Keyboard shortcuts for very basic formatting (bold, italics)

### Examples

<a href="https://meccamedialight.com.au/demo/quickedit/demo.html">Demo </a>

#### Use case 1

Simple markup with a data-api attribute to specifiy the  url to post changes to.

```html
<div class="container" data-api="/api">Lorem ipsum</div>
```

Initialise the editor with the defaults. Changes are posted to '/api' (url specified in the html markup). 

```javascript
$('.container').quickEdit();
```

#### Use case 2

Simple markup with a data-target attribute to specify the from input to store changes. 

```html
<form>
<input type="hidden" name="myhiddenfield" value="Lorem ipsum" ?>
<div class="container" data-target="myhiddenfield">Lorem ipsum</div>
...
</form>
```

Changes are submitted to the server with the rest of the form. 

```javascript
$('.container').quickEdit();
```

#### Use case 3

Simpler HTML, with some options specified in javascript

```html
<div class="container">Lorem ipsum</div>
```

Initialise the editor, with a function to handle saving.

```javascript
$('.container').quickEdit({
	allowReturn: true,
	submitOnBlur: true,
	html: true,
	onSave: function (t) {
		// do something clever with the updated text
		console.log("Saving :" + t);
	}
});
```

### Options

- **allowReturn**: false -- if false, return key is blocked  *(default false)*
- **submitOnBlur**: if true (defaut) then the save action is called when losing focus  *(default true)*
- **html**:  if true, use HTML rather than text *(default false)*
- **onSave**: callback to handle saving (if a function is specified, it will be used in preference to any other scheme). If no function is specified, then data-target (for specifying inputs) or data-api (for ajax) will be used. *(default NULL)*
- **onSaved**: callback after auto saving
- **onEditing**: callback after the editor gets focussed or otherwise has changed content
npm package: @luke-mml/quillwrap
Description: A simple module for for converting textareas into Quill-powered editors.
Latest version: 1.0.1

# quillwrap
A simple module for for converting textareas into Quill-powered editors.  

<a href="https://meccamedialight.com.au/demo/quillwrap/demo.html">Demo</a>

Example use

```html
<script src="jquery.js"></script>
<script src="quill.js"></script>
<script src="quillwrap.js"></script>
<script>
$(document).ready(function () {
    quillwrap.autoinit();
});
</script>
```

Or if you are using AMD modules...

```javascript
var quillWrap = require('quillwrap');
quillWrap.autoinit();
```

The autoinit() method automatically converts textareas with class "rte" into Quill editors. The original textareas are hidden, but their values will update automatically (so you should be able to submit the form without having to perform any extra steps).

Additional demo is here: https://github.com/luke-mml/quillwrap-demo
npm package: @luke-mml/tashwax
Description: Helper module for using Mustache templates. Designed to work with require.js.
Latest version: 1.0.0

Tashwax
========
Helper module for using Mustache templates. Designed to work with require.js.

<a href="https://meccamedialight.com.au/demo/tashwax/demo/demo.html">Demo</a>


Example use:

```javascript
var tash = require('tashwax'), data;
tash.loadAndRender('./templates/template.html', data, $('#test'));
```

This will load a template from /templates/template.html, and render this to html 
using the data object, inserting the result in the element #test. When a template
is loaded, it will be stashed in memory (to avoid having to make another request)

Example use:

```javascript
tash.loadTemplate('./templates/template.html', function(tpl, src){
    $target.html(Mustache.render(tpl, data));
 });
```

This will load a template from /templates/template.html. A callback function will
then use Mustache to render the result into the target element