@kerebron/editor 0.4.27 → 0.4.28

package/esm/plugins/input-rules/rulebuilders.d.ts

@@ -0,0 +1,6 @@
+import { Attrs, Node, NodeType } from 'prosemirror-model';
+import { InputRule } from './InputRulesPlugin.js';
+export declare function wrappingInputRule(regexp: RegExp, nodeType: NodeType, getAttrs?: Attrs | null | ((matches: RegExpMatchArray) => Attrs | null), joinPredicate?: (match: RegExpMatchArray, node: Node) => boolean): InputRule;
+export declare function textblockTypeInputRule(regexp: RegExp, nodeType: NodeType, getAttrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null)): InputRule;
+export declare function replaceInlineNode(regexp: RegExp, nodeType: NodeType, getAttrs?: Attrs | null | ((matches: RegExpMatchArray) => Attrs | null)): InputRule;
+//# sourceMappingURL=rulebuilders.d.ts.map

package/esm/plugins/input-rules/rulebuilders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rulebuilders.d.ts","sourceRoot":"","sources":["../../../src/plugins/input-rules/rulebuilders.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAY,IAAI,EAAE,QAAQ,EAAS,MAAM,mBAAmB,CAAC;AAE3E,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAiBlD,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,QAAQ,EAClB,QAAQ,GAAE,KAAK,GAAG,IAAI,GAAG,CAAC,CAAC,OAAO,EAAE,gBAAgB,KAAK,KAAK,GAAG,IAAI,CAAQ,EAC7E,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,EAAE,IAAI,EAAE,IAAI,KAAK,OAAO,aAmBjE;AAQD,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,QAAQ,EAClB,QAAQ,GAAE,KAAK,GAAG,IAAI,GAAG,CAAC,CAAC,KAAK,EAAE,gBAAgB,KAAK,KAAK,GAAG,IAAI,CAAQ,aAgB5E;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,QAAQ,EAClB,QAAQ,GAAE,KAAK,GAAG,IAAI,GAAG,CAAC,CAAC,OAAO,EAAE,gBAAgB,KAAK,KAAK,GAAG,IAAI,CAAQ,aAY9E"}

package/esm/plugins/input-rules/rulebuilders.js

@@ -0,0 +1,64 @@
+import { canJoin, findWrapping } from 'prosemirror-transform';
+import { Fragment, Slice } from 'prosemirror-model';
+import { InputRule } from './InputRulesPlugin.js';
+/// Build an input rule for automatically wrapping a textblock when a
+/// given string is typed. The `regexp` argument is
+/// directly passed through to the `InputRule` constructor. You'll
+/// probably want the regexp to start with `^`, so that the pattern can
+/// only occur at the start of a textblock.
+///
+/// `nodeType` is the type of node to wrap in. If it needs attributes,
+/// you can either pass them directly, or pass a function that will
+/// compute them from the regular expression match.
+///
+/// By default, if there's a node with the same type above the newly
+/// wrapped node, the rule will try to [join](#transform.Transform.join) those
+/// two nodes. You can pass a join predicate, which takes a regular
+/// expression match and the node before the wrapped node, and can
+/// return a boolean to indicate whether a join should happen.
+export function wrappingInputRule(regexp, nodeType, getAttrs = null, joinPredicate) {
+    return new InputRule(regexp, (state, match, start, end) => {
+        const attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
+        const tr = state.tr.delete(start, end);
+        const $start = tr.doc.resolve(start);
+        const range = $start.blockRange();
+        const wrapping = range && findWrapping(range, nodeType, attrs);
+        if (!wrapping)
+            return null;
+        tr.wrap(range, wrapping);
+        const before = tr.doc.resolve(start - 1).nodeBefore;
+        if (before && before.type == nodeType && canJoin(tr.doc, start - 1) &&
+            (!joinPredicate || joinPredicate(match, before))) {
+            tr.join(start - 1);
+        }
+        return tr;
+    });
+}
+/// Build an input rule that changes the type of a textblock when the
+/// matched text is typed into it. You'll usually want to start your
+/// regexp with `^` to that it is only matched at the start of a
+/// textblock. The optional `getAttrs` parameter can be used to compute
+/// the new node's attributes, and works the same as in the
+/// `wrappingInputRule` function.
+export function textblockTypeInputRule(regexp, nodeType, getAttrs = null) {
+    return new InputRule(regexp, (state, match, start, end) => {
+        const $start = state.doc.resolve(start);
+        const attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
+        if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), nodeType))
+            return null;
+        return state.tr
+            .delete(start, end)
+            .setBlockType(start, start, nodeType, attrs);
+    });
+}
+export function replaceInlineNode(regexp, nodeType, getAttrs = null) {
+    return new InputRule(regexp, (state, match, start, end) => {
+        const attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
+        const node = nodeType.createAndFill(attrs);
+        const slice = new Slice(Fragment.from(node), 0, 0);
+        const tr = state.tr;
+        const from = tr.mapping.map(start);
+        const to = tr.mapping.map(end);
+        return tr.replace(from, to, slice);
+    });
+}

package/esm/plugins/keymap/keymap.d.ts

@@ -0,0 +1,12 @@
+import { Plugin } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import type { Command } from '../../commands/types.js';
+export declare class KeymapPlugin extends Plugin {
+    constructor(bindings: {
+        [key: string]: Command;
+    });
+}
+export declare function keydownHandler(bindings: {
+    [key: string]: Command;
+}): (view: EditorView, event: KeyboardEvent) => boolean;
+//# sourceMappingURL=keymap.d.ts.map

package/esm/plugins/keymap/keymap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keymap.d.ts","sourceRoot":"","sources":["../../../src/plugins/keymap/keymap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAyEvD,qBAAa,YAAa,SAAQ,MAAM;gBAC1B,QAAQ,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE;CAGjD;AAKD,wBAAgB,cAAc,CAC5B,QAAQ,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,GACnC,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,aAAa,KAAK,OAAO,CA6BrD"}

package/esm/plugins/keymap/keymap.js

@@ -0,0 +1,125 @@
+import { Plugin } from 'prosemirror-state';
+import { base, keyName } from './w3c-keyname.js';
+const mac = typeof navigator != 'undefined' &&
+    /Mac|iP(hone|[oa]d)/.test(navigator?.platform);
+const windows = typeof navigator != 'undefined' &&
+    /Win/.test(navigator?.platform);
+function normalizeKeyName(name) {
+    let parts = name.split(/-(?!$)/), result = parts[parts.length - 1];
+    if (result == 'Space')
+        result = ' ';
+    let alt, ctrl, shift, meta;
+    for (let i = 0; i < parts.length - 1; i++) {
+        let mod = parts[i];
+        if (/^(cmd|meta|m)$/i.test(mod))
+            meta = true;
+        else if (/^a(lt)?$/i.test(mod))
+            alt = true;
+        else if (/^(c|ctrl|control)$/i.test(mod))
+            ctrl = true;
+        else if (/^s(hift)?$/i.test(mod))
+            shift = true;
+        else if (/^mod$/i.test(mod)) {
+            if (mac)
+                meta = true;
+            else
+                ctrl = true;
+        }
+        else
+            throw new Error('Unrecognized modifier name: ' + mod);
+    }
+    if (alt)
+        result = 'Alt-' + result;
+    if (ctrl)
+        result = 'Ctrl-' + result;
+    if (meta)
+        result = 'Meta-' + result;
+    if (shift)
+        result = 'Shift-' + result;
+    return result;
+}
+function normalize(map) {
+    let copy = Object.create(null);
+    for (let prop in map)
+        copy[normalizeKeyName(prop)] = map[prop];
+    return copy;
+}
+function modifiers(name, event, shift = true) {
+    if (event.altKey)
+        name = 'Alt-' + name;
+    if (event.ctrlKey)
+        name = 'Ctrl-' + name;
+    if (event.metaKey)
+        name = 'Meta-' + name;
+    if (shift && event.shiftKey)
+        name = 'Shift-' + name;
+    return name;
+}
+/// Create a keymap plugin for the given set of bindings.
+///
+/// Bindings should map key names to [command](#commands)-style
+/// functions, which will be called with `(EditorState, dispatch,
+/// EditorView)` arguments, and should return true when they've handled
+/// the key. Note that the view argument isn't part of the command
+/// protocol, but can be used as an escape hatch if a binding needs to
+/// directly interact with the UI.
+///
+/// Key names may be strings like `"Shift-Ctrl-Enter"`—a key
+/// identifier prefixed with zero or more modifiers. Key identifiers
+/// are based on the strings that can appear in
+/// [`KeyEvent.key`](https:///developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key).
+/// Use lowercase letters to refer to letter keys (or uppercase letters
+/// if you want shift to be held). You may use `"Space"` as an alias
+/// for the `" "` name.
+///
+/// Modifiers can be given in any order. `Shift-` (or `s-`), `Alt-` (or
+/// `a-`), `Ctrl-` (or `c-` or `Control-`) and `Cmd-` (or `m-` or
+/// `Meta-`) are recognized. For characters that are created by holding
+/// shift, the `Shift-` prefix is implied, and should not be added
+/// explicitly.
+///
+/// You can use `Mod-` as a shorthand for `Cmd-` on Mac and `Ctrl-` on
+/// other platforms.
+///
+/// You can add multiple keymap plugins to an editor. The order in
+/// which they appear determines their precedence (the ones early in
+/// the array get to dispatch first).
+export class KeymapPlugin extends Plugin {
+    constructor(bindings) {
+        super({ props: { handleKeyDown: keydownHandler(bindings) } });
+    }
+}
+/// Given a set of bindings (using the same format as
+/// [`keymap`](#keymap.keymap)), return a [keydown
+/// handler](#view.EditorProps.handleKeyDown) that handles them.
+export function keydownHandler(bindings) {
+    let map = normalize(bindings);
+    return function (view, event) {
+        let name = keyName(event), baseName, direct = map[modifiers(name, event)];
+        if (direct && direct(view.state, view.dispatch, view))
+            return true;
+        // A character key
+        if (name.length == 1 && name != ' ') {
+            if (event.shiftKey) {
+                // In case the name was already modified by shift, try looking
+                // it up without its shift modifier
+                let noShift = map[modifiers(name, event, false)];
+                if (noShift && noShift(view.state, view.dispatch, view))
+                    return true;
+            }
+            if ((event.altKey || event.metaKey || event.ctrlKey) &&
+                // Ctrl-Alt may be used for AltGr on Windows
+                !(windows && event.ctrlKey && event.altKey) &&
+                (baseName = base[event.keyCode]) && baseName != name) {
+                // Try falling back to the keyCode when there's a modifier
+                // active or the character produced isn't ASCII, and our table
+                // produces a different name from the the keyCode. See #668,
+                // #1060, #1529.
+                let fromCode = map[modifiers(baseName, event)];
+                if (fromCode && fromCode(view.state, view.dispatch, view))
+                    return true;
+            }
+        }
+        return false;
+    };
+}

package/esm/plugins/keymap/mod.d.ts

@@ -0,0 +1,2 @@
+export * from './keymap.js';
+//# sourceMappingURL=mod.d.ts.map

package/esm/plugins/keymap/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../src/plugins/keymap/mod.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/esm/plugins/keymap/mod.js

@@ -0,0 +1 @@
+export * from './keymap.js';

package/esm/plugins/keymap/w3c-keyname.d.ts

@@ -0,0 +1,4 @@
+export declare const base: Record<number, string>;
+export declare const shift: Record<number, string>;
+export declare function keyName(event: KeyboardEvent): string;
+//# sourceMappingURL=w3c-keyname.d.ts.map

package/esm/plugins/keymap/w3c-keyname.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"w3c-keyname.d.ts","sourceRoot":"","sources":["../../../src/plugins/keymap/w3c-keyname.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAqDvC,CAAC;AAEF,eAAO,MAAM,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAyBxC,CAAC;AAuBF,wBAAgB,OAAO,CAAC,KAAK,EAAE,aAAa,UAmB3C"}

package/esm/plugins/keymap/w3c-keyname.js

@@ -0,0 +1,124 @@
+export const base = {
+    8: 'Backspace',
+    9: 'Tab',
+    10: 'Enter',
+    12: 'NumLock',
+    13: 'Enter',
+    16: 'Shift',
+    17: 'Control',
+    18: 'Alt',
+    20: 'CapsLock',
+    27: 'Escape',
+    32: ' ',
+    33: 'PageUp',
+    34: 'PageDown',
+    35: 'End',
+    36: 'Home',
+    37: 'ArrowLeft',
+    38: 'ArrowUp',
+    39: 'ArrowRight',
+    40: 'ArrowDown',
+    44: 'PrintScreen',
+    45: 'Insert',
+    46: 'Delete',
+    59: ';',
+    61: '=',
+    91: 'Meta',
+    92: 'Meta',
+    106: '*',
+    107: '+',
+    108: ',',
+    109: '-',
+    110: '.',
+    111: '/',
+    144: 'NumLock',
+    145: 'ScrollLock',
+    160: 'Shift',
+    161: 'Shift',
+    162: 'Control',
+    163: 'Control',
+    164: 'Alt',
+    165: 'Alt',
+    173: '-',
+    186: ';',
+    187: '=',
+    188: ',',
+    189: '-',
+    190: '.',
+    191: '/',
+    192: '`',
+    219: '[',
+    220: '\\',
+    221: ']',
+    222: "'",
+};
+export const shift = {
+    48: ')',
+    49: '!',
+    50: '@',
+    51: '#',
+    52: '$',
+    53: '%',
+    54: '^',
+    55: '&',
+    56: '*',
+    57: '(',
+    59: ':',
+    61: '+',
+    173: '_',
+    186: ':',
+    187: '+',
+    188: '<',
+    189: '_',
+    190: '>',
+    191: '?',
+    192: '~',
+    219: '{',
+    220: '|',
+    221: '}',
+    222: '"',
+};
+const mac = typeof navigator != 'undefined' && /Mac/.test(navigator.platform);
+const ie = typeof navigator != 'undefined' &&
+    /MSIE \d|Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(navigator.userAgent);
+// Fill in the digit keys
+for (let i = 0; i < 10; i++)
+    base[48 + i] = base[96 + i] = String(i);
+// The function keys
+for (let i = 1; i <= 24; i++)
+    base[i + 111] = 'F' + i;
+// And the alphabetic keys
+for (let i = 65; i <= 90; i++) {
+    base[i] = String.fromCharCode(i + 32);
+    shift[i] = String.fromCharCode(i);
+}
+// For each code that doesn't have a shift-equivalent, copy the base name
+for (const code in base) {
+    if (!shift.hasOwnProperty(code))
+        shift[code] = base[code];
+}
+export function keyName(event) {
+    // On macOS, keys held with Shift and Cmd don't reflect the effect of Shift in `.key`.
+    // On IE, shift effect is never included in `.key`.
+    const ignoreKey = mac && event.metaKey && event.shiftKey && !event.ctrlKey && !event.altKey ||
+        ie && event.shiftKey && event.key && event.key.length == 1 ||
+        event.key == 'Unidentified';
+    let name = (!ignoreKey && event.key) ||
+        (event.shiftKey ? shift : base)[event.keyCode] ||
+        event.key || 'Unidentified';
+    // Edge sometimes produces wrong names (Issue #3)
+    if (name == 'Esc')
+        name = 'Escape';
+    if (name == 'Del')
+        name = 'Delete';
+    // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/8860571/
+    if (name == 'Left')
+        name = 'ArrowLeft';
+    if (name == 'Up')
+        name = 'ArrowUp';
+    if (name == 'Right')
+        name = 'ArrowRight';
+    if (name == 'Down')
+        name = 'ArrowDown';
+    return name;
+}

package/esm/search/mod.d.ts

@@ -0,0 +1,3 @@
+export * from './query.js';
+export * from './search.js';
+//# sourceMappingURL=mod.d.ts.map

package/esm/search/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/search/mod.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC"}

package/esm/search/mod.js

@@ -0,0 +1,2 @@
+export * from './query.js';
+export * from './search.js';

package/esm/search/query.d.ts

@@ -0,0 +1,45 @@
+import { EditorState } from 'prosemirror-state';
+import { Slice } from 'prosemirror-model';
+export declare class SearchQuery {
+    readonly search: string;
+    readonly caseSensitive: boolean;
+    readonly literal: boolean;
+    readonly regexp: boolean;
+    readonly replace: string;
+    readonly valid: boolean;
+    readonly wholeWord: boolean;
+    readonly filter: ((state: EditorState, result: SearchResult) => boolean) | null;
+    impl: QueryImpl;
+    constructor(config: {
+        search: string;
+        caseSensitive?: boolean;
+        literal?: boolean;
+        regexp?: boolean;
+        replace?: string;
+        wholeWord?: boolean;
+        filter?: (state: EditorState, result: SearchResult) => boolean;
+    });
+    eq(other: SearchQuery): boolean;
+    findNext(state: EditorState, from?: number, to?: number): SearchResult | null;
+    findPrev(state: EditorState, from?: number, to?: number): SearchResult | null;
+    checkResult(state: EditorState, result: SearchResult): boolean;
+    unquote(string: string): string;
+    getReplacements(state: EditorState, result: SearchResult): {
+        from: number;
+        to: number;
+        insert: Slice;
+    }[];
+}
+export interface SearchResult {
+    from: number;
+    to: number;
+    match: RegExpMatchArray | null;
+    matchStart: number;
+}
+interface QueryImpl {
+    findNext(state: EditorState, from: number, to: number): SearchResult | null;
+    findPrev(state: EditorState, from: number, to: number): SearchResult | null;
+}
+export declare function validRegExp(source: string): boolean;
+export {};
+//# sourceMappingURL=query.d.ts.map

package/esm/search/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/search/query.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAkB,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE1D,qBAAa,WAAW;IAEtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAIhC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAG1B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAGzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAGzB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IAGxB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAE5B,QAAQ,CAAC,MAAM,EACX,CAAC,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,KAAK,OAAO,CAAC,GACvD,IAAI,CAAC;IAGT,IAAI,EAAE,SAAS,CAAC;gBAGJ,MAAM,EAAE;QAElB,MAAM,EAAE,MAAM,CAAC;QAEf,aAAa,CAAC,EAAE,OAAO,CAAC;QAIxB,OAAO,CAAC,EAAE,OAAO,CAAC;QAElB,MAAM,CAAC,EAAE,OAAO,CAAC;QAEjB,OAAO,CAAC,EAAE,MAAM,CAAC;QAEjB,SAAS,CAAC,EAAE,OAAO,CAAC;QAGpB,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,KAAK,OAAO,CAAC;KAChE;IAiBD,EAAE,CAAC,KAAK,EAAE,WAAW;IAQrB,QAAQ,CACN,KAAK,EAAE,WAAW,EAClB,IAAI,GAAE,MAAU,EAChB,EAAE,GAAE,MAA+B;IAYrC,QAAQ,CACN,KAAK,EAAE,WAAW,EAClB,IAAI,GAAE,MAA+B,EACrC,EAAE,GAAE,MAAU;IAWhB,WAAW,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY;IAQpD,OAAO,CAAC,MAAM,EAAE,MAAM;IAgBtB,eAAe,CACb,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,YAAY,GACnB;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,KAAK,CAAA;KAAE,EAAE;CAuCjD;AAID,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,UAAU,SAAS;IACjB,QAAQ,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAAC;IAC5E,QAAQ,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAAC;CAC7E;AA8JD,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,WAOzC"}