@dxos/plugin-chess 0.8.4-main.3f58842 → 0.8.4-main.5ea62a8

package/src/components/ChessboardArticle.tsx

@@ -0,0 +1,64 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import React, { useCallback, useRef, useState } from 'react';
+
+import { IconButton, useTranslation } from '@dxos/react-ui';
+import { type Player } from '@dxos/react-ui-gameboard';
+import { StackItem } from '@dxos/react-ui-stack';
+import { mx } from '@dxos/react-ui-theme';
+
+import { meta } from '../meta';
+import { type Chess } from '../types';
+
+import { Chessboard, type ChessboardController, type ChessboardInfoProps } from './Chessboard';
+
+export const ChessboardArticle = ({ game }: { game: Chess.Game }) => {
+  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 (
+    <StackItem.Content classNames='@container bs-full is-full overflow-hidden'>
+      <Chessboard.Root game={game} ref={controller}>
+        <div className={mx('grid grid-rows-[1fr_4rem] bs-full is-full gap-2', open && '@3xl:grid-cols-[1fr_320px]')}>
+          <Chessboard.Content>
+            <Chessboard.Board 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 className='flex justify-center items-center'>
+            <Chessboard.Players>
+              <IconButton
+                variant='ghost'
+                icon='ph--info--regular'
+                iconOnly
+                label={t('button toggle info')}
+                size={6}
+                classNames={mx('invisible', !open && '@3xl:visible')}
+                onClick={() => setOpen((open) => !open)}
+              />
+            </Chessboard.Players>
+          </div>
+        </div>
+      </Chessboard.Root>
+    </StackItem.Content>
+  );
+};

package/src/components/ChessboardContainer.tsx

@@ -0,0 +1,44 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import React from 'react';
+
+import { getSpace } from '@dxos/react-client/echo';
+
+import { type Chess } from '../types';
+
+import { Chessboard } from './Chessboard';
+import { ChessboardArticle } from './ChessboardArticle';
+
+export type ChessboardContainerProps = {
+  game: Chess.Game;
+  role?: string;
+};
+
+export const ChessboardContainer = ({ game, role }: ChessboardContainerProps) => {
+  const space = getSpace(game);
+  if (!space) {
+    return null;
+  }
+
+  switch (role) {
+    case 'card--popover':
+    case 'card--intrinsic':
+    case 'card--extrinsic': {
+      return (
+        <Chessboard.Root game={game}>
+          <Chessboard.Content role={role}>
+            <Chessboard.Board />
+          </Chessboard.Content>
+        </Chessboard.Root>
+      );
+    }
+
+    default: {
+      return <ChessboardArticle game={game} />;
+    }
+  }
+};
+
+export default ChessboardContainer;

package/src/components/ChessboardInfo.tsx

@@ -0,0 +1,173 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import React, { type PropsWithChildren, useEffect, useMemo, useRef } from 'react';
+
+import { Icon, IconButton, type ThemedClassName, useTranslation } from '@dxos/react-ui';
+import { type Player, useGameboardContext } from '@dxos/react-ui-gameboard';
+import { mx } from '@dxos/react-ui-theme';
+
+import { meta } from '../meta';
+
+import { type ExtendedChessModel } from './Chessboard';
+
+export type ChessboardInfoProps = ThemedClassName<
+  {
+    orientation?: Player;
+    onOrientationChange?: (orientation: Player) => void;
+    onClose?: () => void;
+  } & Pick<HistoryProps, 'min' | 'max' | 'onSelect'>
+>;
+
+export const ChessboardInfo = ({
+  classNames,
+  orientation = 'white',
+  onOrientationChange,
+  onClose,
+  ...props
+}: ChessboardInfoProps) => {
+  const { t } = useTranslation(meta.id);
+  const { model } = useGameboardContext<ExtendedChessModel>(ChessboardInfo.displayName);
+
+  return (
+    <div
+      className={mx(
+        'grid grid-rows-[min-content_1fr_min-content] is-full min-is-[16rem] p-2 overflow-hidden bg-inputSurface rounded',
+        classNames,
+      )}
+    >
+      <PlayerIndicator
+        model={model}
+        player={orientation === 'white' ? 'black' : 'white'}
+        title={model.object.players?.[orientation === 'white' ? 'black' : 'white']}
+      >
+        {onClose && <IconButton icon='ph--x--regular' iconOnly label={t('button flip')} size={4} onClick={onClose} />}
+      </PlayerIndicator>
+
+      <History model={model} {...props} />
+
+      <PlayerIndicator model={model} player={orientation} title={model.object.players?.[orientation]}>
+        {onOrientationChange && (
+          <IconButton
+            icon='ph--arrows-down-up--regular'
+            iconOnly
+            label={t('button flip')}
+            size={6}
+            classNames={mx('transition duration-200 ease-linear', orientation === 'white' && 'rotate-180')}
+            onClick={() => onOrientationChange(orientation === 'white' ? 'black' : 'white')}
+          />
+        )}
+      </PlayerIndicator>
+    </div>
+  );
+};
+
+ChessboardInfo.displayName = 'Chessboard.Info';
+
+type HistoryProps = ThemedClassName<{
+  model: ExtendedChessModel;
+  min?: number;
+  max?: number;
+  onSelect?: (index: number) => void;
+}>;
+
+const History = ({ classNames, model, min, max, onSelect }: HistoryProps) => {
+  const { t } = useTranslation(meta.id);
+  const label = model.game.isGameOver()
+    ? model.game.isCheckmate()
+      ? t('game.checkmate')
+      : model.game.isStalemate()
+        ? t('game.stalemate')
+        : t('game.draw')
+    : model.game.isCheck()
+      ? t('game.check')
+      : undefined;
+
+  const history = model.game.history();
+  const moves = useMemo(
+    () =>
+      history.reduce(
+        (acc, move, index) => {
+          if (index % 2 === 0) {
+            acc.push([{ index, move }]);
+          } else {
+            acc[acc.length - 1].push({ index, move });
+          }
+          return acc;
+        },
+        [] as { index: number; move: string }[][],
+      ),
+    [history.length],
+  );
+
+  const scrollerRef = useRef<HTMLDivElement>(null);
+  useEffect(() => {
+    scrollerRef.current?.scrollTo({ top: scrollerRef.current.scrollHeight });
+  }, [history.length]);
+
+  useEffect(() => {
+    const div = scrollerRef.current?.querySelector(`[data-index="${model.moveIndex.value - 1}"]`);
+    scrollerRef.current?.classList.add('scrollbar-none');
+    div?.scrollIntoView({ behavior: 'smooth' });
+    scrollerRef.current?.classList.remove('scrollbar-none');
+  }, [model.moveIndex.value]);
+
+  return (
+    <div
+      ref={scrollerRef}
+      className={mx('overflow-y-scroll', classNames)}
+      style={{
+        minHeight: min === undefined ? 'auto' : `${min * 24}px`,
+        maxHeight: max === undefined ? 'auto' : `${max * 24}px`,
+      }}
+    >
+      {moves.map(([a, b], index) => (
+        <div key={index} className='grid grid-cols-[3rem_1fr_1fr_1rem] gap-2 pis-4 leading-1'>
+          <div className='content-center text-xs text-subdued'>{index + 1}</div>
+          {a && (
+            <div
+              data-index={a.index}
+              className={mx('pis-2 cursor-pointer', a.index === model.moveIndex.value - 1 && 'bg-primary-500')}
+              onClick={() => onSelect?.(a.index + 1)}
+            >
+              {a.move}
+            </div>
+          )}
+          {b && (
+            <div
+              data-index={b.index}
+              className={mx('pis-2 cursor-pointer', b.index === model.moveIndex.value - 1 && 'bg-primary-500')}
+              onClick={() => onSelect?.(b.index + 1)}
+            >
+              {b.move}
+            </div>
+          )}
+        </div>
+      ))}
+      {label && <div className='text-center'>{label}</div>}
+    </div>
+  );
+};
+
+const PlayerIndicator = ({
+  children,
+  model,
+  player,
+  title,
+}: PropsWithChildren<{ model: ExtendedChessModel; player: Player; title?: string }>) => {
+  const turn = player === (model.game.turn() === 'w' ? 'white' : 'black');
+  return (
+    <div className='grid grid-cols-[2rem_1fr_2rem] gap-1 bs-[--rail-size] pis-1 pie-1 flex items-center overflow-hidden'>
+      <div className='place-items-center'>
+        <Icon
+          icon={turn ? 'ph--circle--fill' : 'ph--circle--thin'}
+          size={6}
+          classNames={mx(turn && (model.game.isCheckmate() ? 'text-red-500' : 'text-green-500'))}
+        />
+      </div>
+      <div className='truncate'>{title}</div>
+      {children}
+    </div>
+  );
+};

package/src/components/{PlayerSelector.tsx → ChessboardPlayers.tsx}

@@ -2,32 +2,45 @@
 // Copyright 2024 DXOS.org
 //
 
-import React from 'react';
+import React, { type PropsWithChildren } from 'react';
 
 import { generateName } from '@dxos/display-name';
-import { useMembers, type Space, type SpaceMember } from '@dxos/react-client/echo';
+import { type SpaceMember, getSpace, useMembers } from '@dxos/react-client/echo';
 import { Icon, Input, Select, useThemeContext } from '@dxos/react-ui';
+import { type ThemedClassName } from '@dxos/react-ui';
+import { useGameboardContext } from '@dxos/react-ui-gameboard';
+import { mx } from '@dxos/react-ui-theme';
 
-import { type ChessType } from '../types';
+import { type Chess } from '../types';
 
-export const PlayerSelector = ({ space, game }: { space: Space; game: ChessType }) => {
-  const members = useMembers(space.key);
+import { type ExtendedChessModel } from './Chessboard';
+
+export type ChessboardPlayersProps = ThemedClassName<PropsWithChildren>;
+
+export const ChessboardPlayers = ({ classNames, children }: ChessboardPlayersProps) => {
+  const { model } = useGameboardContext<ExtendedChessModel>(ChessboardPlayers.displayName);
+  const members = useMembers(getSpace(model.object)?.key);
+  const players: Chess.Game['players'] = model.object.players;
+  if (!players) {
+    return null;
+  }
 
   return (
-    <div role='none' className='grid grid-cols-2 gap-8'>
+    <div role='none' className={mx('grid grid-cols-[1fr_min-content_1fr] pis-2 pie-2 overflow-hidden', classNames)}>
       <div role='none' className='flex flex-row-reverse items-center gap-2'>
         <PlayerSelect
           side='white'
-          value={game.playerWhite}
-          onValueChange={(player) => (game.playerWhite = player)}
+          value={players.white}
+          onValueChange={(player) => (players.white = player)}
           members={members}
         />
       </div>
+      <div className='flex flex-row justify-center items-center'>{children}</div>
       <div role='none' className='flex flex-row items-center gap-2'>
         <PlayerSelect
           side='black'
-          value={game.playerBlack}
-          onValueChange={(player) => (game.playerBlack = player)}
+          value={players.black}
+          onValueChange={(player) => (players.black = player)}
           members={members}
         />
       </div>
@@ -35,6 +48,8 @@ export const PlayerSelector = ({ space, game }: { space: Space; game: ChessType
   );
 };
 
+ChessboardPlayers.displayName = 'Chessboard.Players';
+
 const PlayerSelect = ({
   side,
   value,
@@ -74,6 +89,7 @@ const PlayerSelect = ({
                 );
               })}
             </Select.Viewport>
+            <Select.Arrow />
           </Select.Content>
         </Select.Portal>
       </Select.Root>

package/src/components/index.ts

@@ -4,6 +4,6 @@
 
 import { lazy } from 'react';
 
-export * from './Chess';
+export * from './Chessboard';
 
-export const ChessContainer = lazy(() => import('./ChessContainer'));
+export const ChessboardContainer = lazy(() => import('./ChessboardContainer'));

package/src/functions/create.ts

@@ -0,0 +1,30 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Effect, Schema } from 'effect';
+
+import { DatabaseService, defineFunction } from '@dxos/functions';
+
+import { Chess } from '../types';
+
+export default defineFunction({
+  name: 'dxos.org/function/chess/create',
+  description: 'Creates a new chess game.',
+  inputSchema: Schema.Struct({
+    pgn: Schema.optional(
+      Schema.String.annotations({
+        description: 'Portable Game Notation.',
+      }),
+    ),
+    fen: Schema.optional(
+      Schema.String.annotations({
+        description: 'Forsyth-Edwards Notation.',
+      }),
+    ),
+  }),
+  outputSchema: Chess.Game,
+  handler: Effect.fn(function* ({ data: { pgn, fen } }) {
+    return yield* DatabaseService.add(Chess.makeGame({ pgn, fen }));
+  }),
+});

package/src/functions/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export { default as create } from './create';
+export { default as move } from './move';
+export { default as play } from './play';

package/src/functions/move.ts

@@ -0,0 +1,43 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Chess as ChessJS } from 'chess.js';
+import { Effect, Schema } from 'effect';
+
+import { ArtifactId } from '@dxos/assistant';
+import { DatabaseService, defineFunction } from '@dxos/functions';
+
+import { Chess } from '../types';
+
+export default defineFunction({
+  name: 'dxos.org/function/chess/move',
+  description: 'Makes a move in the given chess game.',
+  inputSchema: Schema.Struct({
+    id: ArtifactId.annotations({
+      description: 'The ID of the chess object.',
+    }),
+    move: Schema.String.annotations({
+      description: 'The move to make in the chess game.',
+      examples: ['e4', 'Bf3'],
+    }),
+  }),
+  outputSchema: Schema.Struct({
+    pgn: Schema.String.annotations({
+      description: 'The PGN of the game after the move was played.',
+    }),
+  }),
+  handler: Effect.fn(function* ({ data: { id, move } }) {
+    const object = yield* DatabaseService.resolve(ArtifactId.toDXN(id), Chess.Game);
+    const chess = new ChessJS();
+    if (object.pgn) {
+      chess.loadPgn(object.pgn);
+    } else if (object.fen) {
+      chess.load(object.fen);
+    }
+
+    chess.move(move, { strict: false });
+    object.pgn = chess.pgn();
+    return { pgn: object.pgn };
+  }),
+});

package/src/functions/play.ts

@@ -0,0 +1,45 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Chess as ChessJS } from 'chess.js';
+import { Effect, Schema } from 'effect';
+
+import { ArtifactId } from '@dxos/assistant';
+import { DatabaseService, defineFunction } from '@dxos/functions';
+
+import { Chess } from '../types';
+
+export default defineFunction({
+  name: 'dxos.org/function/chess/play',
+  description: 'Uses the chess engine to play the next move.',
+  inputSchema: Schema.Struct({
+    id: ArtifactId.annotations({
+      description: 'The ID of the chess object.',
+    }),
+  }),
+  outputSchema: Schema.Struct({
+    pgn: Schema.String.annotations({
+      description: 'The PGN of the game after the move was played.',
+    }),
+    move: Schema.optional(Schema.String).annotations({
+      description: 'The move that was played.',
+    }),
+  }),
+  handler: Effect.fn(function* ({ data: { id } }) {
+    const object = yield* DatabaseService.resolve(ArtifactId.toDXN(id), Chess.Game);
+    const chess = new ChessJS();
+    if (object.pgn) {
+      chess.loadPgn(object.pgn);
+    } else if (object.fen) {
+      chess.load(object.fen);
+    }
+
+    const moves = chess.moves();
+    const move = moves[Math.floor(Math.random() * moves.length)];
+
+    chess.move(move, { strict: false });
+    object.pgn = chess.pgn();
+    return { move, pgn: object.pgn };
+  }),
+});

package/src/index.ts

@@ -4,6 +4,8 @@
 
 export * from './capabilities';
 export * from './components';
+export * from './functions';
 export * from './meta';
+export * from './types';
 
 export * from './ChessPlugin';

package/src/meta.ts

@@ -3,14 +3,16 @@
 //
 
 import { type PluginMeta } from '@dxos/app-framework';
+import { trim } from '@dxos/util';
 
 export const CHESS_PLUGIN = 'dxos.org/plugin/chess';
 
 export const meta: PluginMeta = {
   id: CHESS_PLUGIN,
   name: 'Chess',
-  description:
-    'Chess is a simple plugin which allows you to render an interactive chessboard inside of a plank. This chessboard can be used for collaborative chess games, or for practice experiments with the LLM. ',
+  description: trim`
+    Play chess with friends or practice with the AI.
+  `,
   icon: 'ph--shield-chevron--regular',
   source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-chess',
   screenshots: ['https://dxos.network/plugin-details-chess-dark.png'],

package/src/translations.ts

@@ -5,12 +5,12 @@
 import { type Resource } from '@dxos/react-ui';
 
 import { meta } from './meta';
-import { ChessType } from './types';
+import { Chess } from './types';
 
 export const translations = [
   {
     'en-US': {
-      [ChessType.typename]: {
+      [Chess.Game.typename]: {
         'typename label': 'Game',
         'typename label_zero': 'Games',
         'typename label_one': 'Game',
@@ -18,10 +18,16 @@ export const translations = [
         'object name placeholder': 'New game',
         'rename object label': 'Rename game',
         'delete object label': 'Delete game',
+        'button toggle info': 'Toggle info',
+        'button flip': 'Flip board',
       },
       [meta.id]: {
         'plugin name': 'Chess',
         'delete game label': 'Delete',
+        'game.checkmate': 'Checkmate',
+        'game.stalemate': 'Stalemate',
+        'game.draw': 'Draw',
+        'game.check': 'Check',
       },
     },
   },

package/src/types/Chess.ts

@@ -0,0 +1,66 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { Chess as ChessJS } from 'chess.js';
+import { Schema } from 'effect';
+
+import { Obj, Type } from '@dxos/echo';
+import { LabelAnnotation } from '@dxos/echo-schema';
+import { log } from '@dxos/log';
+import { ItemAnnotation } from '@dxos/schema';
+
+export const Game = Schema.Struct({
+  name: Schema.optional(Schema.String),
+  players: Schema.optional(
+    Schema.Struct({
+      white: Schema.optional(
+        Schema.String.annotations({
+          description: 'DID of white player',
+        }),
+      ),
+      black: Schema.optional(
+        Schema.String.annotations({
+          description: 'DID of black player',
+        }),
+      ),
+    }).pipe(Schema.mutable),
+  ),
+  pgn: Schema.optional(
+    Schema.String.annotations({
+      description: 'Portable Game Notation.',
+    }),
+  ),
+  fen: Schema.optional(
+    Schema.String.annotations({
+      description: 'Forsyth-Edwards Notation.',
+    }),
+  ),
+}).pipe(
+  Type.Obj({
+    typename: 'dxos.org/type/Chess',
+    version: '0.2.0',
+  }),
+  LabelAnnotation.set(['name']),
+  ItemAnnotation.set(true),
+);
+
+export interface Game extends Schema.Schema.Type<typeof Game> {}
+
+export const makeGame = ({ name, pgn, fen }: { name?: string; pgn?: string; fen?: string } = {}) => {
+  const chess = new ChessJS();
+  if (pgn) {
+    try {
+      chess.loadPgn(pgn);
+    } catch {
+      log.warn(pgn);
+    }
+  }
+
+  return Obj.make(Game, {
+    name,
+    players: {},
+    pgn,
+    fen,
+  });
+};

package/src/types/ChessAction.ts

@@ -0,0 +1,19 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { Schema } from 'effect';
+
+import { meta } from '../meta';
+
+import { Game } from './Chess';
+
+export class Create extends Schema.TaggedClass<Create>()(`${meta.id}/action/create`, {
+  input: Schema.Struct({
+    name: Schema.optional(Schema.String),
+    pgn: Schema.optional(Schema.String),
+  }),
+  output: Schema.Struct({
+    object: Game,
+  }),
+}) {}

package/src/types/index.ts

@@ -2,5 +2,5 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './schema';
-export * from './types';
+export * as Chess from './Chess';
+export * as ChessAction from './ChessAction';