@dxos/react-ui-editor 0.8.4-main.84f28bd → 0.8.4-main.9735255

package/src/components/EditorToolbar/view-mode.ts

@@ -2,12 +2,14 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type NodeArg } from '@dxos/app-graph';
+import { type Node } from '@dxos/app-graph';
 import { type ToolbarMenuActionGroupProperties } from '@dxos/react-ui-menu';
+import { type EditorViewMode } from '@dxos/ui-editor';
 
-import { createEditorAction, createEditorActionGroup, type EditorToolbarState } from './util';
 import { translationKey } from '../../translations';
-import { type EditorViewMode } from '../../types';
+
+import { createEditorAction, createEditorActionGroup } from './actions';
+import { type EditorToolbarState } from './useEditorToolbar';
 
 const createViewModeGroupAction = (value: string) =>
   createEditorActionGroup(
@@ -28,11 +30,15 @@ const createViewModeActions = (value: string, onViewModeChange: (mode: EditorVie
     readonly: 'ph--pencil-slash--regular',
   }).map(([viewMode, icon]) => {
     const checked = viewMode === value;
-    return createEditorAction(`view-mode--${viewMode}`, () => onViewModeChange(viewMode as EditorViewMode), {
-      label: [`${viewMode} mode label`, { ns: translationKey }],
-      checked,
-      icon,
-    });
+    return createEditorAction(
+      `view-mode--${viewMode}`,
+      {
+        label: [`${viewMode} mode label`, { ns: translationKey }],
+        checked,
+        icon,
+      },
+      () => onViewModeChange(viewMode as EditorViewMode),
+    );
   });
 
 export const createViewMode = (state: EditorToolbarState, onViewModeChange: (mode: EditorViewMode) => void) => {
@@ -40,7 +46,7 @@ export const createViewMode = (state: EditorToolbarState, onViewModeChange: (mod
   const viewModeGroupAction = createViewModeGroupAction(value);
   const viewModeActions = createViewModeActions(value, onViewModeChange);
   return {
-    nodes: [viewModeGroupAction as NodeArg<any>, ...viewModeActions],
+    nodes: [viewModeGroupAction as Node.NodeArg<any>, ...viewModeActions],
     edges: [
       { source: 'root', target: 'viewMode' },
       ...viewModeActions.map(({ id }) => ({ source: viewModeGroupAction.id, target: id })),

package/src/components/index.ts

@@ -3,5 +3,9 @@
 //
 
 export * from './Editor';
-export * from './EditorToolbar';
-export * from './Popover';
+
+// TODO(burdon): Remove once Editor is fully migrated.
+export { EditorContent, createEditorController } from './EditorContent';
+export * from './EditorMenuProvider';
+export * from './EditorPreviewProvider';
+export { EditorToolbar, type EditorToolbarProps, type EditorToolbarState, useEditorToolbar } from './EditorToolbar';

package/src/hooks/useTextEditor.ts

@@ -4,8 +4,8 @@
 
 import { EditorState, type EditorStateConfig, type Text } from '@codemirror/state';
 import { EditorView } from '@codemirror/view';
-import { useFocusableGroup, type TabsterTypes } from '@fluentui/react-tabster';
 import {
+  type ComponentPropsWithoutRef,
   type DependencyList,
   type KeyboardEventHandler,
   type RefObject,
@@ -17,10 +17,14 @@ import {
 } from 'react';
 
 import { log } from '@dxos/log';
-import { getProviderValue, isNotFalsy, type MaybeProvider } from '@dxos/util';
-
-import { type EditorSelection, documentId, createEditorStateTransaction, editorInputMode } from '../extensions';
-import { debugDispatcher } from '../util';
+import {
+  type EditorSelection,
+  createEditorStateTransaction,
+  debugDispatcher,
+  documentId,
+  modalStateField,
+} from '@dxos/ui-editor';
+import { type MaybeProvider, getProviderValue, isTruthy } from '@dxos/util';
 
 let instanceCount = 0;
 
@@ -34,13 +38,9 @@ export type CursorInfo = {
 };
 
 export type UseTextEditor = {
-  // TODO(burdon): Rename.
-  parentRef: RefObject<HTMLDivElement>;
-  view?: EditorView;
-  focusAttributes?: TabsterTypes.TabsterDOMAttribute & {
-    tabIndex: 0;
-    onKeyUp: KeyboardEventHandler<HTMLDivElement>;
-  };
+  parentRef: RefObject<HTMLDivElement | null>;
+  view: EditorView | null;
+  focusAttributes?: ComponentPropsWithoutRef<'div'>;
 };
 
 export type UseTextEditorProps = Pick<EditorStateConfig, 'extensions'> & {
@@ -50,7 +50,7 @@ export type UseTextEditorProps = Pick<EditorStateConfig, 'extensions'> & {
   autoFocus?: boolean;
   scrollTo?: number;
   selection?: EditorSelection;
-  moveToEndOfLine?: boolean;
+  selectionEnd?: boolean;
   debug?: boolean;
 };
 
@@ -61,16 +61,16 @@ export const useTextEditor = (
   props: MaybeProvider<UseTextEditorProps> = {},
   deps: DependencyList = [],
 ): UseTextEditor => {
-  const { id, doc, initialValue, extensions, autoFocus, scrollTo, selection, moveToEndOfLine, debug } =
+  const { id, doc, initialValue, extensions, autoFocus, scrollTo, selection, selectionEnd, debug } =
     useMemo<UseTextEditorProps>(() => getProviderValue(props), deps ?? []);
 
   // NOTE: Increments by 2 in strict mode.
   const [instanceId] = useState(() => `text-editor-${++instanceCount}`);
-  const [view, setView] = useState<EditorView>();
+  const [view, setView] = useState<EditorView | null>(null);
   const parentRef = useRef<HTMLDivElement>(null);
 
   useEffect(() => {
-    let view: EditorView;
+    let view: EditorView | null = null;
     if (parentRef.current) {
       log('create', { id, instanceId, doc: initialValue?.length ?? 0 });
 
@@ -79,7 +79,7 @@ export const useTextEditor = (
         if (selection.anchor <= initialValue.length && (selection?.head ?? 0) <= initialValue.length) {
           initialSelection = selection;
         }
-      } else if (moveToEndOfLine && selection === undefined) {
+      } else if (selectionEnd && selection === undefined) {
         const index = initialValue?.indexOf('\n');
         const anchor = !index || index === -1 ? 0 : index;
         initialSelection = { anchor };
@@ -96,19 +96,7 @@ export const useTextEditor = (
           EditorView.exceptionSink.of((err) => {
             log.catch(err);
           }),
-          // TODO(burdon): Factor out debug inspector.
-          // ViewPlugin.fromClass(
-          //   class {
-          //     constructor(_view: EditorView) {
-          //       log('construct', { id });
-          //     }
-          //
-          //     destroy() {
-          //       log('destroy', { id });
-          //     }
-          //   },
-          // ),
-        ].filter(isNotFalsy),
+        ].filter(isTruthy),
       });
 
       // https://codemirror.net/docs/ref/#view.EditorViewConfig
@@ -120,7 +108,7 @@ export const useTextEditor = (
       });
 
       // Move to end of line after document loaded (unless selection is specified).
-      if (moveToEndOfLine && !initialSelection) {
+      if (selectionEnd && !initialSelection) {
         const { to } = view.state.doc.lineAt(0);
         if (to) {
           view.dispatch({ selection: { anchor: to } });
@@ -155,23 +143,30 @@ export const useTextEditor = (
     }
   }, [autoFocus, view]);
 
-  const focusableGroupAttrs = useFocusableGroup({
-    tabBehavior: 'limited',
-    ignoreDefaultKeydown: {
-      Escape: view?.state.facet(editorInputMode).noTabster,
-    },
-  });
-
   // Focus editor on Enter (e.g., when tabbing to this component).
-  const handleKeyUp = useCallback<KeyboardEventHandler<HTMLDivElement>>(
+  const handleKeyDown = useCallback<KeyboardEventHandler<HTMLDivElement>>(
     (event) => {
       const { key, target, currentTarget } = event;
-      if (target === currentTarget) {
-        switch (key) {
-          case 'Enter': {
+      switch (key) {
+        case 'Escape': {
+          // Check if popover is open.
+          const modal = view?.state.field(modalStateField, false);
+          if (modal) {
+            return;
+          }
+
+          // Focus the closest focusable parent.
+          const element = view?.contentDOM.closest('[tabindex="0"]') as HTMLDivElement | null;
+          element?.focus();
+          break;
+        }
+
+        case 'Enter': {
+          event.preventDefault();
+          if (target === currentTarget) {
             view?.focus();
-            break;
           }
+          break;
         }
       }
     },
@@ -183,8 +178,7 @@ export const useTextEditor = (
     view,
     focusAttributes: {
       tabIndex: 0 as const,
-      ...focusableGroupAttrs,
-      onKeyUp: handleKeyUp,
+      onKeyDown: handleKeyDown,
     },
   };
 };

package/src/index.ts

@@ -4,17 +4,7 @@
 
 import { translations } from './translations';
 
-export { type Extension, EditorState } from '@codemirror/state';
-export { EditorView, keymap } from '@codemirror/view';
-export { tags } from '@lezer/highlight';
-
-export { TextKind } from '@dxos/protocols/proto/dxos/echo/model/text';
-
 export * from './components';
-export * from './defaults';
-export * from './extensions';
 export * from './hooks';
-export * from './types';
-export * from './util';
 
 export { translations };

package/src/stories/Automerge.stories.tsx

@@ -0,0 +1,175 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { Repo } from '@automerge/automerge-repo';
+import { BroadcastChannelNetworkAdapter } from '@automerge/automerge-repo-network-broadcastchannel';
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React, { useCallback, useEffect, useState } from 'react';
+
+import { Obj, Ref } from '@dxos/echo';
+import { TestSchema } from '@dxos/echo/testing';
+import { DocAccessor, createDocAccessor } from '@dxos/echo-db';
+import { log } from '@dxos/log';
+import { type Messenger } from '@dxos/protocols';
+import { Query, useQuery, useSpace } from '@dxos/react-client/echo';
+import { type Identity, useIdentity } from '@dxos/react-client/halo';
+import { useClientStory, withMultiClientProvider } from '@dxos/react-client/testing';
+import { Button, useThemeContext } from '@dxos/react-ui';
+import { withTheme } from '@dxos/react-ui/testing';
+import { render } from '@dxos/storybook-utils';
+import { createBasicExtensions, createDataExtensions, createThemeExtensions } from '@dxos/ui-editor';
+
+import { useTextEditor } from '../hooks';
+import { translations } from '../translations';
+
+const initialContent = 'Hello world!';
+
+type TestObject = {
+  text: string;
+};
+
+type EditorProps = {
+  source: DocAccessor;
+  messenger?: Messenger;
+  identity?: Identity;
+  autoFocus?: boolean;
+};
+
+const Editor = ({ source, messenger, identity, autoFocus }: EditorProps) => {
+  const { themeMode } = useThemeContext();
+  const { parentRef } = useTextEditor(
+    () => ({
+      autoFocus,
+      initialValue: DocAccessor.getValue(source),
+      extensions: [
+        createBasicExtensions({ placeholder: 'Type here...', search: true }),
+        createThemeExtensions({ themeMode, slots: { scroll: { className: 'p-2' } } }),
+        createDataExtensions({ id: 'test', text: source, messenger, identity }),
+      ],
+    }),
+    [source, themeMode],
+  );
+
+  return <div ref={parentRef} className='flex is-full' />;
+};
+
+const DefaultStory = () => {
+  const [object1, setObject1] = useState<DocAccessor<TestObject>>();
+  const [object2, setObject2] = useState<DocAccessor<TestObject>>();
+
+  useEffect(() => {
+    queueMicrotask(async () => {
+      const repo1 = new Repo({ network: [new BroadcastChannelNetworkAdapter()] });
+      const repo2 = new Repo({ network: [new BroadcastChannelNetworkAdapter()] });
+
+      const object1 = repo1.create<TestObject>();
+      object1.change((doc: TestObject) => {
+        doc.text = initialContent;
+      });
+
+      const object2 = await repo2.find<TestObject>(object1.url);
+      await object2.whenReady();
+
+      setObject1({ handle: object1, path: ['text'] });
+      setObject2({ handle: object2, path: ['text'] });
+    });
+  }, []);
+
+  if (!object1 || !object2) {
+    return null;
+  }
+
+  return (
+    <div className='bs-full is-full grid grid-cols-2 gap-4'>
+      <Editor source={object1} autoFocus />
+      <Editor source={object2} />
+    </div>
+  );
+};
+
+const EchoStory = () => {
+  const { spaceId, index } = useClientStory();
+  const identity = useIdentity();
+  const space = useSpace(spaceId);
+  const objects = useQuery(space?.db, Query.type(TestSchema.Expando, { type: 'test' }));
+
+  const [source, setSource] = useState<DocAccessor>();
+  const init = useCallback(() => {
+    const content = objects[0]?.content.target;
+    if (!content) {
+      if (objects.length) {
+        // TODO(burdon): Initially ref isn't ready.
+        log.warn('no content', { index, objects: JSON.stringify(objects) });
+      }
+      return;
+    }
+
+    setSource(createDocAccessor(content, ['content']));
+  }, [objects]);
+
+  useEffect(() => {
+    if (source) {
+      return;
+    }
+
+    init();
+  }, [objects, source]);
+
+  return (
+    <div className='bs-full is-full flex flex-col overflow-hidden'>
+      <pre className='p-2 text-xs text-subdued'>
+        {JSON.stringify({ index, identity: identity?.identityKey.truncate(), spaceId, objects }, null, 2)}
+      </pre>
+      {identity && source ? (
+        <div className='p-2 flex grow overflow-hidden'>
+          <Editor identity={identity} messenger={space} source={source} />
+        </div>
+      ) : (
+        <div className='p-2'>
+          <Button onClick={init}>Init</Button>
+        </div>
+      )}
+    </div>
+  );
+};
+
+const meta = {
+  title: 'ui/react-ui-editor/Automerge',
+  component: Editor as any,
+  parameters: {
+    layout: 'fullscreen',
+    translations,
+  },
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+// TODO(burdon): ERROR: factories.ts:126 Error: Non-base58 character
+export const Default: Story = {
+  decorators: [withTheme],
+  render: render(DefaultStory),
+};
+
+// TODO(burdon): Failing (doesn't sync)
+export const WithEcho: Story = {
+  decorators: [
+    withTheme,
+    withMultiClientProvider({
+      numClients: 2,
+      createIdentity: true,
+      createSpace: true,
+      onCreateSpace: async ({ space }) => {
+        space.db.add(
+          Obj.make(TestSchema.Expando, {
+            type: 'test',
+            content: Ref.make(Obj.make(TestSchema.Expando, { content: initialContent })),
+          }),
+        );
+      },
+    }),
+  ],
+  render: render(EchoStory),
+};

package/src/stories/CommandDialog.stories.tsx

@@ -0,0 +1,81 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React, { type KeyboardEvent, useState } from 'react';
+
+import { type Button, IconButton, Input } from '@dxos/react-ui';
+import { withTheme } from '@dxos/react-ui/testing';
+import { editorWidth, join } from '@dxos/ui-editor';
+import { mx } from '@dxos/ui-theme';
+
+import { EditorStory } from './components';
+
+// TODO(burdon): Reimplement with Popover.
+const CommandDialog = ({ onAction }: { onAction: (action?: any) => void }) => {
+  const [text, setText] = useState('');
+
+  const handleInsert = () => {
+    // TODO(burdon): Use queue ref.
+    const link = `![${text}](dxn:queue:data:123)`;
+    onAction(text.length ? { type: 'insert', text: link } : undefined);
+  };
+
+  const handleKeyDown = (event: KeyboardEvent<HTMLInputElement>) => {
+    switch (event.key) {
+      case 'Enter': {
+        handleInsert();
+        break;
+      }
+      case 'Escape': {
+        onAction();
+        break;
+      }
+    }
+  };
+
+  return (
+    <div className='flex is-full justify-center'>
+      <div
+        className={mx(
+          'flex is-full p-2 gap-2 items-center bg-modalSurface border border-separator rounded-md',
+          editorWidth,
+        )}
+      >
+        <Input.Root>
+          <Input.TextInput
+            autoFocus={true}
+            placeholder='Ask a question...'
+            value={text}
+            onChange={(ev) => setText(ev.target.value)}
+            onKeyDown={handleKeyDown}
+          />
+        </Input.Root>
+        <IconButton
+          icon='ph--x--regular'
+          label='Cancel'
+          iconOnly
+          variant='ghost'
+          classNames='pli-0'
+          onClick={() => onAction({ type: 'cancel' })}
+        />
+      </div>
+    </div>
+  );
+};
+
+const meta = {
+  title: 'ui/react-ui-editor/CommandDialog',
+  render: () => <EditorStory text={join('# Command', '', '')} extensions={[]} />,
+  decorators: [withTheme],
+  parameters: {
+    layout: 'fullscreen',
+  },
+} satisfies Meta<typeof Button>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};

package/src/stories/Comments.stories.tsx

@@ -2,81 +2,89 @@
 // Copyright 2023 DXOS.org
 //
 
-import '@dxos-theme';
-
-import { effect, useSignal } from '@preact/signals-react';
-import React, { type FC } from 'react';
+import { Atom, RegistryContext } from '@effect-atom/atom-react';
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React, { type FC, useContext, useMemo } from 'react';
 
 import { keySymbols, parseShortcut } from '@dxos/keyboard';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { withLayout, withTheme, type Meta } from '@dxos/storybook-utils';
+import { withTheme } from '@dxos/react-ui/testing';
+import { withRegistry } from '@dxos/storybook-utils';
+import { type Comment, annotations, comments, createExternalCommentSync } from '@dxos/ui-editor';
+
+import { createRenderer, str } from '../util';
 
 import { EditorStory, content, longText } from './components';
-import { annotations, comments, createExternalCommentSync } from '../extensions';
-import { str } from '../testing';
-import { type Comment } from '../types';
-import { createRenderer } from '../util';
 
-const meta: Meta<typeof EditorStory> = {
+const meta = {
   title: 'ui/react-ui-editor/Comments',
   component: EditorStory,
-  decorators: [withTheme, withLayout({ fullscreen: true })],
-  parameters: { layout: 'fullscreen' },
-};
+  decorators: [withRegistry, withTheme],
+  parameters: {
+    layout: 'fullscreen',
+  },
+} satisfies Meta<typeof EditorStory>;
 
 export default meta;
 
+type Story = StoryObj<typeof meta>;
+
 //
 // Comments
 //
 
-export const Comments = {
-  render: () => {
-    const _comments = useSignal<Comment[]>([]);
-    return (
-      <EditorStory
-        text={str('# Comments', '', content.paragraphs, content.footer)}
-        extensions={[
-          createExternalCommentSync(
-            'test',
-            (sink) => effect(() => sink()),
-            () => _comments.value,
-          ),
-          comments({
-            id: 'test',
-            renderTooltip: createRenderer(CommentTooltip),
-            onCreate: ({ cursor }) => {
-              const id = PublicKey.random().toHex();
-              _comments.value = [..._comments.value, { id, cursor }];
-              return id;
-            },
-            onSelect: (state) => {
-              const debug = false;
-              if (debug) {
-                log.info('update', {
-                  comments: state.comments.length,
-                  active: state.selection.current?.slice(0, 8),
-                  closest: state.selection.closest?.slice(0, 8),
-                });
-              }
-            },
-          }),
-        ]}
-      />
-    );
-  },
+const CommentsStory = () => {
+  const registry = useContext(RegistryContext);
+  const commentsAtom = useMemo(() => Atom.make<Comment[]>([]), []);
+
+  return (
+    <EditorStory
+      text={str('# Comments', '', content.paragraphs, content.footer)}
+      extensions={[
+        createExternalCommentSync(
+          'test',
+          (sink) => registry.subscribe(commentsAtom, () => sink()),
+          () => registry.get(commentsAtom),
+        ),
+        comments({
+          id: 'test',
+          renderTooltip: createRenderer(CommentTooltip),
+          onCreate: ({ cursor }) => {
+            const id = PublicKey.random().toHex();
+            const current = registry.get(commentsAtom);
+            registry.set(commentsAtom, [...current, { id, cursor }]);
+            return id;
+          },
+          onSelect: (state) => {
+            const debug = false;
+            if (debug) {
+              log.info('update', {
+                comments: state.comments.length,
+                active: state.selection.current?.slice(0, 8),
+                closest: state.selection.closest?.slice(0, 8),
+              });
+            }
+          },
+        }),
+      ]}
+    />
+  );
+};
+
+export const Comments: Story = {
+  render: () => <CommentsStory />,
 };
 
 const Key: FC<{ char: string }> = ({ char }) => (
-  <span className='flex justify-center items-center w-[24px] h-[24px] rounded text-xs bg-neutral-200 text-black'>
+  <span className='flex justify-center items-center is-[24px] bs-[24px] rounded text-xs bg-neutral-200 text-black'>
     {char}
   </span>
 );
 
 const CommentTooltip: FC<{ shortcut: string }> = ({ shortcut }) => {
   return (
-    <div className='flex items-center gap-2 px-2 py-2 bg-neutral-700 text-white text-xs rounded'>
+    <div className='flex items-center gap-2 pli-2 plb-2 bg-neutral-700 text-white text-xs rounded'>
       <div>Create comment</div>
       <div className='flex gap-1'>
         {keySymbols(parseShortcut(shortcut)).map((char) => (
@@ -91,7 +99,7 @@ const CommentTooltip: FC<{ shortcut: string }> = ({ shortcut }) => {
 // Annotations
 //
 
-export const Annotations = {
+export const Annotations: Story = {
   render: () => (
     <EditorStory text={str('# Annotations', '', longText)} extensions={[annotations({ match: /volup/gi })]} />
   ),