qword 1.1.11 → 1.1.13

package/client/qword.js

@@ -0,0 +1,196 @@
+import '../css/qword.css';
+import * as smalltalk from 'smalltalk';
+import jssha from 'jssha';
+import load from 'load.js';
+import {createPatch} from 'daffy';
+import * as restafary from 'restafary/client';
+import {tryToCatch} from 'try-to-catch';
+import {tryCatch} from 'try-catch';
+import Editor from './editor.js';
+import Story from './story.js';
+import _clipboard from './_clipboard.js';
+import save from './save.js';
+import _initSocket from './_init-socket.js';
+import _onSave from './_on-save.js';
+import showMessage from './show-message.js';
+import loadRemote, {loadModules, loadOptions} from './loadremote.js';
+
+const isString = (a) => typeof a === 'string';
+
+const noop = () => {};
+
+export default function Qword(el, options, callback) {
+    if (isString(el))
+        el = document.querySelector(el);
+    
+    return new MainQword(el, options, callback);
+}
+
+class MainQword extends Editor {
+    constructor(element, options = {}, callback = noop) {
+        super(element, options);
+        
+        this._initSocket = _initSocket;
+        this._TITLE = 'Qword';
+        this._story = Story();
+        this._savedValue = '';
+        this._filename = '';
+        this._maxSize = options.maxSize || 512_000;
+        this._PREFIX = options.prefix || '/qword';
+        this._prefixSocket = options.prefixSocket || '/qword';
+        this._socketPath = options.socketPath || '';
+        
+        restafary.prefix(`${this._PREFIX}/api/v1/fs`);
+        this
+            ._init()
+            .then(() => callback(this));
+    }
+    
+    async _init() {
+        const [error, config] = await tryToCatch(load.json, `${this._PREFIX}/edit.json`);
+        
+        if (error)
+            return smalltalk.alert(this._TITLE, 'Could not load edit.json!');
+        
+        this._Config = config;
+        
+        await Promise.all([
+            loadOptions(this._PREFIX),
+            loadModules(this._PREFIX),
+        ]);
+        
+        await loadRemote('socket', {
+            prefix: this._socketPath,
+        });
+        this._initSocket();
+    }
+    
+    setValueFirst(name, value) {
+        this.setModeForPath(name);
+        this.setValue(value);
+        this._filename = name;
+        this._savedValue = value;
+        this.clearHistory();
+        this.moveCursorTo(0, 0);
+        
+        return this;
+    }
+    
+    sha() {
+        const sha = new jssha('SHA-1', 'TEXT');
+        sha.update(this.getValue());
+        
+        return sha.getHash('HEX');
+    }
+    
+    evaluate() {
+        if (!this._filename?.endsWith('.js'))
+            return smalltalk.alert(this._TITLE, 'JS only');
+        
+        const [error] = tryCatch(new Function(this.getValue()));
+        
+        if (error)
+            smalltalk.alert(this._TITLE, error.message);
+        
+        return this;
+    }
+    
+    goToLine() {
+        const number = Number(prompt('Line number'));
+        
+        if (!number)
+            return;
+        
+        const line = this._view.state.doc.line(number);
+        
+        this._view.dispatch({
+            selection: {
+                anchor: line.from,
+            },
+            scrollIntoView: true,
+        });
+        this.focus();
+    }
+    
+    remove(direction) {
+        const {state} = this._view;
+        const {from, to} = state.selection.main;
+        const isCollapsed = from === to;
+        
+        if (direction === 'right') {
+            const end = isCollapsed ? to + 1 : to;
+            
+            this._view.dispatch({
+                changes: {
+                    from,
+                    to: end,
+                    insert: '',
+                },
+            });
+        } else {
+            const start = isCollapsed ? from - 1 : from;
+            
+            if (start >= 0)
+                this._view.dispatch({
+                    changes: {
+                        from: start,
+                        to,
+                        insert: '',
+                    },
+                });
+        }
+        
+        return this;
+    }
+    
+    selectAll() {
+        const {doc} = this._view.state;
+        
+        this._view.dispatch({
+            selection: {
+                anchor: 0,
+                head: doc.length,
+            },
+        });
+        
+        return this;
+    }
+    
+    enableKey() {
+        return this;
+    }
+    
+    cutToClipboard() {
+        return this._clipboard('cut');
+    }
+    
+    copyToClipboard() {
+        return this._clipboard('copy');
+    }
+    
+    pasteFromClipboard() {
+        return this._clipboard('paste');
+    }
+    
+    _patchHttp(path, patch) {
+        restafary.patch(path, patch, this._onSave.bind(this));
+    }
+    
+    _writeHttp(path, data) {
+        restafary.write(path, data, this._onSave.bind(this));
+    }
+    
+    async _doDiff(path) {
+        const equal = await this
+            ._story
+            .checkHash(path)
+            .catch(() => false);
+        
+        return equal ? '' : createPatch(this._savedValue || '', this.getValue());
+    }
+}
+
+Qword.prototype._clipboard = _clipboard;
+Qword.prototype.save = save;
+Qword.prototype._onSave = _onSave;
+Qword.prototype.showMessage = showMessage;

package/client/save.js

@@ -0,0 +1,53 @@
+import wraptile from 'wraptile';
+import {promisify} from 'es6-promisify';
+import _zipio from 'zipio';
+
+const isString = (a) => typeof a === 'string';
+const zipio = promisify(_zipio);
+
+const setValue = wraptile(_setValue);
+
+export default function() {
+    save
+        .call(this)
+        .then(setValue(this))
+        .catch(this._onSave.bind(this));
+    
+    return this;
+}
+
+async function save() {
+    const value = this.getValue();
+    const {length} = value;
+    const {_FileName: _filename, _maxSize} = this;
+    
+    const {diff, zip} = await this._loadOptions();
+    
+    if (diff) {
+        const patch = await this._doDiff(_filename);
+        const isPatch = checkPatch(length, _maxSize, patch);
+        
+        if (isPatch)
+            return this._patch(_filename, patch);
+    }
+    
+    if (!zip)
+        return this._write(_filename, value);
+    
+    const zippedValue = await zipio(value);
+    
+    return this._write(`${_filename}?unzip`, zippedValue);
+}
+
+function _setValue(ctx) {
+    ctx._Value = ctx.getValue();
+}
+
+function checkPatch(length, maxSize, patch) {
+    const patchLength = patch?.length || 0;
+    const isLessMaxLength = length < maxSize;
+    const isLessLength = isLessMaxLength && patchLength < length;
+    const isStr = isString(patch);
+    
+    return patch && isStr && isLessLength;
+}

package/client/scroll.d.ts

@@ -0,0 +1,11 @@
+import type {EditorView} from '@codemirror/view';
+
+export type ScrollInfo = {
+    left: number;
+    top: number;
+};
+
+export const getScrollInfo: (view: EditorView) => ScrollInfo;
+
+export function scrollTo(view: EditorView, left: number, top: number): void;
+

package/client/scroll.js

@@ -0,0 +1,9 @@
+export const getScrollInfo = (view) => ({
+    left: view.scrollDOM.scrollLeft,
+    top: view.scrollDOM.scrollTop,
+});
+
+export function scrollTo(view, left, top) {
+    view.scrollDOM.scrollLeft = left;
+    view.scrollDOM.scrollTop = top;
+}

package/client/show-message.js

@@ -0,0 +1,30 @@
+import createElement from '@cloudcmd/create-element';
+
+function createMsg() {
+    const innerHTML = '<div class="dword-msg">/div>';
+    const wrapper = createElement('div', {
+        innerHTML,
+    });
+    
+    return wrapper.firstChild;
+}
+
+export default showMessage;
+
+function showMessage(text) {
+    const HIDE_TIME = 2000;
+    
+    if (!this._ElementMsg) {
+        this._ElementMsg = createMsg();
+        this._Element.appendChild(this._ElementMsg);
+    }
+    
+    this._ElementMsg.textContent = text;
+    this._ElementMsg.hidden = false;
+    
+    setTimeout(() => {
+        this._ElementMsg.hidden = true;
+    }, HIDE_TIME);
+    
+    return this;
+}

package/client/story.js

@@ -0,0 +1,55 @@
+import {promisify} from 'es6-promisify';
+import * as restafary from 'restafary/client';
+
+export default Story;
+
+function Story() {
+    if (!(this instanceof Story))
+        return new Story();
+}
+
+Story.prototype.checkHash = async function(name) {
+    const loadHash = await this.loadHash(name);
+    const nameHash = `${name}-hash`;
+    const storeHash = localStorage.getItem(nameHash);
+    
+    return loadHash === storeHash;
+};
+
+Story.prototype.loadHash = promisify(function(name, callback) {
+    const query = '?hash';
+    
+    restafary.read(name + query, callback);
+    
+    return this;
+});
+
+Story.prototype.setData = function(name, data) {
+    const nameData = `${name}-data`;
+    
+    localStorage.setItem(nameData, data);
+    
+    return this;
+};
+
+Story.prototype.setHash = function(name, hash) {
+    const nameHash = `${name}-hash`;
+    
+    localStorage.setItem(nameHash, hash);
+    
+    return this;
+};
+
+Story.prototype.getData = function(name) {
+    const nameData = `${name}-data`;
+    const data = localStorage.getItem(nameData);
+    
+    return data || '';
+};
+
+Story.prototype.getHash = function(name) {
+    const item = `${name}-hash`;
+    const data = localStorage.getItem(item);
+    
+    return data || '';
+};

package/client/types.d.ts

@@ -0,0 +1,28 @@
+// Character offset into source text (0-indexed, matches CM6) — same convention as putout-editor's codemirror-adapter.
+export type CharOffset = number;
+
+// Line/column position — matches CodeMirror's {line, ch} convention.
+export type SourcePosition = {
+    line: number;
+    ch: number;
+};
+
+// CodeMirror editor mode string — e.g. 'javascript', 'json', 'html'.
+export type EditorMode = string;
+
+// CodeMirror key map name.
+export type KeyMap =
+    | 'vim'
+    | 'emacs'
+    | 'sublime'
+    | 'default';
+
+// Editor theme name.
+export type EditorTheme =
+    | 'nord'
+    | 'default'
+    | 'dark'
+    | 'one-dark';
+
+// JavaScript/TypeScript source code.
+export type SourceCode = string;