edytor 0.0.1 → 0.0.6

package/dist/events/onKeyDown.d.ts

@@ -1,2 +1,69 @@
 import { Editor } from "../types";
 export declare const onKeyDown: (editor: Editor, e: KeyboardEvent) => any;
+export declare const defaultHotkeys: ({
+    operation: string;
+    keys: string;
+    mark: {
+        bold: boolean;
+        italic?: undefined;
+        underline?: undefined;
+        code?: undefined;
+        strikethrough?: undefined;
+        highlight?: undefined;
+    };
+} | {
+    operation: string;
+    keys: string;
+    mark: {
+        italic: boolean;
+        bold?: undefined;
+        underline?: undefined;
+        code?: undefined;
+        strikethrough?: undefined;
+        highlight?: undefined;
+    };
+} | {
+    operation: string;
+    keys: string;
+    mark: {
+        underline: boolean;
+        bold?: undefined;
+        italic?: undefined;
+        code?: undefined;
+        strikethrough?: undefined;
+        highlight?: undefined;
+    };
+} | {
+    operation: string;
+    keys: string;
+    mark: {
+        code: boolean;
+        bold?: undefined;
+        italic?: undefined;
+        underline?: undefined;
+        strikethrough?: undefined;
+        highlight?: undefined;
+    };
+} | {
+    operation: string;
+    keys: string;
+    mark: {
+        strikethrough: boolean;
+        bold?: undefined;
+        italic?: undefined;
+        underline?: undefined;
+        code?: undefined;
+        highlight?: undefined;
+    };
+} | {
+    operation: string;
+    keys: string;
+    mark: {
+        highlight: boolean;
+        bold?: undefined;
+        italic?: undefined;
+        underline?: undefined;
+        code?: undefined;
+        strikethrough?: undefined;
+    };
+})[];

package/dist/operations/deleteText.d.ts

@@ -3,5 +3,5 @@ declare type deleteTextOpts = {
     mode: "forward" | "backward" | "none";
     selection?: EdytorSelection;
 };
-export declare const deleteText: (editor: Editor, { mode, selection }: deleteTextOpts) => any;
+export declare const deleteText: (editor: Editor, { mode, selection }: deleteTextOpts) => void;
 export {};

package/dist/operations/formatText.d.ts

@@ -1,6 +1,5 @@
 import { YMap, YText } from "yjs/dist/src/internals";
 import { Editor, Position, EdytorSelection } from "../types";
-import { YLeaf } from "../utils";
 export declare type formatTextOperation = {
     at?: Position;
     value: any;
@@ -17,5 +16,5 @@ export declare type formatAtEqualPathOperation = {
     data?: object;
 };
 export declare const applyMarksFromParent: (parent: YMap<any>, leafs: YMap<any>[]) => void;
-export declare const formatAtEqualPath: ({ format, value, start, end }: formatAtEqualPathOperation) => YLeaf;
+export declare const formatAtEqualPath: ({ format, value, start, end }: formatAtEqualPathOperation) => import("../types").YLeaf;
 export declare const formatText: (editor: Editor, mark: Record<string, any>) => number;

package/dist/operations/splitLeaf.d.ts

@@ -1,8 +1,2 @@
-import { YText } from "yjs/dist/src/internals";
-import { Editor, Position } from "../types";
-declare type splitLeafOperation = {
-    yText: YText;
-    at: Position;
-};
-export declare const splitLeaf: (editor: Editor | Pick<Editor, "toYJS">, { yText, at }: splitLeafOperation) => void;
-export {};
+import { Editor } from "../types";
+export declare const splitLeaf: (editor: Editor) => void;

package/dist/types.d.ts

@@ -1,8 +1,10 @@
 import { YArray, YMap } from "yjs/dist/src/internals";
-import { Cursor, EdytorDoc } from ".";
-import { Dropper, EdytorSelection, jsonNode, YLeaf, YNode } from "./utils";
+import { EdytorDoc } from ".";
+import { Dropper, EdytorSelection, jsonNode, YNode } from "./utils";
+import * as awarenessProtocol from "y-protocols/awareness";
 export { EdytorSelection };
 declare type Accessor<T> = () => T;
+export declare type YLeaf = YMap<any>;
 export declare type dataEdytorType = "data-edytor-block" | "data-edytor-leave";
 export declare type attributes = {
     id: string;
@@ -38,12 +40,35 @@ interface HotKeys {
     keys: string;
     mark: Record<string, any>;
 }
+declare type DNDProps = {
+    canNest?: (block: YMap<any>, path: number[]) => boolean;
+    active: boolean;
+    renderIndicator: () => any;
+    onExternalDrop?: (files: any) => any;
+    accept?: string[];
+    afterDrop?: (editor: Editor, from: any, to: any) => void;
+};
 export interface EditorProps extends Record<any, any> {
     allowNesting: boolean;
+    children: any;
     initialValue: {
         json?: jsonNode[];
         yarray?: YArray<any>;
     };
+    dnd?: DNDProps;
+    collaboration: {
+        awarenessId?: string;
+        awareness?: awarenessProtocol.Awareness;
+        url: string;
+        room: string;
+        user?: {
+            color?: string;
+            name?: string;
+            id?: string | number;
+            picture?: string;
+        };
+    };
+    onMount?: (editor: Editor) => void;
     leaves: Record<string, keyof HTMLElementTagNameMap> | Record<string, any>;
     blocks: Record<string, keyof HTMLElementTagNameMap> | Record<string, any>;
     defaultBlock?: string;
@@ -55,30 +80,27 @@ export interface EditorProps extends Record<any, any> {
     renderBefore?: () => any;
     renderAfter?: () => any;
     onChange?: (editor: Editor) => void;
-    renderBlock?: ({ attributes, children, block }: renderBlockProps) => any;
-    renderLeaf?: ({ attributes, string, leaf }: renderLeafProps) => any;
 }
+export declare type EditorWithChildren = Pick<Editor, "children">;
 export interface Editor {
     allowNesting: boolean;
     readOnly: boolean;
     editorId: string;
     defaultBlock: string;
+    awareness?: awarenessProtocol.Awareness;
+    dnd?: DNDProps;
     dropper: Dropper;
     hotkeys?: HotKeys[];
     selection: EdytorSelection;
-    cursor: () => Cursor | undefined;
     leaves: Record<string, keyof HTMLElementTagNameMap> | Record<string, any>;
     blocks: Record<string, keyof HTMLElementTagNameMap> | Record<string, any>;
     renderHandle: (({ node, attributes }: renderHandleProps) => any) | undefined;
     undoManager: any;
-    editorRef: Accessor<HTMLDivElement | undefined>;
-    toUpdate: () => Uint8Array;
+    editorRef: HTMLDivElement | undefined;
     doc: EdytorDoc;
-    config: YMap<any>;
+    toRawText: () => string;
     toJSON: () => jsonNode[];
     ID_TO_NODE: Map<string, YMap<any>>;
-    ID_TO_MAP: WeakMap<any, any>;
-    MAP_TO_ID: WeakMap<any, any>;
     children: YArray<any>;
 }
 export interface Value {

package/dist/utils/common.d.ts

@@ -1,8 +1,17 @@
-import { YMap } from "yjs/dist/src/internals";
+import { YArray, YMap } from "yjs/dist/src/internals";
+import { Editor, EditorWithChildren, YLeaf } from "../types";
 export declare const nanoid: () => string;
 declare type YNode = YMap<any>;
 export declare const getNode: (node: any) => YNode;
 export declare const getIndex: (node: YNode) => number;
 export declare const getPath: (node: YNode) => number[];
 export declare const getId: (node: any) => string;
+export declare const getLeafAtPath: (editor: Editor | EditorWithChildren, [start, ...path]: number[]) => YLeaf;
+export declare const getNodeAtPath: (editor: Editor, [start, ...path]: number[]) => YNode;
+export declare const getContainerAtPath: (editor: Editor, path: number[]) => YArray<any>;
+export declare const traverse: (editor: Editor | EditorWithChildren, cb: (node: YMap<any>, isText: boolean, path: number[]) => void, opts?: {
+    start?: number;
+    end?: number;
+}) => void;
+export declare const toString: (editor: Editor | EditorWithChildren) => string;
 export {};

package/dist/utils/dropper.d.ts

@@ -1,16 +1,18 @@
-import { EdytorSelection } from "../types";
+import { Editor, EdytorSelection } from "../types";
 import { EdytorDoc } from "./yClasses";
 export declare class Dropper {
     from: any;
     to: any;
     node: any;
     startPath: any;
+    container: HTMLDivElement;
+    editor: Editor;
     doc: EdytorDoc;
     editorId: string;
     ID_TO_NODE: Map<any, any>;
     selection: EdytorSelection;
     allowNesting: boolean;
-    constructor(doc: EdytorDoc, editorId: string, ID_TO_NODE: Map<any, any>, selection: EdytorSelection, allowNesting: boolean);
+    init: (editor: any, container: any) => void;
     startDrag: (node: any, e: DragEvent) => void;
     dragEnd: () => void;
     getHoveredNode: (target: HTMLElement) => {

package/dist/utils/index.d.ts

@@ -1,8 +1,6 @@
-export * from "./getSelection";
-export * from "./cursor";
 export * from "./yClasses/index";
 export * from "./leaves";
 export * from "./nodes";
 export * from "./common";
 export * from "./dropper";
-export * from "./Selection/EdytorSelection";
+export * from "./selection";

package/dist/utils/nodes.d.ts

@@ -1,7 +1,7 @@
-import { YArray } from "yjs/dist/src/internals";
+import { YArray, YMap } from "yjs/dist/src/internals";
 import { Editor } from "../types";
 import { YNode } from "./yClasses";
-export declare const mergeContentWithPrevLeaf: (editor: Editor) => void;
+export declare const mergeContentWithPrevLeaf: (editor: Editor) => any[];
 export declare const mergeContentWithNextLeaf: (editor: Editor) => any;
 export declare const deleteNode: (node: any, defaultBlock: string) => void;
 export declare const getNodeContainer: (node: any) => YArray<YNode>;
@@ -10,4 +10,5 @@ export declare const getNodeContent: (node: any) => YArray<YNode>;
 export declare const hasChildren: (node: any) => boolean;
 export declare const isNodeEmpty: (node: any) => boolean;
 export declare const isNodeContentEmpty: (node: any) => boolean;
-export declare const copyNode: (node: YNode) => YNode;
+export declare const copyNode: (node: YNode) => YMap<any>;
+export declare const nodeString: (node: YNode) => string;

package/dist/utils/{Selection/EdytorSelection.d.ts → selection.d.ts}

@@ -1,10 +1,14 @@
-import { Position } from "../..";
-import { YLeaf, YNode } from "../yClasses";
+import { Editor, Position, YLeaf } from "../types";
+import { YNode } from ".";
 export declare class EdytorSelection {
-    onSelectionChange?: (selection: EdytorSelection) => void;
+    editor: Editor;
     observers: ((selection: EdytorSelection) => void)[];
     container: HTMLDivElement;
-    ID_TO_NODE: Map<any, any>;
+    collaborationPosition: {
+        node: string;
+        leaf: string;
+        offset: number;
+    };
     start: Position;
     end: Position;
     selectedText: string;
@@ -14,6 +18,8 @@ export declare class EdytorSelection {
     range?: Range;
     boundingRect?: DOMRect;
     edges: {
+        startDocument: boolean;
+        endDocument: boolean;
         startLeaf: boolean;
         startNode: boolean;
         endLeaf: boolean;
@@ -22,8 +28,8 @@ export declare class EdytorSelection {
     selection?: Selection;
     focused: boolean;
     type?: "multinodes" | "collapsed" | "singlenode" | "multileaves" | "notInDoc";
-    constructor(ID_TO_NODE: Map<any, any>, onSelectionChange?: (selection: EdytorSelection) => void);
-    init: (container: any) => void;
+    constructor();
+    init: (editor: Editor, container: any) => void;
     onFocus: () => void;
     onBlur: () => void;
     destroy: () => void;

package/dist/utils/yClasses/EdytorDoc.d.ts

@@ -1,6 +1,5 @@
 import { Doc } from "yjs";
-import { YArray, YMap } from "yjs/dist/src/internals";
-import { YLeaf, YNode } from ".";
+import { YNode } from ".";
 export interface jsonLeaf extends Record<string, any> {
     text: string;
     data?: object;
@@ -11,23 +10,7 @@ export declare type jsonNode = {
     data?: object;
     children?: jsonNode[];
 };
-export declare const getContent: (leaf: jsonLeaf) => YLeaf;
 export declare const getChildren: ({ type, content, children, ...props }: jsonNode) => YNode;
 export declare class EdytorDoc extends Doc {
-    children: YArray<YNode>;
-    config: YMap<any>;
-    constructor(value?: jsonNode[]);
-    getLeafAtPath: ([start, ...path]: number[]) => YLeaf;
-    getNodeAtPath: ([start, ...path]: number[]) => YNode;
-    getContainerAtPath: (path: number[]) => YArray<any>;
-    traverse: (cb: (node: YMap<any>, isText: boolean, path: number[]) => void, opts?: {
-        start?: number;
-        end?: number;
-    }) => void;
-    toJSON: () => {
-        children: any;
-        config: any;
-    };
-    toUpdate: () => Uint8Array;
-    string: () => string;
 }
+export declare const DocFromJson: (value: jsonNode[], initialDoc?: Doc) => Doc;

package/dist/utils/yClasses/yLeaf.d.ts

@@ -4,7 +4,4 @@ export declare type YLeafProps = {
     text?: string;
     id?: string;
 };
-export declare class YLeaf extends Map<any> {
-    id: string;
-    constructor(props?: YLeafProps);
-}
+export declare const createLeaf: (props?: YLeafProps) => Map<unknown>;

package/dist/utils/yClasses/yNode.d.ts

@@ -1,12 +1,12 @@
 import { Map } from "yjs";
-import { YArray } from "yjs/dist/src/internals";
-import { YLeaf } from ".";
+import { YArray, YMap } from "yjs/dist/src/internals";
+import { YLeaf } from "../../";
 export declare type YNodeProps = {
     data?: any;
     content?: YLeaf[] | YArray<YLeaf>;
     children?: YNode[] | YArray<YNode>;
     id?: string;
 };
+export declare const createNode: (type: string, props?: YNodeProps) => YMap<any>;
 export declare class YNode extends Map<any> {
-    constructor(type: string, props?: YNodeProps);
 }

package/dist/yjs/index.d.ts

@@ -1,2 +1 @@
-export * from "./webrtcProvider";
 export * from "./wsProvider";

package/dist/yjs/wsProvider.d.ts

@@ -1,11 +1 @@
-import { Doc } from "yjs";
-declare type WebrtcProviderOptions = {
-    signaling: Array<string>;
-    password: string | null;
-    awareness: any;
-    maxConns: number;
-    filterBcConns: boolean;
-    peerOpts: any;
-};
-export declare const createWSProvider: (doc: Doc, room: string, opts: WebrtcProviderOptions) => Doc;
-export {};
+export declare const createWSProvider: (room?: any) => Promise<unknown>;

package/index.ts

@@ -1,3 +1 @@
 export * from "./src";
-
-// This allows tests to include Slate Nodes written in JSX without TypeScript complaining.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edytor",
-  "version": "0.0.1",
+  "version": "0.0.6",
   "description": "the core of edytor",
   "keywords": [
     "richtext"
@@ -19,16 +19,16 @@
   },
   "dependencies": {
     "is-hotkey": "^0.2.0",
-    "jest": "^27.2.2",
     "nanoid": "^3.1.28",
-    "slate-hyperscript": "^0.66.0",
-    "ts": "^0.2.2",
+    "simple-peer-light": "^9.10.0",
+    "y-protocols": "^1.0.5",
     "y-webrtc": "^10.2.0",
     "y-websocket": "^1.3.16",
-    "yjs": "^13.5.12"
+    "yjs": "13.5.11"
   },
   "devDependencies": {
-    "jest": "^27.2.2",
+    "jest": "^27.2.5",
+    "ts": "^0.2.2",
     "ts-jest": "^27.0.5",
     "tsdx": "^0.14.1"
   }

package/dist/datastructure.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/utils/cursor.d.ts

@@ -1,24 +0,0 @@
-import { EdytorSelection } from "../types";
-export declare class Cursor {
-    container: HTMLDivElement;
-    selection: EdytorSelection;
-    constructor({ container, selection }: {
-        container: any;
-        selection: any;
-    });
-    getEditorOffset: (selection: Selection) => number;
-    static getCurrentCursorPosition(parentElement: HTMLElement | Node, focusNode?: Node, focusOffset?: number): number;
-    set: (offset: number) => void;
-    setRange: (offset: number, length: any) => void;
-    getRangeBoundaries: (offset: number, length: any) => {
-        startNode: ChildNode;
-        startOffset: number;
-        endNode: ChildNode;
-        endOffset: number;
-    };
-    getRangeBoundary: (node: any, chars: any, isStart: any) => [ChildNode, number];
-    static setCurrentCursorPosition(chars: any, element: any, s?: Selection): void;
-    static selectNode(node: any, startOffset: any, endOffset: any, selection: any): void;
-    static _createRange(node: any, chars: any, range: any): any;
-    static _isChildOf(node: any, parentElement: any): boolean;
-}

package/dist/utils/getSelection.d.ts

@@ -1,2 +0,0 @@
-import { Editor, EdytorSelection } from "../types";
-export declare const getRange: (editor: Editor, selection: Selection) => EdytorSelection;

package/dist/yjs/webrtcProvider.d.ts

@@ -1,12 +0,0 @@
-import { WebrtcProvider } from "y-webrtc";
-import { Doc } from "yjs";
-declare type WebrtcProviderOptions = {
-    signaling: Array<string>;
-    password: string | null;
-    awareness: any;
-    maxConns: number;
-    filterBcConns: boolean;
-    peerOpts: any;
-};
-export declare const createWebRtcProvider: (doc: Doc, room: string, opts: WebrtcProviderOptions) => WebrtcProvider;
-export {};