@dxos/plugin-chess 0.8.4-main.b97322e → 0.8.4-main.bc674ce

package/src/capabilities/react-surface/react-surface.tsx

@@ -0,0 +1,27 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { Capability, Common } from '@dxos/app-framework';
+import { Obj } from '@dxos/echo';
+
+import { ChessboardContainer } from '../../components';
+import { meta } from '../../meta';
+import { Chess } from '../../types';
+
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Common.Capability.ReactSurface, [
+      Common.createSurface({
+        id: meta.id,
+        role: ['article', 'section', 'card--content'],
+        // TODO(burdon): Could this be standardized so that we don't require a subject property.
+        filter: (data): data is { subject: Chess.Game } => Obj.instanceOf(Chess.Game, data.subject),
+        component: ({ data, role }) => <ChessboardContainer role={role} subject={data.subject} />,
+      }),
+    ]),
+  ),
+);

package/src/cli/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './plugin';

package/src/cli/plugin.ts

@@ -0,0 +1,26 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Common, Plugin } from '@dxos/app-framework';
+import { type CreateObject } from '@dxos/plugin-space/types';
+
+import { meta } from '../meta';
+import { Chess } from '../types';
+
+// TODO(wittjosiah): Factor out shared modules.
+export const ChessPlugin = Plugin.define(meta).pipe(
+  Common.Plugin.addSchemaModule({ schema: [Chess.Game] }),
+  Common.Plugin.addMetadataModule({
+    metadata: {
+      id: Chess.Game.typename,
+      metadata: {
+        createObject: ((props) => Effect.sync(() => Chess.make(props))) satisfies CreateObject,
+        addToCollectionOnCreate: true,
+      },
+    },
+  }),
+  Plugin.make,
+);

package/src/components/Card.stories.tsx

@@ -0,0 +1,47 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React, { useMemo } from 'react';
+
+import { withTheme } from '@dxos/react-ui/testing';
+import { CardContainer } from '@dxos/react-ui-mosaic/testing';
+
+import { meta as pluginMeta } from '../meta';
+import { Chess } from '../types';
+
+import { Chessboard } from './Chessboard';
+
+const SAMPLE_PGN =
+  '1. e4 e5 2. Nf3 Nc6 3. Bc4 Bc5 4. c3 Nf6 5. d4 exd4 6. cxd4 Bb4+ 7. Nc3 d5 8. exd5 Nxd5 9. O-O Be6 10. Qb3 Na5 11. Qa4+ c6 12. Bxd5 Bxc3 13. Bxe6 fxe6 14. d5 Qg5 15. dxe6 Qg4 16. e7 Kf7 17. bxc3 Kg6 *';
+
+// TODO(wittjosiah): ECHO objects don't work when passed via Storybook args.
+const CardStory = () => {
+  const game = useMemo(() => Chess.make({ pgn: SAMPLE_PGN }), []);
+  return (
+    <CardContainer icon={pluginMeta.icon}>
+      <Chessboard.Root game={game}>
+        <Chessboard.Content>
+          <Chessboard.Board />
+        </Chessboard.Content>
+      </Chessboard.Root>
+    </CardContainer>
+  );
+};
+
+const meta = {
+  title: 'plugins/plugin-chess/Card',
+  render: () => <CardStory />,
+  decorators: [withTheme],
+  parameters: {
+    layout: 'centered',
+  },
+  tags: ['cards'],
+} satisfies Meta;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Popover: Story = {};

package/src/components/Chessboard.stories.tsx

@@ -2,40 +2,52 @@
 // Copyright 2023 DXOS.org
 //
 
-import '@dxos-theme';
-
 import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React, { useMemo } from 'react';
 
-import { Gameboard, Chessboard, ChessModel } from '@dxos/react-ui-gameboard';
-import { withLayout, withTheme } from '@dxos/storybook-utils';
+import { withClientProvider } from '@dxos/react-client/testing';
+import { withTheme } from '@dxos/react-ui/testing';
 
-import { ChessPanel } from './ChessPanel';
+import { translations } from '../translations';
+import { Chess } from '../types';
 
-const DefaultStory = () => {
-  const model = useMemo(() => new ChessModel(), []);
+import { ChessboardArticle } from './ChessboardArticle';
 
-  return (
-    <div className='flex grow mx-8 gap-8 items-center overflow-hidden'>
-      <Gameboard.Root model={model} onDrop={(move) => model.makeMove(move)}>
-        <Gameboard.Content>
-          <Chessboard />
-        </Gameboard.Content>
-      </Gameboard.Root>
-      <ChessPanel model={model} classNames='w-[200px]' />
-    </div>
-  );
+type StoryProps = {
+  pgn?: string;
 };
 
-const meta: Meta<typeof Chessboard> = {
-  title: 'plugins/plugin-chess/Chessboard',
-  component: Chessboard,
-  render: DefaultStory,
-  decorators: [withTheme, withLayout({ fullscreen: true })],
+const DefaultStory = ({ pgn }: StoryProps) => {
+  const game = useMemo(() => Chess.make(pgn ? { pgn } : undefined), [pgn]);
+  return <ChessboardArticle subject={game} />;
 };
 
-type Story = StoryObj<typeof Chessboard>;
+const meta = {
+  title: 'plugins/plugin-chess/Chessboard',
+  component: DefaultStory,
+  decorators: [withTheme, withClientProvider({ createIdentity: true })],
+  parameters: {
+    layout: 'fullscreen',
+    translations,
+  },
+} satisfies Meta<typeof DefaultStory>;
 
 export default meta;
 
-export const Default: Story = {};
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {
+  args: {},
+};
+
+export const EndGame: Story = {
+  args: {
+    pgn: '1. e4 e5 2. Nf3 Nc6 3. Bc4 Bc5 4. c3 Nf6 5. d4 exd4 6. cxd4 Bb4+ 7. Nc3 d5 8. exd5 Nxd5 9. O-O Be6 10. Qb3 Na5 11. Qa4+ c6 12. Bxd5 Bxc3 13. Bxe6 fxe6 *',
+  },
+};
+
+export const Promption: Story = {
+  args: {
+    pgn: '1. e4 e5 2. Nf3 Nc6 3. Bc4 Bc5 4. c3 Nf6 5. d4 exd4 6. cxd4 Bb4+ 7. Nc3 d5 8. exd5 Nxd5 9. O-O Be6 10. Qb3 Na5 11. Qa4+ c6 12. Bxd5 Bxc3 13. Bxe6 fxe6 14. d5 Qg5 15. dxe6 Qg4 16. e7 Kf7 17. bxc3 Kg6 *',
+  },
+};

package/src/components/Chessboard.tsx

@@ -0,0 +1,188 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type Registry, RegistryContext } from '@effect-atom/atom-react';
+import React, {
+  type PropsWithChildren,
+  forwardRef,
+  useCallback,
+  useContext,
+  useEffect,
+  useImperativeHandle,
+  useMemo,
+  useRef,
+} from 'react';
+
+import { addEventListener } from '@dxos/async';
+import { Obj } from '@dxos/echo';
+import { type ThemedClassName } from '@dxos/react-ui';
+import {
+  ChessModel,
+  Gameboard,
+  type GameboardRootProps,
+  Chessboard as NaturalChessboard,
+  type ChessboardProps as NaturalChessboardProps,
+  getRawPgn,
+  useGameboardContext,
+} from '@dxos/react-ui-gameboard';
+import { useSoundEffect } from '@dxos/react-ui-sfx';
+import { mx } from '@dxos/ui-theme';
+
+import { type Chess } from '../types';
+
+import { Info, type InfoProps } from './Info';
+
+export interface ChessboardController {
+  setMoveNumber(index: number): void;
+}
+
+export class ExtendedChessModel extends ChessModel {
+  constructor(
+    registry: Registry.Registry,
+    readonly object: Chess.Game,
+  ) {
+    super(registry);
+  }
+}
+
+//
+// Root
+//
+
+type RootProps = PropsWithChildren<{
+  game: Chess.Game;
+}>;
+
+const Root = forwardRef<ChessboardController, RootProps>(({ game, children }, forwardedRef) => {
+  const registry = useContext(RegistryContext);
+  const model = useMemo(() => new ExtendedChessModel(registry, game), [registry]);
+  const click = useSoundEffect('Click');
+
+  // Controller.
+  useImperativeHandle(forwardedRef, () => {
+    return {
+      setMoveNumber: (index) => model.setMoveIndex(index),
+    };
+  }, [model]);
+
+  // External change.
+  // NOTE: Warning if user has not interacted with the board.
+  useEffect(() => {
+    if (model.pgn !== getRawPgn(game.pgn ?? '')) {
+      const silent = model.pgn === '*';
+      model.update(game.pgn);
+      if (!silent) {
+        void click.play();
+      }
+    }
+  }, [game.pgn]);
+
+  // Move.
+  const handleDrop = useCallback<NonNullable<GameboardRootProps<ChessModel>['onDrop']>>(
+    (move) => {
+      if (!model.makeMove(move)) {
+        return false;
+      }
+
+      void click.play();
+      Obj.change(game, (g) => {
+        g.pgn = model.pgn;
+      });
+      return true;
+    },
+    [model],
+  );
+
+  return (
+    <Gameboard.Root model={model} onDrop={handleDrop}>
+      {children}
+    </Gameboard.Root>
+  );
+});
+
+//
+// Content
+//
+
+type Role = 'card--popover' | 'card--intrinsic' | 'card--extrinsic';
+
+type ContentProps = ThemedClassName<PropsWithChildren<{ role?: Role }>>;
+
+const Content = ({ classNames, children, role }: ContentProps) => {
+  return (
+    <Gameboard.Content
+      classNames={mx(classNames, role === 'card--popover' && 'size-container popover-square')}
+      grow={!role || role === 'card--extrinsic'}
+      contain={!role || role === 'card--extrinsic' || role === 'card--popover'}
+    >
+      {children}
+    </Gameboard.Content>
+  );
+};
+
+//
+// Board
+//
+
+type BoardProps = NaturalChessboardProps;
+
+const Board = (props: BoardProps) => {
+  const registry = useContext(RegistryContext);
+  const { model } = useGameboardContext<ChessModel>(Board.displayName);
+
+  // Keyboard navigation.
+  const ref = useRef<HTMLDivElement>(null);
+  useEffect(() => {
+    if (!ref.current) {
+      return;
+    }
+
+    // Participate in keyboard navigation (set tabIndex={0})
+    ref.current.setAttribute('data-arrow-keys', 'all');
+
+    return addEventListener(ref.current, 'keydown', (ev) => {
+      const moveIndex = registry.get(model.moveIndex);
+      switch (ev.key) {
+        case 'ArrowUp':
+          model.setMoveIndex(0);
+          break;
+        case 'ArrowDown':
+          model.setMoveIndex(model.game.history().length);
+          break;
+        case 'ArrowLeft':
+          if (moveIndex > 0) {
+            model.setMoveIndex(moveIndex - 1);
+          }
+          break;
+        case 'ArrowRight':
+          if (moveIndex < model.game.history().length) {
+            model.setMoveIndex(moveIndex + 1);
+          }
+          break;
+      }
+    });
+  }, [registry, model]);
+
+  return <NaturalChessboard ref={ref} {...props} />;
+};
+
+Board.displayName = 'Chessboard.Board';
+
+//
+// Chessboard
+//
+
+export const Chessboard = {
+  Root: Root,
+  Content: Content,
+  Board: Board,
+  Info: Info,
+};
+
+export type {
+  RootProps as ChessboardRootProps,
+  ContentProps as ChessboardContentProps,
+  BoardProps as ChessboardBoardProps,
+  InfoProps as ChessboardInfoProps,
+};

package/src/components/ChessboardArticle.tsx

@@ -0,0 +1,71 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import React, { useCallback, useRef, useState } from 'react';
+
+import { type SurfaceComponentProps } from '@dxos/app-framework/react';
+import { Toolbar, useTranslation } from '@dxos/react-ui';
+import { type Player } from '@dxos/react-ui-gameboard';
+import { Layout } from '@dxos/react-ui-mosaic';
+import { mx } from '@dxos/ui-theme';
+
+import { meta } from '../meta';
+import { type Chess } from '../types';
+
+import { Chessboard, type ChessboardController, type ChessboardInfoProps } from './Chessboard';
+
+export type ChessboardArticleProps = SurfaceComponentProps<Chess.Game>;
+
+export const ChessboardArticle = ({ role, subject: game }: ChessboardArticleProps) => {
+  const { t } = useTranslation(meta.id);
+  const [orientation, setOrientation] = useState<Player>('white');
+  const [open, setOpen] = useState(true);
+  const controller = useRef<ChessboardController>(null);
+
+  // TODO(burdon): Keyboard handler.
+  const handleSelect = useCallback<NonNullable<ChessboardInfoProps['onSelect']>>((index) => {
+    controller.current?.setMoveNumber(index);
+  }, []);
+
+  return (
+    <Layout.Main toolbar classNames='@container'>
+      <Chessboard.Root game={game} ref={controller}>
+        <Toolbar.Root>
+          <Toolbar.IconButton
+            icon='ph--info--regular'
+            iconOnly
+            label={t('toggle info button')}
+            disabled={open}
+            classNames={mx('invisible @3xl:visible')}
+            onClick={() => setOpen((open) => !open)}
+          />
+        </Toolbar.Root>
+        <div
+          className={mx(
+            'grid bs-full is-full gap-2',
+            open && '@3xl:grid-cols-[1fr_320px]',
+            role === 'section' && 'aspect-square',
+            role === 'section' && open && '@3xl:aspect-auto',
+          )}
+        >
+          <Chessboard.Content>
+            <Chessboard.Board classNames='m-4 rounded-sm overflow-hidden' orientation={orientation} />
+          </Chessboard.Content>
+          {open && (
+            <div className='hidden @3xl:flex flex-col p-8 justify-center items-center overflow-hidden'>
+              <Chessboard.Info
+                orientation={orientation}
+                min={8}
+                max={8}
+                onOrientationChange={setOrientation}
+                onClose={() => setOpen(false)}
+                onSelect={handleSelect}
+              />
+            </div>
+          )}
+        </div>
+      </Chessboard.Root>
+    </Layout.Main>
+  );
+};

package/src/components/ChessboardContainer.tsx

@@ -0,0 +1,40 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import React from 'react';
+
+import { type SurfaceComponentProps } from '@dxos/app-framework/react';
+import { Obj } from '@dxos/echo';
+
+import { type Chess } from '../types';
+
+import { Chessboard } from './Chessboard';
+import { ChessboardArticle } from './ChessboardArticle';
+
+export type ChessboardContainerProps = SurfaceComponentProps<Chess.Game>;
+
+export const ChessboardContainer = ({ role, subject: game }: ChessboardContainerProps) => {
+  const db = Obj.getDatabase(game);
+  if (!db) {
+    return null;
+  }
+
+  switch (role) {
+    case 'card--content': {
+      return (
+        <Chessboard.Root game={game}>
+          <Chessboard.Content>
+            <Chessboard.Board />
+          </Chessboard.Content>
+        </Chessboard.Root>
+      );
+    }
+
+    default: {
+      return <ChessboardArticle role={role} subject={game} />;
+    }
+  }
+};
+
+export default ChessboardContainer;