qword 1.1.11 → 1.1.13

package/ChangeLog

@@ -1,3 +1,13 @@
+2026.09.07, v1.1.13
+
+fix:
+- d53dfd5 client: options: keepIndent on double enter
+
+2026.09.07, v1.1.12
+
+fix:
+- ee42e43 npmignore
+
 2026.09.07, v1.1.11
 
 fix:

package/bower.json

@@ -0,0 +1,25 @@
+{
+    "name": "dword",
+    "homepage": "https://github.com/cloudcmd/dword",
+    "authors": [
+        "coderaiser <mnemonic.enemy@gmail.com>"
+    ],
+    "description": "web editor",
+    "main": "bin/dword.js",
+    "keywords": [
+        "file",
+        "edit"
+    ],
+    "license": "MIT",
+    "private": true,
+    "ignore": [
+        "node_modules",
+        "modules"
+    ],
+    "dependencies": {
+        "codemirror-emmet": "~1.1.0",
+        "cm-searchbox": "1.0.8",
+        "cm-show-invisibles": "^3.1.0",
+        "jshint": "^2.13.5"
+    }
+}

package/client/_clipboard.js

@@ -0,0 +1,50 @@
+import clipboard from '@cloudcmd/clipboard';
+import once from 'once';
+import showMessage from './show-message.js';
+
+const showMessageOnce = once(showMessage);
+
+export default function clipboardCommand(command) {
+    const {_view, _story} = this;
+    const NAME = 'editor-clipboard';
+    
+    const getSelected = () => {
+        const {from, to} = _view.state.selection.main;
+        return _view.state.sliceDoc(from, to);
+    };
+    
+    const insert = (text) => {
+        const {from, to} = _view.state.selection.main;
+        
+        _view.dispatch({
+            changes: {
+                from,
+                to,
+                insert: text,
+            },
+        });
+    };
+    
+    if (command === 'copy') {
+        const value = getSelected();
+        _story.setData(NAME, value);
+        
+        return clipboard.writeText(value);
+    }
+    
+    if (command === 'cut') {
+        const value = getSelected();
+        _story.setData(NAME, value);
+        insert('');
+        
+        return clipboard.writeText(value);
+    }
+    
+    return clipboard
+        .readText()
+        .then(insert)
+        .catch(() => {
+            showMessageOnce.call(this, 'Could not paste from clipboard. Inner buffer used.');
+            insert(_story.getData(NAME));
+        });
+}

package/client/_init-socket.js

@@ -0,0 +1,76 @@
+import {applyPatch} from 'daffy';
+import {alert} from 'smalltalk';
+
+const getHost = () => {
+    const l = location;
+    
+    return l.origin || l.protocol + '//' + l.host;
+};
+
+export default function() {
+    const qword = this;
+    const href = getHost();
+    const FIVE_SECONDS = 5000;
+    
+    const patch = (name, data) => {
+        socket.emit('patch', name, data);
+    };
+    
+    const {_prefixSocket} = qword;
+    
+    const socket = globalThis.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', () => {
+        qword._patch = patch;
+    });
+    
+    socket.on('message', (msg) => {
+        this._onSave(null, msg);
+    });
+    
+    socket.on('file', (name, data) => {
+        qword
+            .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 = qword.getCursor();
+        const value = qword.getValue();
+        const result = applyPatch(value, data);
+        
+        this.setValue(result);
+        
+        this
+            ._story
+            .setData(name, value)
+            .setHash(name, this.sha());
+        
+        qword.moveCursorTo(cursor.row, cursor.column);
+    });
+    
+    socket.on('disconnect', () => {
+        qword.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/content.d.ts

@@ -0,0 +1,8 @@
+import type {EditorView} from '@codemirror/view';
+import type {SourceCode} from './types.js';
+
+export function getValue(view: EditorView): SourceCode;
+export const getDocValue: typeof getValue;
+
+export function setValue(view: EditorView, value: SourceCode): void;
+export const setDocValue: typeof setValue;

package/client/content.js

@@ -0,0 +1,14 @@
+export const getValue = (view) => view.state.doc.toString();
+export const getDocValue = getValue;
+
+export function setValue(view, value) {
+    view.dispatch({
+        changes: {
+            from: 0,
+            to: view.state.doc.length,
+            insert: value,
+        },
+    });
+}
+
+export const setDocValue = setValue;

package/client/create.d.ts

@@ -0,0 +1,33 @@
+import {Compartment} from '@codemirror/state';
+import {type ViewUpdate, EditorView} from '@codemirror/view';
+import type {
+    SourceCode,
+    KeyMap,
+    EditorMode,
+    EditorTheme,
+} from './types.js';
+
+export type CreateEditorOptions = {
+    value?: SourceCode;
+    mode?: EditorMode | {
+        name: EditorMode;
+        json?: boolean;
+    };
+    keyMap?: KeyMap;
+    theme?: EditorTheme;
+    lineNumbers?: boolean;
+    readOnly?: boolean;
+    foldGutter?: boolean;
+    updateListener?: (update: ViewUpdate) => void;
+};
+
+// Augmented EditorView with compartment refs for dynamic option changes.
+export type QwordEditorView = EditorView & {
+    _themeCompartment: Compartment;
+    _keymapCompartment: Compartment;
+    _langCompartment: Compartment;
+    _historyCompartment: Compartment;
+};
+
+export function createEditor(element: Element, options?: CreateEditorOptions): QwordEditorView;
+

package/client/create.js

@@ -0,0 +1,101 @@
+import {EditorState, Compartment} from '@codemirror/state';
+import {
+    EditorView,
+    lineNumbers as lineNumbersExtension,
+    drawSelection,
+    keymap,
+} from '@codemirror/view';
+import {history, historyKeymap} from '@codemirror/commands';
+import {
+    foldGutter,
+    codeFolding,
+    syntaxHighlighting,
+    indentOnInput,
+    indentUnit,
+    bracketMatching,
+} from '@codemirror/language';
+import {highlightStyle} from './highlight.js';
+import {
+    keymapExtension,
+    themeExtension,
+    languageExtension,
+} from './options.js';
+import {markField, lineField} from './decorations.js';
+
+export function createEditor(element, options = {}) {
+    const {
+        value = '',
+        mode = 'javascript',
+        keyMap = 'default',
+        theme = 'default',
+        lineNumbers = true,
+        readOnly = false,
+        foldGutter: fold = false,
+        updateListener,
+    } = options;
+    
+    const themeCompartment = new Compartment();
+    const keymapCompartment = new Compartment();
+    const langCompartment = new Compartment();
+    const historyCompartment = new Compartment();
+    
+    const hideCursorOnBlur = EditorView.theme({
+        '&:not(.cm-focused) .cm-fat-cursor': {
+            display: 'none',
+        },
+    });
+    
+    const extensions = [
+        historyCompartment.of([
+            history(),
+            keymap.of(historyKeymap),
+        ]),
+        markField,
+        lineField,
+        themeCompartment.of(themeExtension(theme)),
+        keymapCompartment.of(keymapExtension(keyMap)),
+        bracketMatching(),
+        langCompartment.of(languageExtension(mode)),
+        syntaxHighlighting(highlightStyle),
+        indentOnInput(),
+        indentUnit.of('    '),
+        ...lineNumbers
+            ? [
+                lineNumbersExtension(),
+            ]
+            : [],
+        ...fold
+            ? [
+                foldGutter(),
+                codeFolding(),
+            ]
+            : [],
+        ...readOnly
+            ? [
+                EditorState.readOnly.of(true),
+            ]
+            : [],
+        ...updateListener
+            ? [
+                EditorView.updateListener.of(updateListener),
+            ]
+            : [],
+        drawSelection(),
+        hideCursorOnBlur,
+    ];
+    
+    const view = new EditorView({
+        state: EditorState.create({
+            doc: value,
+            extensions,
+        }),
+        parent: element,
+    });
+    
+    view._themeCompartment = themeCompartment;
+    view._keymapCompartment = keymapCompartment;
+    view._langCompartment = langCompartment;
+    view._historyCompartment = historyCompartment;
+    
+    return view;
+}

package/client/decorations.d.ts

@@ -0,0 +1,38 @@
+import {
+    type Range,
+    StateEffect,
+    StateField,
+} from '@codemirror/state';
+import {
+    Decoration,
+    EditorView,
+    type DecorationSet,
+} from '@codemirror/view';
+import type {SourcePosition} from './types.js';
+
+export const setMarkEffect: StateEffect<Range<Decoration>>;
+export const clearMarkEffect: StateEffect<null>;
+export const setLineEffect: StateEffect<{
+    line: number;
+    cls: string;
+}>;
+export const clearLineEffect: StateEffect<{
+    line: number;
+    cls: string;
+}>;
+
+export const markField: StateField<DecorationSet>;
+export const lineField: StateField<DecorationSet>;
+
+export type MarkHandle = {
+    clear: () => void;
+};
+
+export function markText(view: EditorView, from: SourcePosition, to: SourcePosition, {className}: {
+    className: string;
+}): MarkHandle;
+
+export function addLineClass(view: EditorView, line: number, _where: string, className: string): void;
+
+export function removeLineClass(view: EditorView, line: number, _where: string, className: string): void;
+

package/client/decorations.js

@@ -0,0 +1,110 @@
+import {StateEffect, StateField} from '@codemirror/state';
+import {EditorView, Decoration} from '@codemirror/view';
+import {positionToOffset} from './position.js';
+
+const noop = () => {};
+
+export const setMarkEffect = StateEffect.define();
+export const clearMarkEffect = StateEffect.define();
+export const setLineEffect = StateEffect.define();
+export const clearLineEffect = StateEffect.define();
+
+export const markField = StateField.define({
+    create: () => Decoration.none,
+    update(decorations, transaction) {
+        decorations = decorations.map(transaction.changes);
+        
+        for (const effect of transaction.effects) {
+            if (effect.is(setMarkEffect))
+                decorations = decorations.update({
+                    add: [effect.value],
+                    sort: true,
+                });
+            
+            if (effect.is(clearMarkEffect))
+                decorations = Decoration.none;
+        }
+        
+        return decorations;
+    },
+    provide: (field) => EditorView.decorations.from(field),
+});
+
+export const lineField = StateField.define({
+    create: () => Decoration.none,
+    update(decorations, transaction) {
+        decorations = decorations.map(transaction.changes);
+        
+        for (const effect of transaction.effects) {
+            if (effect.is(setLineEffect)) {
+                const {line, cls} = effect.value;
+                const {from} = transaction.state.doc.line(Math.min(line + 1, transaction.state.doc.lines));
+                
+                decorations = decorations.update({
+                    add: [
+                        Decoration
+                            .line({
+                                class: cls,
+                            })
+                            .range(from),
+                    ],
+                    sort: true,
+                });
+            }
+            
+            if (effect.is(clearLineEffect)) {
+                const {line, cls} = effect.value;
+                
+                decorations = decorations.update({
+                    filter: (from, _, decoration) => !(decoration.spec.class === cls && transaction.state.doc.lineAt(from).number === line + 1),
+                });
+            }
+        }
+        
+        return decorations;
+    },
+    provide: (field) => EditorView.decorations.from(field),
+});
+
+export function markText(view, from, to, {className}) {
+    const fromOffset = positionToOffset(view.state.doc, from);
+    const toOffset = positionToOffset(view.state.doc, to);
+    
+    if (fromOffset === toOffset)
+        return {
+            clear: noop,
+        };
+    
+    const decoration = Decoration
+        .mark({
+            class: className,
+        })
+        .range(fromOffset, toOffset);
+    
+    view.dispatch({
+        effects: setMarkEffect.of(decoration),
+    });
+    return {
+        clear: () => view.dispatch({
+            effects: clearMarkEffect.of(null),
+        }),
+    };
+}
+
+export function addLineClass(view, line, _where, className) {
+    view.dispatch({
+        effects: setLineEffect.of({
+            line,
+            cls: className,
+        }),
+    });
+}
+
+export function removeLineClass(view, line, _where, className) {
+    view.dispatch({
+        effects: clearLineEffect.of({
+            line,
+            cls: className,
+        }),
+    });
+}

package/client/dom.d.ts

@@ -0,0 +1,8 @@
+import {EditorView} from '@codemirror/view';
+
+export function getView(container: HTMLElement): EditorView | null;
+
+export function refresh(view: EditorView): void;
+
+export function observeResize(view: EditorView, container: Element): () => void;
+

package/client/dom.js

@@ -0,0 +1,17 @@
+import {EditorView} from '@codemirror/view';
+
+export function getView(container) {
+    const element = container.querySelector('.cm-editor');
+    return element ? EditorView.findFromDOM(element) : null;
+}
+
+export function refresh(view) {
+    view.requestMeasure();
+}
+
+export function observeResize(view, container) {
+    const observer = new ResizeObserver(() => view.requestMeasure());
+    observer.observe(container);
+    
+    return () => observer.disconnect();
+}

package/client/editor.d.ts

@@ -0,0 +1,46 @@
+import {
+    type QwordEditorView,
+    type CreateEditorOptions,
+} from './create.js';
+import type {MarkHandle} from './decorations.js';
+import type {OptionKey, OptionValue} from './options.js';
+import type {
+    SourceCode,
+    SourcePosition,
+    CharOffset,
+    KeyMap,
+    EditorMode,
+    EditorTheme,
+} from './types.js';
+
+export type EditorOptions = CreateEditorOptions;
+
+export default class Editor {
+    constructor(element: Element, options?: EditorOptions);
+    getValue(): SourceCode;
+    setValue(value: SourceCode): this;
+    getCursorIndex(): CharOffset;
+    getCursor(): {
+        row: number;
+        column: number;
+    };
+    posFromIndex(index: CharOffset): SourcePosition;
+    focus(): this;
+    moveCursorTo(row: number, column?: number): this;
+    markRange(from: SourcePosition, to: SourcePosition, className: string): MarkHandle;
+    addLineClass(line: number, className: string): this;
+    removeLineClass(line: number, className: string): this;
+    setOption(name: OptionKey, value: OptionValue): this;
+    setMode(mode: EditorMode): this;
+    setTheme(theme: EditorTheme): this;
+    setKeyMap(name: KeyMap): this;
+    setModeForPath(path: string): this;
+    isChanged(): boolean;
+    clearHistory(): this;
+    on(event: string, handler: (...args: unknown[]) => void): this;
+    addListener(event: string, handler: (...args: unknown[]) => void): this;
+    once(event: string, handler: (...args: unknown[]) => void): this;
+    removeListener(event: string, handler: (...args: unknown[]) => void): this;
+    emit(...args: unknown[]): this;
+    _view(): QwordEditorView;
+}