@getguru/slate-yjs-core 1.0.3

package/test/collaboration/splitNode/onNonDefaultBlock.tsx

@@ -0,0 +1,27 @@
+/** @jsx jsx */
+import { Editor, Transforms } from 'slate';
+import { jsx } from '../../../../../support/jsx';
+
+export const input = (
+  <editor>
+    <h1 id="block1">
+      Hello world!
+      <cursor />
+    </h1>
+    <unstyled>Welcome to slate-yjs!</unstyled>
+  </editor>
+);
+
+export const expected = (
+  <editor>
+    <h1 id="block1">Hello world!</h1>
+    <h1 id="block1">
+      <cursor />
+    </h1>
+    <unstyled>Welcome to slate-yjs!</unstyled>
+  </editor>
+);
+
+export function run(editor: Editor) {
+  Transforms.splitNodes(editor, { always: true });
+}

package/test/collaboration/splitNode/withMultipleSubNodes.tsx

@@ -0,0 +1,32 @@
+/* eslint-disable react/void-dom-elements-no-children */
+/** @jsx jsx */
+import { Editor, Transforms } from 'slate';
+import { jsx } from '../../../../../support/jsx';
+
+export const input = (
+  <editor>
+    <unstyled id="block1">
+      slate-yjs
+      <cursor />
+      slate-yjs
+      <link url="https://slate-yjs.dev">slate-yjs</link>
+      <link url="https://slate-yjs.dev">slate-yjs</link>
+    </unstyled>
+  </editor>
+);
+
+export const expected = (
+  <editor>
+    <unstyled id="block1">slate-yjs</unstyled>
+    <unstyled id="block1">
+      <cursor />
+      slate-yjs
+      <link url="https://slate-yjs.dev">slate-yjs</link>
+      <link url="https://slate-yjs.dev">slate-yjs</link>
+    </unstyled>
+  </editor>
+);
+
+export function run(editor: Editor) {
+  Transforms.splitNodes(editor, { always: true });
+}

package/test/collaboration/splitNode/withUnicode.tsx

@@ -0,0 +1,29 @@
+/** @jsx jsx */
+import { Editor, Transforms } from 'slate';
+import { jsx } from '../../../../../support/jsx';
+
+export const input = (
+  <editor>
+    <unstyled id="block1">
+      H{'Iñtërnâtiônàlizætiøn☃💩\uFEFF'}
+      <cursor />
+      {'Iñtërnâtiônàlizætiøn☃💩\uFEFF'}
+    </unstyled>
+    <unstyled>{'Iñtërnâtiônàlizætiøn☃💩\uFEFF'}</unstyled>
+  </editor>
+);
+
+export const expected = (
+  <editor>
+    <unstyled id="block1">H{'Iñtërnâtiônàlizætiøn☃💩\uFEFF'}</unstyled>
+    <unstyled id="block1">
+      <cursor />
+      {'Iñtërnâtiônàlizætiøn☃💩\uFEFF'}
+    </unstyled>
+    <unstyled>{'Iñtërnâtiônàlizætiøn☃💩\uFEFF'}</unstyled>
+  </editor>
+);
+
+export function run(editor: Editor) {
+  Transforms.splitNodes(editor, { always: true });
+}

package/test/index.test.ts

@@ -0,0 +1,65 @@
+/* eslint-disable import/no-extraneous-dependencies */
+import { createEditor, Editor } from 'slate';
+import { describe, expect } from 'vitest';
+import * as Y from 'yjs';
+import { fixtures } from '../../../support/fixtures';
+import { yTextToSlateElement } from '../src';
+import { withTestingElements } from './withTestingElements';
+
+export type FixtureModule = {
+  module: {
+    input: Editor;
+    expected: Editor;
+    run: (e: Editor) => void;
+  };
+};
+
+async function normalizedSlateDoc(sharedRoot: Y.XmlText) {
+  const editor = createEditor();
+  editor.children = yTextToSlateElement(sharedRoot).children;
+  const e = await withTestingElements(editor);
+  Editor.normalize(e, { force: true });
+  return e.children;
+}
+
+async function runCollaborationTest({ module }: FixtureModule) {
+  // Setup 'local' editor
+  const { input, run, expected } = module;
+  const editor = await withTestingElements(input);
+
+  // Keep the 'local' editor state before applying run.
+  const baseState = Y.encodeStateAsUpdateV2(editor.sharedRoot.doc);
+
+  Editor.normalize(editor, { force: true });
+
+  // The normalized editor state should match the shared root.
+  expect(await normalizedSlateDoc(editor.sharedRoot)).toEqual(editor.children);
+
+  run(editor);
+  editor.onChange();
+
+  // Editor state after run should match shared root.
+  expect(await normalizedSlateDoc(editor.sharedRoot)).toEqual(editor.children);
+
+  // Setup remote editor with input base state
+  const remoteDoc = new Y.Doc();
+  Y.applyUpdateV2(remoteDoc, baseState);
+  const remote = await withTestingElements(createEditor(), remoteDoc);
+
+  // Apply changes from 'run'
+  Y.applyUpdateV2(remoteDoc, Y.encodeStateAsUpdateV2(editor.sharedRoot.doc));
+
+  // Verify remote and editor state are equal
+  expect(await normalizedSlateDoc(remote.sharedRoot)).toEqual(remote.children);
+  expect(editor.children).toEqual(remote.children);
+  expect(await normalizedSlateDoc(editor.sharedRoot)).toEqual(editor.children);
+
+  // Verify editor is in expected state
+  const expectedEditor = await withTestingElements(expected);
+  Editor.normalize(expectedEditor, { force: true });
+  expect(editor.children).toEqual(expectedEditor.children);
+}
+
+describe('adapter', () => {
+  fixtures(__dirname, 'collaboration', runCollaborationTest);
+});

package/test/slate.d.ts

@@ -0,0 +1,8 @@
+import { BaseElement, BaseText } from 'slate';
+
+declare module 'slate' {
+  interface CustomTypes {
+    Element: BaseElement & Record<string, unknown>;
+    Text: BaseText & Record<string, unknown>;
+  }
+}

package/test/withTestingElements.ts

@@ -0,0 +1,46 @@
+import { Editor, Element, Transforms } from 'slate';
+import * as Y from 'yjs';
+import { wait } from '../../../support/utils';
+import { slateNodesToInsertDelta, withYjs } from '../src';
+
+const INLINE_ELEMENTS = ['note-link', 'link'];
+
+export async function withTestingElements(
+  editor: Editor,
+  doc: Y.Doc = new Y.Doc()
+) {
+  const { normalizeNode, isInline } = editor;
+
+  // normalizations needed for nested tests
+  editor.normalizeNode = (entry) => {
+    const [node, path] = entry;
+
+    // remove empty list
+    if (
+      Element.isElement(node) &&
+      !Editor.isEditor(node) &&
+      node.type === 'unordered-list'
+    ) {
+      if (!node.children.length) {
+        return Transforms.removeNodes(editor, { at: path });
+      }
+    }
+
+    normalizeNode(entry);
+  };
+
+  editor.isInline = (element) =>
+    INLINE_ELEMENTS.includes(element.type as string) || isInline(element);
+
+  const sharedType = doc.get('sharedRoot', Y.XmlText) as Y.XmlText;
+  if (sharedType.toDelta().length === 0) {
+    sharedType.applyDelta(slateNodesToInsertDelta(editor.children));
+  }
+
+  const e = withYjs(editor, sharedType, { autoConnect: true });
+
+  // Wait for editor to be initialized
+  await wait();
+
+  return e;
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../config/typescript/tsconfig.json",
+  "include": ["src/**/*"],
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "declarationDir": "./dist",
+    "composite": true
+  },
+  "references": []
+}

package/tsup.config.ts

@@ -0,0 +1,32 @@
+/* eslint-disable import/no-default-export */
+/* eslint-disable import/no-extraneous-dependencies */
+import { defineConfig, Options } from 'tsup';
+
+export default defineConfig(
+  ({ watch }) => <Options[]>[
+      {
+        entry: ['src/index.ts'],
+        outDir: 'dist',
+        format: ['cjs', 'iife', 'esm'],
+        globalName: 'SlateYjsCore',
+        platform: 'browser',
+        splitting: false,
+        bundle: true,
+        sourcemap: true,
+        minify: false,
+        clean: !watch,
+      },
+      !!watch && {
+        entry: ['src'],
+        outDir: 'dist',
+        format: [],
+        platform: 'browser',
+        splitting: false,
+        bundle: false,
+        sourcemap: true,
+        dts: true,
+        minify: false,
+        clean: false,
+      },
+    ].filter(Boolean)
+);