@dxos/plugin-space 0.8.4-main.84f28bd → 0.8.4-main.8baae0fced

package/src/{components/PopoverRenameSpace.tsx → containers/SpaceRenamePopover/SpaceRenamePopover.tsx}

@@ -4,39 +4,39 @@
 
 import React, { useCallback, useRef, useState } from 'react';
 
-import { createIntent, LayoutAction, useIntentDispatcher } from '@dxos/app-framework';
-import { type Space } from '@dxos/react-client/echo';
+import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { type Space } from '@dxos/client/echo';
+import { Obj } from '@dxos/echo';
 import { Button, Input, Popover, useTranslation } from '@dxos/react-ui';
+import { osTranslations } from '@dxos/ui-theme';
 
-import { SPACE_PLUGIN } from '../meta';
+import { meta } from '#meta';
 
-export const POPOVER_RENAME_SPACE = `${SPACE_PLUGIN}/PopoverRenameSpace`;
+export const SPACE_RENAME_POPOVER = `${meta.id}.SpaceRenamePopover`;
 
-export const PopoverRenameSpace = ({ space }: { space: Space }) => {
-  const { t } = useTranslation(SPACE_PLUGIN);
+export const SpaceRenamePopover = ({ space }: { space: Space }) => {
+  const { t } = useTranslation(meta.id);
   const doneButton = useRef<HTMLButtonElement>(null);
   const [name, setName] = useState(space.properties.name ?? '');
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
+  const { invokePromise } = useOperationInvoker();
 
   const handleDone = useCallback(() => {
-    space.properties.name = name;
-    void dispatch(
-      createIntent(LayoutAction.UpdatePopover, {
-        part: 'popover',
-        options: { variant: 'react', anchorId: '', state: false },
-      }),
-    );
-  }, [space, name]);
+    Obj.update(space.properties, (obj) => {
+      obj.name = name;
+    });
+    void invokePromise(LayoutOperation.UpdatePopover, { anchorId: '', state: false });
+  }, [space, name, invokePromise]);
 
   // TODO(thure): Why does the input value need to be uncontrolled to work?
   return (
-    <div role='none' className='p-2 flex gap-2'>
-      <div role='none' className='flex-1'>
+    <div className='p-2 flex gap-2'>
+      <div className='flex-1'>
         <Input.Root>
-          <Input.Label srOnly>{t('space name label')}</Input.Label>
+          <Input.Label srOnly>{t('space-name.label')}</Input.Label>
           <Input.TextInput
             defaultValue={space.properties.name ?? ''}
-            placeholder={t('unnamed space label')}
+            placeholder={t('unnamed-space.label')}
             onChange={({ target: { value } }) => setName(value)}
             // TODO(wittjosiah): Ideally this should access the popover context to close the popover.
             //   Currently this is not possible because Radix does not expose the popover context.
@@ -46,7 +46,7 @@ export const PopoverRenameSpace = ({ space }: { space: Space }) => {
       </div>
       <Popover.Close asChild>
         <Button ref={doneButton} classNames='self-stretch' onClick={handleDone}>
-          {t('done label', { ns: 'os' })}
+          {t('done.label', { ns: osTranslations })}
         </Button>
       </Popover.Close>
     </div>

package/src/containers/SpaceRenamePopover/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+export { SpaceRenamePopover as default } from './SpaceRenamePopover';

package/src/containers/SpaceSettingsContainer/SpaceSettingsContainer.stories.tsx

@@ -0,0 +1,48 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React from 'react';
+
+import { ProcessManagerPlugin } from '@dxos/app-framework';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { AppSurface } from '@dxos/app-toolkit/ui';
+import { useClientStory, withClientProvider } from '@dxos/react-client/testing';
+import { Loading, withLayout, withTheme } from '@dxos/react-ui/testing';
+
+import { translations } from '#translations';
+
+import { SpaceSettingsContainer } from './SpaceSettingsContainer';
+
+const Story = (props: Partial<AppSurface.SpaceArticleProps>) => {
+  const { space } = useClientStory();
+  if (!space) {
+    return <Loading />;
+  }
+
+  return <SpaceSettingsContainer role='article' attendableId={space.id} {...props} space={space} />;
+};
+
+const meta = {
+  title: 'plugins/plugin-space/containers/SpaceSettingsContainer',
+  component: SpaceSettingsContainer,
+  render: Story,
+  decorators: [
+    withTheme(),
+    withLayout({ layout: 'fullscreen' }),
+    withClientProvider({ createIdentity: true, createSpace: true }),
+    // TODO(wittjosiah): Try to write story which does not depend on plugin manager.
+    withPluginManager({ plugins: [ProcessManagerPlugin()] }),
+  ],
+  parameters: {
+    translations,
+    layout: 'fullscreen',
+  },
+} satisfies Meta<typeof SpaceSettingsContainer>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: StoryObj<typeof SpaceSettingsContainer> = {};

package/src/containers/SpaceSettingsContainer/SpaceSettingsContainer.tsx

@@ -0,0 +1,350 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import React, { type ChangeEvent, useCallback, useEffect, useMemo, useState } from 'react';
+
+import { useCapabilities, useOperationInvoker } from '@dxos/app-framework/ui';
+import { getPersonalSpace, getSpacePath, isPersonalSpace, LayoutOperation } from '@dxos/app-toolkit';
+import { AppSurface } from '@dxos/app-toolkit/ui';
+import { Filter, Obj, Relation } from '@dxos/echo';
+import { log } from '@dxos/log';
+import { SpaceArchive } from '@dxos/protocols/proto/dxos/client/services';
+import { EdgeReplicationSetting } from '@dxos/protocols/proto/dxos/echo/metadata';
+import { useClient } from '@dxos/react-client';
+import { type Space, SpaceState, useQuery } from '@dxos/react-client/echo';
+import {
+  Button,
+  Dialog,
+  DropdownMenu,
+  Icon,
+  IconButton,
+  Input,
+  useMulticastObservable,
+  useTranslation,
+} from '@dxos/react-ui';
+import { Form, type FormFieldMap, Settings } from '@dxos/react-ui-form';
+import { HuePicker, IconPicker } from '@dxos/react-ui-pickers';
+import { ConfirmReset } from '@dxos/shell/react';
+
+import { meta } from '#meta';
+import { SpaceOperation } from '#operations';
+import { SpaceCapabilities, SpaceForm } from '#types';
+
+const SpaceFormSchema = SpaceForm.pipe(
+  Schema.extend(
+    Schema.Struct({
+      archived: Schema.Boolean.annotations({ title: 'Archive Space' }),
+    }),
+  ),
+);
+
+// TODO(wittjosiah): Handle space migrations here?
+export const SpaceSettingsContainer = ({ space }: AppSurface.SpaceArticleProps) => {
+  const { t } = useTranslation(meta.id);
+  const { invokePromise } = useOperationInvoker();
+  const client = useClient();
+  const archived = useMulticastObservable(space.state) === SpaceState.SPACE_INACTIVE;
+  const [edgeReplication, setEdgeReplication] = useState(
+    space.internal.data.edgeReplication === EdgeReplicationSetting.ENABLED,
+  );
+  const toggleEdgeReplication = useCallback(
+    async (next: boolean) => {
+      setEdgeReplication(next);
+      await space?.internal
+        .setEdgeReplicationPreference(next ? EdgeReplicationSetting.ENABLED : EdgeReplicationSetting.DISABLED)
+        .catch((err: unknown) => {
+          log.catch(err);
+          setEdgeReplication(!next);
+        });
+    },
+    [space],
+  );
+
+  const handleValuesChanged = useCallback(
+    (newValues: Partial<Schema.Schema.Type<typeof SpaceFormSchema>>, meta: { changed?: Record<string, boolean> }) => {
+      const changed = meta.changed ?? {};
+      if (changed['edgeReplication']) {
+        void toggleEdgeReplication(newValues.edgeReplication ?? false);
+      }
+
+      if (changed['name'] || changed['icon'] || changed['hue']) {
+        Obj.update(space.properties, (obj) => {
+          if (changed['name'] && newValues.name !== undefined) {
+            obj.name = newValues.name;
+          }
+          if (changed['icon']) {
+            obj.icon = newValues.icon;
+          }
+          if (changed['hue']) {
+            obj.hue = newValues.hue;
+          }
+        });
+      }
+
+      if (changed['archived']) {
+        if (newValues.archived && !archived) {
+          void invokePromise(SpaceOperation.Close, { space });
+          const personalSpace = getPersonalSpace(client);
+          if (personalSpace) {
+            void invokePromise(LayoutOperation.SwitchWorkspace, {
+              subject: getSpacePath(personalSpace.id),
+            });
+          }
+        } else if (!newValues.archived && archived) {
+          void invokePromise(SpaceOperation.Open, { space });
+        }
+      }
+    },
+    [space, client, archived, invokePromise, toggleEdgeReplication],
+  );
+
+  const defaultValues = useMemo(
+    () => ({
+      name: space.properties.name,
+      icon: space.properties.icon,
+      hue: space.properties.hue,
+      edgeReplication,
+      archived,
+    }),
+    [space.properties.name, space.properties.icon, space.properties.hue, edgeReplication, archived],
+  );
+
+  const personal = isPersonalSpace(space);
+
+  const fieldMap = useMemo<FormFieldMap>(
+    () => ({
+      name: personal
+        ? () => null
+        : ({ type, label, getValue, onValueChange }) => {
+            const handleChange = useCallback(
+              ({ target: { value } }: ChangeEvent<HTMLInputElement>) => onValueChange(type, value),
+              [onValueChange, type],
+            );
+            return (
+              <Settings.Item title={label} description={t('display-name.description')}>
+                <Input.TextInput
+                  value={getValue()}
+                  onChange={handleChange}
+                  placeholder={t('display-name-input.placeholder')}
+                  classNames='min-w-64'
+                />
+              </Settings.Item>
+            );
+          },
+      icon: personal
+        ? () => null
+        : ({ type, label, getValue, onValueChange }) => {
+            const handleChange = useCallback((icon: string) => onValueChange(type, icon), [onValueChange, type]);
+            const handleReset = useCallback(() => onValueChange(type, undefined), [onValueChange, type]);
+            return (
+              <Settings.Item title={label} description={t('icon.description')}>
+                <IconPicker
+                  value={getValue()}
+                  onChange={handleChange}
+                  onReset={handleReset}
+                  classNames='justify-self-end'
+                />
+              </Settings.Item>
+            );
+          },
+      hue: ({ type, label, getValue, onValueChange }) => {
+        const handleChange = useCallback((nextHue: string) => onValueChange(type, nextHue), [onValueChange, type]);
+        const handleReset = useCallback(() => onValueChange(type, undefined), [onValueChange, type]);
+        return (
+          <Settings.Item title={label} description={t('hue.description')}>
+            <HuePicker value={getValue()} onChange={handleChange} onReset={handleReset} classNames='justify-self-end' />
+          </Settings.Item>
+        );
+      },
+      edgeReplication: ({ type, label, getValue, onValueChange }) => {
+        const handleChange = useCallback((checked: boolean) => onValueChange(type, checked), [onValueChange, type]);
+        return (
+          <Settings.Item title={label} description={t('edge-replication.description')}>
+            <Input.Switch checked={getValue()} onCheckedChange={handleChange} classNames='justify-self-end' />
+          </Settings.Item>
+        );
+      },
+      archived: personal
+        ? () => null
+        : ({ type, label, getValue, onValueChange }) => {
+            const handleChange = useCallback(() => onValueChange(type, !getValue()), [onValueChange, type, getValue]);
+            return (
+              <Settings.Item title={label} description={t('archive-space.description')}>
+                <Button variant={getValue() ? 'default' : 'destructive'} onClick={handleChange}>
+                  {getValue() ? t('unarchive-space.label') : t('archive-space.label')}
+                </Button>
+              </Settings.Item>
+            );
+          },
+    }),
+    [t, space, personal],
+  );
+
+  const handleBackupBinary = useCallback(async () => {
+    await invokePromise(SpaceOperation.ExportSpace, { space, format: SpaceArchive.Format.BINARY });
+  }, [space, invokePromise]);
+  const handleBackupJson = useCallback(async () => {
+    await invokePromise(SpaceOperation.ExportSpace, { space, format: SpaceArchive.Format.JSON });
+  }, [space, invokePromise]);
+
+  const repairs = useCapabilities(SpaceCapabilities.Repair);
+  const handleRepair = useCallback(async () => {
+    await Promise.all(repairs.map((repair) => repair({ space, isDefault: isPersonalSpace(space) })));
+  }, [space, repairs]);
+
+  const { schemas, objects, relations, feeds } = useSpaceCounts(space);
+  const [resetConfirmOpen, setResetConfirmOpen] = useState(false);
+  const handleReset = useCallback(async () => {
+    log.info('reset: confirmed in dialog', { spaceId: space.id });
+    try {
+      await invokePromise(SpaceOperation.Reset, { space });
+      log.info('reset: invocation resolved', { spaceId: space.id });
+    } catch (err) {
+      log.catch(err, { stage: 'reset: invocation rejected', spaceId: space.id });
+      throw err;
+    }
+    setResetConfirmOpen(false);
+  }, [space, invokePromise]);
+  const handleResetCancel = useCallback(() => setResetConfirmOpen(false), []);
+
+  return (
+    <Settings.Viewport>
+      <Settings.Section
+        title={t('space-properties-settings-verbose.label')}
+        description={t('space-properties-settings.description', { ns: meta.id })}
+      >
+        <Form.Root
+          key={space.id}
+          fieldMap={fieldMap}
+          schema={SpaceFormSchema}
+          defaultValues={defaultValues}
+          onValuesChanged={handleValuesChanged}
+        >
+          <Form.FieldSet />
+        </Form.Root>
+      </Settings.Section>
+
+      <Settings.Section title={t('space-controls.title')} description={t('space-controls.description')}>
+        <Settings.Item title={t('space-key.title')} description={t('space-key.description')}>
+          <div className='flex items-center gap-2'>
+            <Input.Root>
+              <Input.TextInput value={space.key.toHex()} disabled classNames='flex-1 font-mono text-xs' />
+            </Input.Root>
+            <IconButton
+              icon='ph--copy--regular'
+              iconOnly
+              label={t('copy-space-key.label')}
+              onClick={() => {
+                void navigator.clipboard.writeText(space.key.toHex());
+              }}
+            />
+          </div>
+        </Settings.Item>
+        <Settings.Item title={t('backup-space.title')} description={t('backup-space.description')}>
+          <DropdownMenu.Root>
+            <DropdownMenu.Trigger asChild>
+              <Button>
+                {t('download-backup.label')}
+                <Icon icon='ph--caret-down--regular' size={4} classNames='mis-2' />
+              </Button>
+            </DropdownMenu.Trigger>
+            <DropdownMenu.Content>
+              <DropdownMenu.Viewport>
+                <DropdownMenu.Item onClick={handleBackupBinary}>{t('download-backup-binary.label')}</DropdownMenu.Item>
+                <DropdownMenu.Item onClick={handleBackupJson}>{t('download-backup-json.label')}</DropdownMenu.Item>
+              </DropdownMenu.Viewport>
+            </DropdownMenu.Content>
+          </DropdownMenu.Root>
+        </Settings.Item>
+        <Settings.Item title={t('repair-space.title')} description={t('repair-space.description')}>
+          <Button onClick={handleRepair}>{t('repair-space.label')}</Button>
+        </Settings.Item>
+      </Settings.Section>
+
+      <Settings.Section title={t('danger-zone.title')} description={t('danger-zone.description')}>
+        <Settings.Item title={t('space-contents.title')} description={t('space-contents.description')}>
+          <div className='grid grid-cols-4 gap-2 justify-self-end text-center'>
+            <ContentCount label={t('schema-count.label')} value={schemas} />
+            <ContentCount label={t('object-count.label')} value={objects} />
+            <ContentCount label={t('relation-count.label')} value={relations} />
+            <ContentCount label={t('feed-count.label')} value={feeds} />
+          </div>
+        </Settings.Item>
+        <Settings.Item title={t('reset-space.title')} description={t('reset-space.description')}>
+          <Dialog.Root open={resetConfirmOpen} onOpenChange={setResetConfirmOpen}>
+            <Dialog.Trigger asChild>
+              <Button variant='destructive'>{t('reset-space.label')}</Button>
+            </Dialog.Trigger>
+            <Dialog.Portal>
+              <Dialog.Overlay>
+                <Dialog.Content>
+                  <Dialog.Header>
+                    <Dialog.Title>{t('reset-space-confirm.title')}</Dialog.Title>
+                  </Dialog.Header>
+                  <Dialog.Body>
+                    <Dialog.Description classNames='sr-only'>{t('reset-space-confirm.description')}</Dialog.Description>
+                    <ConfirmReset
+                      active
+                      title={t('reset-space-confirm.title')}
+                      message={t('reset-space-confirm.description')}
+                      confirmLabel={t('reset-space.label')}
+                      errorMessage={t('reset-space-failed.message')}
+                      onConfirm={handleReset}
+                      onCancel={handleResetCancel}
+                    />
+                  </Dialog.Body>
+                </Dialog.Content>
+              </Dialog.Overlay>
+            </Dialog.Portal>
+          </Dialog.Root>
+        </Settings.Item>
+      </Settings.Section>
+    </Settings.Viewport>
+  );
+};
+
+SpaceSettingsContainer.displayName = 'SpaceSettingsContainer';
+
+const ContentCount = ({ label, value }: { label: string; value: number }) => (
+  <div className='flex flex-col items-center'>
+    <div className='text-lg font-mono tabular-nums'>{value}</div>
+    <div className='text-xs text-description'>{label}</div>
+  </div>
+);
+
+type SpaceCounts = {
+  schemas: number;
+  objects: number;
+  relations: number;
+  feeds: number;
+};
+
+const useSpaceCounts = (space: Space): SpaceCounts => {
+  const entities = useQuery(space.db, Filter.everything());
+  const { objects, relations } = useMemo(() => {
+    let objects = 0;
+    let relations = 0;
+    for (const entity of entities) {
+      if (Relation.isRelation(entity)) {
+        relations += 1;
+      } else {
+        objects += 1;
+      }
+    }
+    return { objects, relations };
+  }, [entities]);
+
+  const [schemas, setSchemas] = useState(0);
+  useEffect(() => {
+    const query = space.db.schemaRegistry.query();
+    setSchemas(query.runSync().length);
+    return query.subscribe(() => setSchemas(query.results.length));
+  }, [space]);
+
+  const pipeline = useMulticastObservable(space.pipeline);
+  const feeds = (pipeline.controlFeeds?.length ?? 0) + (pipeline.dataFeeds?.length ?? 0);
+
+  return { schemas, objects, relations, feeds };
+};

package/src/containers/SpaceSettingsContainer/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export { SpaceSettingsContainer as default } from './SpaceSettingsContainer';

package/src/{components → containers}/SyncStatus/SyncStatus.stories.tsx

@@ -2,28 +2,28 @@
 // Copyright 2023 DXOS.org
 //
 
-import '@dxos-theme';
-
 import { type Meta, type StoryObj } from '@storybook/react-vite';
 
-import { withTheme } from '@dxos/storybook-utils';
+import { withClientProvider } from '@dxos/react-client/testing';
+import { withTheme } from '@dxos/react-ui/testing';
+
+import { translations } from '#translations';
 
 import { SyncStatusIndicator } from './SyncStatus';
-import { translations } from '../../translations';
 
-const meta: Meta = {
-  title: 'plugins/plugin-space/SyncStatusIndicator',
+const meta = {
+  title: 'plugins/plugin-space/containers/SyncStatusIndicator',
   component: SyncStatusIndicator,
-  decorators: [withTheme],
+  decorators: [withTheme(), withClientProvider({ createIdentity: true })],
   parameters: {
-    translations,
     layout: 'centered',
+    translations,
   },
-};
+} satisfies Meta<typeof SyncStatusIndicator>;
 
 export default meta;
 
-type Story = StoryObj<typeof SyncStatusIndicator>;
+type Story = StoryObj<typeof meta>;
 
 export const Default: Story = {
   args: {

package/src/containers/SyncStatus/SyncStatus.tsx

@@ -0,0 +1,149 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import React, { useEffect, useState } from 'react';
+
+import { log } from '@dxos/log';
+import { StatusBar } from '@dxos/plugin-status-bar/components';
+import { EdgeStatus } from '@dxos/protocols/proto/dxos/client/services';
+import { type QueryEdgeStatusResponse } from '@dxos/protocols/proto/dxos/client/services';
+import { useClient } from '@dxos/react-client';
+import { useStream } from '@dxos/react-client/devtools';
+import { type SpaceSyncStateMap, getSyncSummary, useSyncState } from '@dxos/react-client/echo';
+import { Icon, IconButton, Popover, useTranslation } from '@dxos/react-ui';
+import { iconSize, mx } from '@dxos/ui-theme';
+import { Unit, type UnitFormat } from '@dxos/util';
+
+import { createClientSaveTracker, getIcon, getStatus } from '#components';
+import { meta } from '#meta';
+
+const SYNC_STALLED_TIMEOUT = 5_000;
+
+export const SyncStatus = () => {
+  const client = useClient();
+  const state = useSyncState();
+  const [saved, setSaved] = useState(true);
+  useEffect(() => createClientSaveTracker(client, (state) => setSaved(state === 'saved')), []);
+
+  return <SyncStatusIndicator state={state} saved={saved} />;
+};
+
+export const SyncStatusIndicator = ({ state, saved }: { state: SpaceSyncStateMap; saved: boolean }) => {
+  const { t } = useTranslation(meta.id);
+  const summary = getSyncSummary(state);
+  const offline = Object.values(state).length === 0;
+  const needsToUpload = summary.differentDocuments > 0 || summary.missingOnRemote > 0;
+  const needsToDownload = summary.differentDocuments > 0 || summary.missingOnLocal > 0;
+  const status = getStatus({ offline, saved, needsToUpload, needsToDownload });
+
+  const [classNames, setClassNames] = useState<string>();
+  useEffect(() => {
+    setClassNames(undefined);
+    if (offline || (!needsToUpload && !needsToDownload)) {
+      return;
+    }
+
+    const t = setTimeout(() => {
+      log.warn('sync stalled', { state });
+      setClassNames('text-error-text');
+    }, SYNC_STALLED_TIMEOUT);
+
+    return () => {
+      clearTimeout(t);
+      setClassNames(undefined);
+    };
+  }, [offline, needsToUpload, needsToDownload]);
+
+  return (
+    <Popover.Root>
+      <Popover.Trigger asChild>
+        <StatusBar.Item>
+          <IconButton icon={getIcon(status)} iconOnly label={t(`${status}.label`)} classNames={classNames} />
+        </StatusBar.Item>
+      </Popover.Trigger>
+      <Popover.Portal>
+        <Popover.Content side='left' classNames=''>
+          <EdgeConnectionPopover />
+          <Popover.Arrow />
+        </Popover.Content>
+      </Popover.Portal>
+    </Popover.Root>
+  );
+};
+
+const EdgeConnectionPopover = () => {
+  const { t } = useTranslation(meta.id);
+  const client = useClient();
+  const { status } = useStream(
+    () => client.services.services.EdgeAgentService!.queryEdgeStatus(),
+    {} as QueryEdgeStatusResponse,
+  );
+
+  const isConnected = status?.state === EdgeStatus.ConnectionState.CONNECTED;
+
+  return (
+    <div className='flex flex-col gap-2 w-[240px] p-2' style={iconSize(4)}>
+      {/* Connection Status Header */}
+      <div className='flex items-center gap-2 mb-2'>
+        <Icon
+          icon={isConnected ? 'ph--check-circle--regular' : 'ph--warning-circle--regular'}
+          classNames={mx(isConnected ? 'text-success-text' : 'text-error-text animate-pulse')}
+        />
+        <span className='font-medium text-sm'>
+          {isConnected ? t('sync-edge-connected.label') : t('sync-edge-disconnected.label')}
+        </span>
+      </div>
+
+      {/* Connection Details */}
+      {status?.state === EdgeStatus.ConnectionState.NOT_CONNECTED && (
+        <div className='grid grid-cols-[min-content_1fr_min-content_min-content] gap-2'>
+          <Icon icon='ph--cloud-x--regular' />
+          <span className='text-description'>{t('sync-no-connection.label')}</span>
+        </div>
+      )}
+
+      {status?.state === EdgeStatus.ConnectionState.CONNECTED && (
+        <div className='grid grid-cols-[min-content_1fr_min-content_min-content] gap-2 gap-y-1'>
+          {/* Latency */}
+          <div className='col-span-full grid grid-cols-subgrid gap-2 items-center text-sm'>
+            <Icon icon='ph--timer--regular' />
+            <span className='text-description'>{t('sync-latency.label')}</span>
+            <div />
+            <UnitValue value={status.rtt} format={Unit.Millisecond} />
+          </div>
+
+          {/* Upload Speed */}
+          <div className='col-span-full grid grid-cols-subgrid gap-2 items-center text-sm'>
+            <Icon icon='ph--arrow-up--regular' classNames='text-green-500' />
+            <span className='text-description'>{t('sync-upload.label')}</span>
+            <UnitValue value={status.messagesSent} format={Unit.Thousand} />
+            <UnitValue value={status.rateBytesUp} format={Unit.Kilobyte} suffix='/s' />
+          </div>
+
+          {/* Download Speed */}
+          <div className='col-span-full grid grid-cols-subgrid gap-2 items-center text-sm'>
+            <Icon icon='ph--arrow-down--regular' classNames='text-orange-500' />
+            <span className='text-description'>{t('sync-download.label')}</span>
+            <UnitValue value={status.messagesReceived} format={Unit.Thousand} />
+            <UnitValue value={status.rateBytesDown} format={Unit.Kilobyte} suffix='/s' />
+          </div>
+        </div>
+      )}
+    </div>
+  );
+};
+
+// TODO(burdon): Factor out.
+const UnitValue = ({ value: input, format, suffix }: { value: number; format: UnitFormat; suffix?: string }) => {
+  const { formattedValue, unit } = format(input);
+  return (
+    <span className='font-mono'>
+      {formattedValue}
+      <span className='ms-1 text-subdued'>
+        {unit.symbol}
+        {suffix}
+      </span>
+    </span>
+  );
+};

package/src/containers/SyncStatus/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export { SyncStatus as default } from './SyncStatus';