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

package/src/components/ChessboardArticle.tsx

@@ -0,0 +1,69 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import React, { useCallback, useRef, useState } from 'react';
+
+import { IconButton, Toolbar, 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, role }: { game: Chess.Game; role?: string }) => {
+  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 toolbar classNames='@container bs-full is-full overflow-hidden'>
+      <Chessboard.Root game={game} ref={controller}>
+        <Toolbar.Root>
+          <IconButton
+            variant='ghost'
+            icon='ph--info--regular'
+            iconOnly
+            label={t('toggle info button')}
+            size={6}
+            classNames={mx('invisible', !open && '@3xl:visible')}
+            onClick={() => setOpen((open) => !open)}
+          />
+        </Toolbar.Root>
+        <div
+          className={mx(
+            'grid _grid-rows-[1fr_4rem] 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>
+    </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} role={role} />;
+    }
+  }
+};
+
+export default ChessboardContainer;

package/src/components/Info.tsx

@@ -0,0 +1,236 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import React, { type JSX, type PropsWithChildren, useEffect, useMemo, useRef } from 'react';
+
+import { generateName } from '@dxos/display-name';
+import { type SpaceMember, getSpace, useMembers } from '@dxos/react-client/echo';
+import { Icon, IconButton, Select, 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 InfoProps = ThemedClassName<
+  {
+    orientation?: Player;
+    onOrientationChange?: (orientation: Player) => void;
+    onClose?: () => void;
+  } & Pick<HistoryProps, 'min' | 'max' | 'onSelect'>
+>;
+
+export const Info = ({ classNames, orientation = 'white', onOrientationChange, onClose, ...props }: InfoProps) => {
+  const { t } = useTranslation(meta.id);
+  const { model } = useGameboardContext<ExtendedChessModel>(Info.displayName);
+  const members = useMembers(getSpace(model.object)?.key);
+
+  return (
+    <div
+      className={mx(
+        'grid grid-rows-[min-content_1fr_min-content] is-full min-is-[18rem] p-2 overflow-hidden bg-groupSurface rounded-sm',
+        classNames,
+      )}
+    >
+      <PlayerIndicator
+        model={model}
+        player={orientation === 'white' ? 'black' : 'white'}
+        icon={
+          onClose && (
+            <IconButton icon='ph--x--regular' iconOnly label={t('close info button')} size={4} onClick={onClose} />
+          )
+        }
+      >
+        <PlayerSelector
+          value={model.object.players?.[orientation === 'white' ? 'black' : 'white']}
+          onValueChange={(value) => {
+            model.object.players![orientation === 'white' ? 'black' : 'white'] = value;
+          }}
+          members={members}
+        />
+      </PlayerIndicator>
+
+      <History model={model} {...props} />
+
+      <PlayerIndicator
+        model={model}
+        player={orientation}
+        icon={
+          onOrientationChange && (
+            <IconButton
+              classNames={mx('transition duration-200 ease-linear', orientation === 'white' && 'rotate-180')}
+              icon='ph--arrows-clockwise--regular'
+              iconOnly
+              label={t('flip board button')}
+              size={4}
+              onClick={() => onOrientationChange(orientation === 'white' ? 'black' : 'white')}
+            />
+          )
+        }
+      >
+        <PlayerSelector
+          value={model.object.players?.[orientation]}
+          onValueChange={(value) => {
+            model.object.players![orientation] = value;
+          }}
+          members={members}
+        />
+      </PlayerIndicator>
+    </div>
+  );
+};
+
+Info.displayName = 'Chessboard.Info';
+
+//
+// History
+//
+
+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>
+  );
+};
+
+//
+// PlayerIndicator
+//
+
+type PlayerIndicatorProps = PropsWithChildren<{
+  model: ExtendedChessModel;
+  player: Player;
+  icon?: JSX.Element;
+}>;
+
+const PlayerIndicator = ({ children, model, player, icon }: PlayerIndicatorProps) => {
+  const turn = player === (model.game.turn() === 'w' ? 'white' : 'black');
+  return (
+    <div className='grid grid-cols-[2rem_1fr_2rem] gap-2 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 overflow-hidden items-center'>{children}</div>
+      {icon}
+    </div>
+  );
+};
+
+//
+// PlayerSelector
+//
+
+type PlayerSelectorProps = {
+  value?: string;
+  onValueChange: (player: string) => void;
+  members: SpaceMember[];
+};
+
+const PlayerSelector = ({ value, onValueChange, members }: PlayerSelectorProps) => {
+  const { t } = useTranslation(meta.id);
+  return (
+    <Select.Root value={value} onValueChange={onValueChange}>
+      <Select.TriggerButton placeholder={t('select player button')} />
+      <Select.Portal>
+        <Select.Content>
+          <Select.Viewport>
+            {members.map((member) => {
+              const memberKey = member.identity.identityKey.toHex();
+              const displayName = member.identity?.profile?.displayName || generateName(memberKey);
+              return (
+                <Select.Option key={memberKey} value={memberKey}>
+                  {displayName}
+                </Select.Option>
+              );
+            })}
+          </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,53 @@
+//
+// 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.',
+    }),
+    side: Schema.optional(Schema.Literal('white', 'black', 'any')).annotations({
+      description: 'The side to play.',
+      defaultValue: 'any',
+    }),
+  }),
+  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, side = 'any' } }) {
+    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);
+    }
+
+    if (!(side === 'any' || (chess.turn() === 'w' && side === 'white') || (chess.turn() === 'b' && side === 'black'))) {
+      return { move: undefined, pgn: object.pgn! };
+    }
+
+    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,18 @@ export const translations = [
         'object name placeholder': 'New game',
         'rename object label': 'Rename game',
         'delete object label': 'Delete game',
+        'toggle info button': 'Toggle info',
+        'close info button': 'Close info',
+        'flip board button': 'Flip board',
+        'select player button': 'Select player',
       },
       [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';