qword 0.1.0

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2018 Coderaiser
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,170 @@
+# Dword [![License][LicenseIMGURL]][LicenseURL] [![NPM version][NPMIMGURL]][NPMURL]
+
+[NPMIMGURL]: https://img.shields.io/npm/v/dword.svg?style=flat
+[BuildStatusURL]: https://github.com/cloudcmd/dword/actions?query=workflow%3A%22Node+CI%22 "Build Status"
+[BuildStatusIMGURL]: https://github.com/cloudcmd/dword/workflows/Node%20CI/badge.svg
+[LicenseIMGURL]: https://img.shields.io/badge/license-MIT-317BF9.svg?style=flat
+[NPM_INFO_IMG]: https://nodei.co/npm/dword.png?downloads=true&&stars&&downloadRank "npm install dword"
+[NPMURL]: https://npmjs.org/package/dword "npm"
+[LicenseURL]: https://tldrlegal.com/license/mit-license "MIT License"
+[edit.json]: https://github.com/cloudcmd/dword/tree/master/json/edit.json "edit.json"
+
+Web editor based on [CodeMirror](http://codemirror.net).
+Fork of [edward](https://github.com/cloudcmd/edward "Edward").
+
+![dword](https://raw.githubusercontent.com/cloudcmd/dword/master/img/dword.png "dword")
+
+## Features
+
+- Syntax highlighting based on extension of file for over 90 languages.
+- Built-in `emmet` (for html files)
+- Drag n drop (drag file from desktop to editor).
+- Configurable options ([json/edit.json][edit.json] could be overriden by `~/.dword.json`)
+
+## Install
+
+```
+npm i dword -g
+```
+
+![NPM\_INFO][NPM_INFO_IMG]
+
+## Command line parameters
+
+Usage: `dword [filename]`
+
+|Parameter              |Operation
+|:----------------------|:--------------------------------------------
+| `-h, --help`          | display help and exit
+| `-v, --version`       | output version information and exit
+
+## Hot keys
+
+|Key                    |Operation
+|:----------------------|:--------------------------------------------
+| `Ctrl + s`            | save
+| `Ctrl + f`            | find
+| `Ctrl + h`            | replace
+| `Ctrl + g`            | go to line
+| `Ctrl + e`            | evaluate (JavaScript only supported)
+
+## API
+
+dword could be used as middleware for [express](http://expressjs.com "Express").
+For this purpuse API could be used.
+
+### Server
+
+#### dword(options)
+
+Middleware of `dword`. Options could be omitted.
+
+```js
+import {dword} from 'dword';
+import express from 'express';
+
+const app = express();
+
+app.use(dword({
+    root: '/', // default
+    online: true, // default
+    diff: true, // default
+    zip: true, // default
+    dropbox: false, // optional
+    dropboxToken: 'token', //  optional
+}));
+
+app.listen(31_337);
+```
+
+#### dword.listen(socket)
+
+Could be used with [socket.io](http://socket.io "Socket.io") to handle editor events with.
+
+```js
+import {Server} from 'socket.io';
+const socket = new Server(server);
+
+dword.listen(socket, {
+    // optional
+    prefixSocket: '/dword',
+    // optional
+    auth: (accept, reject) => (username, password) => {
+        accept();
+    },
+});
+```
+
+### Client
+
+Dword uses [codemirror](http://codemirror.net/ "CodeMirror") on client side, so API is similar.
+All you need is put minimal `html`, `css`, and `js` into your page.
+
+Minimal html:
+
+```html
+<div class="edit" data-name="js-edit"></div>
+<script src="/dword/dword.js"></script>
+```
+
+Minimal css:
+
+```css
+html, body, .edit {
+    height: 100%;
+    margin: 0;
+}
+```
+
+Minimal js:
+
+```js
+dword('[data-name="js-edit"]', (editor) => {
+    editor.setValue('hello dword');
+    console.log('dword is ready');
+});
+```
+
+#### Client API
+
+##### `dword(selector, callback)`
+
+- `selector`: **string**
+- `callback`: **EditorCallback**
+
+Initialize new instance
+
+###### `editor.setValue(value)`
+
+- `value`: **string**
+
+Set value to `editor`.
+
+###### `editor.getValue()`
+
+- `returns`: **string**
+
+Get value from editor.
+
+##### Types
+
+```ts
+interface Editor {
+    setValue: (value: string) => void;
+    getValue: () => string;
+}
+
+type EditorCallback = (editor: Editor) => void;
+type Dword = (selector: string, callback: EditorCallback) => void;
+```
+
+For more information you could always look around `client/dword.js` directory.
+
+## Related
+
+- [Edward](https://github.com/cloudcmd/edward "Edwdard") - web editor based on [Ace](https://ace.c9.io "Ace").
+- [Deepword](https://github.com/cloudcmd/deepword "Deepword") - web editor based on [Monaco](https://microsoft.github.io/monaco-editor/ "Monaco").
+
+## License
+
+MIT

package/assets/index.html

@@ -0,0 +1,24 @@
+<!doctype html>
+<html>
+    <head>
+        <title>Dword</title>
+        <link rel="stylesheet" href="/style.css">
+    </head>
+    <body>
+        <div class="edit" data-name="js-edit"></div>
+        <script src="/dword/dword.js"></script>
+        <script>
+            /* global dword */
+            window.addEventListener('DOMContentLoaded', function domLoad() {
+                dword('[data-name="js-edit"]', (editor) => {
+                    editor.setOptions({
+                        fontSize: '16px',
+                        fontFamily: 'Droid Sans Mono',
+                    });
+                });
+                
+                window.removeEventListener('DOMContentLoaded', domLoad);
+            });
+        </script>
+    </body>
+</html>

package/assets/style.css

@@ -0,0 +1,34 @@
+@font-face {
+    font-family: 'Droid Sans Mono';
+    src: url(https://themes.googleusercontent.com/static/fonts/droidsansmono/v5/ns-m2xQYezAtqh7ai59hJTwtzT4qNq-faudv5qbO9-U.eot);
+    src:
+        local('Droid Sans Mono'),
+        local('DroidSansMono'),
+        url(/font/DroidSansMono.eot) format('embedded-opentype'),
+        url(https://themes.googleusercontent.com/static/fonts/droidsansmono/v5/ns-m2xQYezAtqh7ai59hJTwtzT4qNq-faudv5qbO9-U.eot?#iefix)
+            format('embedded-opentype'),
+        url(https://themes.googleusercontent.com/static/fonts/droidsansmono/v5/ns-m2xQYezAtqh7ai59hJTwtzT4qNq-faudv5qbO9-U.eot)
+            format('embedded-opentype'),
+        url(/font/DroidSansMono.woff2) format('woff2'),
+        url(/font/DroidSansMono.woff) format('woff'),
+        url(https://themes.googleusercontent.com/static/fonts/droidsansmono/v5/ns-m2xQYezAtqh7ai59hJUYuTAAIFFn5GTWtryCmBQ4.woff)
+            format('woff'),
+        local('Consolas');
+    font-style: normal;
+    font-weight: 400;
+}
+
+html,
+body,
+.edit {
+    width: 100%;
+    height: 100%;
+    margin: 0;
+}
+
+.edit {
+    position: absolute;
+    inset: 0;
+    font-family: 'Droid Sans Mono';
+    font-size: 16px;
+}

package/bin/dword.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import {fileURLToPath} from 'node:url';
+import {dirname} from 'node:path';
+import process from 'node:process';
+import http from 'node:http';
+import express from 'express';
+import {Server} from 'socket.io';
+import info from '../package.json' with {
+    type: 'json',
+};
+import {dword} from '../server/index.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const [arg] = process.argv.slice(2);
+
+if (!arg)
+    usage();
+else if (/^(-v|--v)$/.test(arg))
+    version();
+else if (/^(-h|--help)$/.test(arg))
+    help();
+else
+    checkFile(arg, (error) => {
+        if (!error)
+            return main(arg);
+        
+        console.error(error.message);
+    });
+
+function getPath(name) {
+    const reg = /^[~/]/;
+    
+    if (!reg.test(name))
+        name = process.cwd() + '/' + name;
+    
+    return name;
+}
+
+function main(name) {
+    const filename = getPath(name);
+    const DIR = `${__dirname}/../assets/`;
+    
+    const app = express();
+    const server = http.createServer(app);
+    
+    const {env} = process;
+    
+    const port = env.PORT || 1337;
+    const ip = env.IP || '0.0.0.0';
+    
+    app
+        .use(express.static(DIR))
+        .use(dword({
+            online: false,
+            diff: true,
+            zip: true,
+        }));
+    
+    server.listen(port, ip);
+    
+    const socket = new Server(server);
+    const edSocket = dword.listen(socket);
+    
+    edSocket.on('connection', () => {
+        fs.readFile(name, 'utf8', (error, data) => {
+            if (error)
+                return console.error(error.message);
+            
+            edSocket.emit('file', filename, data);
+        });
+    });
+    
+    console.log('url: http://' + ip + ':' + port);
+}
+
+function checkFile(name, callback) {
+    fs.stat(name, (error, stat) => {
+        let msg;
+        
+        if (error && error.code === 'ENOENT')
+            msg = Error(`no such file or directory: '${name}'`);
+        else if (stat.isDirectory())
+            msg = Error(`'${name}' is directory`);
+        
+        callback(msg);
+    });
+}
+
+function version() {
+    console.log(`v${info.version}`);
+}
+
+function usage() {
+    console.log(`Usage: ${info.name} [filename]`);
+}
+
+async function help() {
+    const bin = await import('../json/bin');
+    
+    usage();
+    console.log('Options:');
+    
+    for (const name of Object.keys(bin)) {
+        console.log(`  ${name} ${bin[name]}`);
+    }
+}

package/client/_clipboard.js

@@ -0,0 +1,53 @@
+import clipboard from '@cloudcmd/clipboard';
+import createElement from '@cloudcmd/create-element';
+import once from 'once';
+import _showMessageOnce from './show-message.js';
+
+const resolve = Promise.resolve.bind(Promise);
+const reject = Promise.reject.bind(Promise);
+const showMessageOnce = once(_showMessageOnce);
+
+export default (cmd) => {
+    const NAME = 'editor-clipboard';
+    const {_Ace, _story} = this;
+    
+    const value = _Ace.getSelection('\n');
+    const insert = (a) => _Ace
+        .getDoc()
+        .replaceSelection(a);
+    
+    if (cmd === 'copy') {
+        _story.setData(NAME, value);
+        return clipboard.writeText(value);
+    }
+    
+    if (cmd === 'cut') {
+        _story.setData(NAME, value);
+        return cut(value) ? resolve() : reject();
+    }
+    
+    return clipboard
+        .readText()
+        .then(insert)
+        .catch(() => {
+            showMessageOnce('Could not paste from clipboard. Inner buffer used.');
+            
+            const value = _story.getData(NAME);
+            
+            insert(value);
+        });
+};
+
+function cut(value) {
+    const textarea = createElement('textarea', {
+        value,
+    });
+    
+    textarea.select();
+    
+    const result = document.execCommand('cut');
+    
+    document.body.removeChild(textarea);
+    
+    return result;
+}

package/client/_init-socket.js

@@ -0,0 +1,77 @@
+/* global io */
+import {applyPatch} from 'daffy';
+import {alert} from 'smalltalk';
+
+const getHost = () => {
+    const l = location;
+    
+    return l.origin || l.protocol + '//' + l.host;
+};
+
+export default function() {
+    const dword = this;
+    const href = getHost();
+    const FIVE_SECONDS = 5000;
+    
+    const patch = (name, data) => {
+        socket.emit('patch', name, data);
+    };
+    
+    const {_prefixSocket} = dword;
+    
+    const socket = io.connect(href + _prefixSocket, {
+        'max reconnection attempts': 2 ** 32,
+        'reconnection limit': FIVE_SECONDS,
+        'path': this._socketPath + '/socket.io',
+    });
+    
+    this._socket = socket;
+    
+    socket.on('reject', () => {
+        this.emit('reject');
+    });
+    
+    socket.on('connect', () => {
+        dword._patch = patch;
+    });
+    
+    socket.on('message', (msg) => {
+        this._onSave(null, msg);
+    });
+    
+    socket.on('file', (name, data) => {
+        dword
+            .setModeForPath(name)
+            .setValueFirst(name, data)
+            .moveCursorTo(0, 0);
+    });
+    
+    socket.on('patch', (name, data, hash) => {
+        if (name !== this._FileName)
+            return;
+        
+        if (hash !== this._story.getHash(name))
+            return;
+        
+        const cursor = dword.getCursor();
+        const value = dword.getValue();
+        const result = applyPatch(value, data);
+        
+        this.setValue(result);
+        
+        this
+            ._story
+            .setData(name, value)
+            .setHash(name, this.sha());
+        
+        dword.moveCursorTo(cursor.row, cursor.column);
+    });
+    
+    socket.on('disconnect', () => {
+        dword.save.patch = globalThis._patchHttp;
+    });
+    
+    socket.on('err', (error) => {
+        alert(this._TITLE, error);
+    });
+}

package/client/_on-save.js

@@ -0,0 +1,38 @@
+import {confirm} from 'smalltalk';
+import {write} from 'restafary/client';
+
+function empty() {}
+
+export default function onSave(error, text) {
+    const Value = this._Value;
+    const FileName = this._FileName;
+    let msg = 'Try again?';
+    
+    if (error) {
+        if (error.message)
+            msg = error.message + '\n' + msg;
+        else
+            msg = `Can't save.` + msg;
+        
+        const onSave = this._onSave.bind(this);
+        
+        return confirm(this._TITLE, msg)
+            .then(() => {
+                write(this._FileName, this._Value, onSave);
+            })
+            .catch(empty)
+            .then(() => {
+                this.focus();
+            });
+    }
+    
+    this.showMessage(text);
+    
+    const hash = this.sha();
+    this
+        ._story
+        .setData(FileName, Value)
+        .setHash(FileName, hash);
+    
+    this._Emitter.emit('save', Value.length);
+}

package/client/codemirror/show-trailing.js

@@ -0,0 +1,54 @@
+'use strict';
+
+/* global CodeMirror */
+/* global define */
+
+(function(mod) {
+    const isFn = (a) => typeof a === 'function';
+    
+    if (typeof exports === 'object' && typeof module === 'object') // CommonJS
+        mod(require('../../lib/codemirror'));
+    else if (isFn(define) && define.amd) // AMD
+        define(['../../lib/codemirror'], mod);
+    else // Plain browser env
+        mod(CodeMirror);
+})((CodeMirror) => {
+    add();
+    
+    CodeMirror.defineOption('showTrailing', false, (cm, val, prev) => {
+        if (prev === CodeMirror.Init)
+            prev = false;
+        
+        if (prev && !val)
+            cm.removeOverlay('trailingspace');
+        else if (!prev && val)
+            cm.addOverlay({
+                token(stream) {
+                    let ret = null;
+                    const match = stream.match(/\s+$/);
+                    
+                    if (match && match[0] !== stream.string)
+                        ret = 'trailing-whitespace';
+                    
+                    stream.match(/^\s*\S/);
+                    
+                    return ret;
+                },
+                name: 'trailingspace',
+            });
+    });
+    
+    function add() {
+        const style = document.createElement('style');
+        
+        style.setAttribute('data-name', 'js-showTrailing');
+        
+        style.textContent = [
+            '.cm-trailing-whitespace {',
+            'color: #f80;',
+            'text-decoration: underline;',
+            '}'].join('');
+        
+        document.head.appendChild(style);
+    }
+});

package/client/codemirror/use-soft-tabs.js

@@ -0,0 +1,38 @@
+'use strict';
+
+/* global CodeMirror */
+/* global define */
+
+(function(mod) {
+    if (typeof exports === 'object' && typeof module === 'object') // CommonJS
+        mod(require('../../lib/codemirror'));
+    else if (typeof define === 'function' && define.amd) // AMD
+        define(['../../lib/codemirror'], mod);
+    else // Plain browser env
+        mod(CodeMirror);
+})((CodeMirror) => {
+    CodeMirror.defineOption('useSoftTabs', false, (cm) => {
+        cm.addKeyMap({
+            'Tab'(cm) {
+                let line;
+                const sel = cm.getSelection('\n');
+                const coupleLines = sel.length > 0;
+                const isSelected = cm.somethingSelected();
+                
+                if (isSelected) {
+                    line = cm.getLine(cm.getCursor().line);
+                    // Indent only if there are multiple lines selected, or if the selection spans a full line
+                    
+                    if (coupleLines && (sel.includes('\n') || sel.length === line.length)) {
+                        cm.indentSelection('add');
+                    }
+                } else {
+                    cm.execCommand('insertSoftTab');
+                }
+            },
+            'Shift-Tab'(cm) {
+                cm.indentSelection('subtract');
+            },
+        });
+    });
+});