@dxos/plugin-preview 0.8.4-main.7ace549 → 0.8.4-main.8baae0fced

package/src/capabilities/react-surface.tsx

@@ -2,156 +2,151 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { useCallback } from 'react';
+import * as Effect from 'effect/Effect';
+import React from 'react';
 
-import { Capabilities, LayoutAction, contributes, createIntent, createSurface } from '@dxos/app-framework';
-import { Surface, SurfaceCardRole, useIntentDispatcher } from '@dxos/app-framework/react';
-import { getSpace } from '@dxos/client/echo';
-import { Obj } from '@dxos/echo';
-import { type JsonPath, setValue } from '@dxos/echo/internal';
-import { useActiveSpace } from '@dxos/plugin-space';
-import { useTranslation } from '@dxos/react-ui';
-import { Form } from '@dxos/react-ui-form';
-import { Card } from '@dxos/react-ui-stack';
-import { descriptionMessage, mx } from '@dxos/react-ui-theme';
-import { type ProjectionModel } from '@dxos/schema';
-import { Organization, Person, Project, Task } from '@dxos/types';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Surface } from '@dxos/app-framework/ui';
+import { AppSurface } from '@dxos/app-toolkit/ui';
+import { Obj, Type } from '@dxos/echo';
+import { Card } from '@dxos/react-ui';
+import { Expando, type ProjectionModel } from '@dxos/schema';
+import { Organization, Person, Pipeline, Task } from '@dxos/types';
 
-import { OrganizationCard, PersonCard, ProjectCard, TaskCard } from '../cards';
-import { meta } from '../meta';
-import { type CardPreviewProps } from '../types';
+import {
+  DynamicTypeCard,
+  ExpandoCard,
+  FormCard,
+  JsonCard,
+  OrganizationCard,
+  PersonCard,
+  ProjectCard,
+  TaskCard,
+} from '../cards';
 
-export default () =>
-  contributes(Capabilities.ReactSurface, [
-    //
-    // Specific schema types.
-    // TODO(burdon): Create helpers and factor out.
-    //
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Capabilities.ReactSurface, [
+      //
+      // Specific schema types.
+      // TODO(burdon): Create helpers and factor out.
+      //
 
-    // TODO(burdon): Infer Role type.
-    createSurface<{ subject: Person.Person }>({
-      id: `${meta.id}/schema-popover--contact`,
-      role: SurfaceCardRole.literals as any,
-      filter: (data): data is { subject: Person.Person } => Obj.instanceOf(Person.Person, data.subject),
-      component: ({ data, role }) => {
-        const { dispatchPromise: dispatch } = useIntentDispatcher();
-        const space = getSpace(data.subject);
-        const activeSpace = useActiveSpace(); // TODO(burdon): Disambiguate with space?
-        const handleSelect = useCallback<NonNullable<CardPreviewProps['onSelect']>>(
-          (object) =>
-            dispatch(
-              createIntent(LayoutAction.Open, {
-                part: 'main',
-                subject: [Obj.getDXN(object).toString()],
-                options: {
-                  workspace: space?.id,
-                },
-              }),
-            ),
-          [dispatch],
-        );
+      Surface.create<{ subject: Person.Person }>({
+        id: 'schema-popover--contact',
+        position: 'first',
+        filter: AppSurface.object(AppSurface.Card, Person.Person),
+        component: ({ data, role }) => {
+          return (
+            <>
+              <PersonCard role={role} subject={data.subject} />
+              <Surface.Surface type={AppSurface.Related} data={data} limit={1} />
+            </>
+          );
+        },
+      }),
+      Surface.create({
+        id: 'schema-popover--organization',
+        position: 'first',
+        filter: AppSurface.object(AppSurface.Card, Organization.Organization),
+        component: ({ data, role }) => {
+          return (
+            <>
+              <OrganizationCard role={role} subject={data.subject} />
+              <Surface.Surface type={AppSurface.Related} data={data} limit={1} />
+            </>
+          );
+        },
+      }),
+      Surface.create({
+        id: 'schema-popover--project',
+        position: 'first',
+        filter: AppSurface.object(AppSurface.Card, Pipeline.Pipeline),
+        component: ({ data, role }) => {
+          return <ProjectCard role={role} subject={data.subject} />;
+        },
+      }),
+      Surface.create({
+        id: 'schema-popover--task',
+        position: 'first',
+        filter: AppSurface.object(AppSurface.Card, Task.Task),
+        component: ({ data, role }) => {
+          return <TaskCard role={role} subject={data.subject} />;
+        },
+      }),
+      Surface.create<AppSurface.ObjectCardData<Expando.Expando>>({
+        id: 'schema-popover--expando',
+        filter: AppSurface.object(AppSurface.Card, Expando.Expando),
+        component: ({ data, role }) => {
+          return <ExpandoCard role={role} subject={data.subject} ignorePaths={data.ignorePaths} />;
+        },
+      }),
 
-        return (
-          <PersonCard
-            role={role as SurfaceCardRole}
-            subject={data.subject}
-            activeSpace={activeSpace}
-            onSelect={handleSelect}
-          >
-            {role === 'card--popover' && <Surface role='related' data={data} />}
-          </PersonCard>
-        );
-      },
-    }),
-    createSurface({
-      id: `${meta.id}/schema-popover--organization`,
-      role: SurfaceCardRole.literals as any,
-      filter: (data): data is { subject: Organization.Organization } =>
-        Obj.instanceOf(Organization.Organization, data.subject),
-      component: ({ data, role }) => {
-        const activeSpace = useActiveSpace();
-        return (
-          <OrganizationCard role={role as SurfaceCardRole} subject={data.subject} activeSpace={activeSpace}>
-            {role === 'card--popover' && <Surface role='related' data={data} />}
-          </OrganizationCard>
-        );
-      },
-    }),
-    createSurface({
-      id: `${meta.id}/schema-popover--project`,
-      role: SurfaceCardRole.literals as any,
-      filter: (data): data is { subject: Project.Project } => Obj.instanceOf(Project.Project, data.subject),
-      component: ({ data, role }) => {
-        const activeSpace = useActiveSpace();
-        return <ProjectCard subject={data.subject} role={role as SurfaceCardRole} activeSpace={activeSpace} />;
-      },
-    }),
-    createSurface({
-      id: `${meta.id}/schema-popover--task`,
-      role: SurfaceCardRole.literals as any,
-      filter: (data): data is { subject: Task.Task } => Obj.instanceOf(Task.Task, data.subject),
-      component: ({ data, role }) => {
-        return <TaskCard subject={data.subject} role={role as SurfaceCardRole} />;
-      },
-    }),
-
-    //
-    // Fallback for any object.
-    //
+      Surface.create({
+        id: 'schema-popover--dynamic-type',
+        role: 'card--content',
+        filter: (data): data is { subject: Obj.Unknown } => {
+          if (!Obj.isObject(data.subject)) {
+            return false;
+          }
+          const schema = Obj.getSchema(data.subject);
+          if (schema) {
+            return Type.isMutable(schema);
+          }
+          // Obj.getSchema fails for database-registered schemas (DXN mismatch); fall back to typename query.
+          try {
+            const db = Obj.getDatabase(data.subject);
+            const typename = Obj.getTypename(data.subject);
+            return !!db && !!typename && db.schemaRegistry.query({ typename }).runSync().length > 0;
+          } catch {
+            return false;
+          }
+        },
+        component: ({ data, role }) => {
+          return <DynamicTypeCard role={role} subject={data.subject} />;
+        },
+      }),
 
-    createSurface({
-      id: `${meta.id}/fallback-popover`,
-      role: SurfaceCardRole.literals as any,
-      position: 'fallback',
-      filter: (data): data is { subject: Obj.Any; projection?: ProjectionModel } => Obj.isObject(data.subject),
-      component: ({ data, role }) => {
-        const schema = Obj.getSchema(data.subject);
-        const { t } = useTranslation(meta.id);
-        if (!schema) {
-          // TODO(burdon): Use Alert.
-          return <p className={mx(descriptionMessage)}>{t('unable to create preview message')}</p>;
-        }
+      //
+      // Fallback for any object.
+      //
 
-        const handleSave = useCallback((values: any, { changed }: { changed: Record<string, boolean> }) => {
-          const changedPaths = Object.keys(changed).filter((path) => changed[path]);
-          for (const path of changedPaths) {
-            const value = values[path];
-            setValue(data.subject, path as JsonPath, value);
-          }
-        }, []);
+      Surface.create({
+        id: 'fallback-popover',
+        role: 'card--content',
+        position: 'last',
+        filter: (data): data is { subject: Obj.Unknown; projection?: ProjectionModel } => Obj.isObject(data.subject),
+        component: ({ data, role }) => {
+          return <FormCard role={role} subject={data.subject} projection={data.projection} />;
+        },
+      }),
 
-        return (
-          <Card.SurfaceRoot role={role}>
-            <Form
-              id={data.subject.id}
-              schema={schema}
-              projection={data.projection}
-              values={data.subject}
-              readonly={role === 'card--popover' ? 'static' : false}
-              onSave={handleSave}
-              autoSave
-              {...(role === 'card--intrinsic' && {
-                outerSpacing: 'blockStart-0',
-              })}
-            />
-          </Card.SurfaceRoot>
-        );
-      },
-    }),
+      Surface.create({
+        id: 'fallback-json',
+        role: 'card--content',
+        position: 'last',
+        filter: (data): data is Record<string, unknown> => true,
+        component: ({ data }) => {
+          return <JsonCard data={data} />;
+        },
+      }),
 
-    createSurface({
-      id: `${meta.id}/section`,
-      role: ['section'],
-      position: 'fallback',
-      filter: (data): data is { subject: Obj.Any } => Obj.isObject(data.subject),
-      component: ({ data }) => {
-        return (
-          <div role='none' className='flex is-full justify-center'>
-            <div role='none' className='pbs-2 pbe-2 card-min-width card-max-width'>
-              <Surface role='card' data={data} limit={1} />
+      Surface.create({
+        id: 'section',
+        position: 'last',
+        filter: AppSurface.subject(AppSurface.Section, Obj.isObject),
+        component: ({ data }) => {
+          return (
+            <div className='flex w-full justify-center'>
+              <div className='py-2 dx-card-min-width dx-card-max-width'>
+                <Card.Root>
+                  <Surface.Surface type={AppSurface.Card} data={data} limit={1} />
+                </Card.Root>
+              </div>
             </div>
-          </div>
-        );
-      },
-    }),
-  ]);
+          );
+        },
+      }),
+    ]),
+  ),
+);

package/src/cards/DynamicTypeCard.tsx

@@ -0,0 +1,53 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useCallback, useMemo } from 'react';
+
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { Obj } from '@dxos/echo';
+import { useSchema } from '@dxos/echo-react';
+import { type JsonPath, splitJsonPath } from '@dxos/effect';
+import { Card, useTranslation } from '@dxos/react-ui';
+import { Form, type FormUpdateMeta, omitId } from '@dxos/react-ui-form';
+import { descriptionMessage, mx } from '@dxos/ui-theme';
+
+import { meta } from '#meta';
+
+export const DynamicTypeCard = ({ subject }: AppSurface.ObjectCardProps) => {
+  const { t } = useTranslation(meta.id);
+  const db = Obj.getDatabase(subject);
+  const typename = Obj.getTypename(subject);
+  const runtimeSchema = useSchema(db, typename);
+  const schema = useMemo(() => runtimeSchema && omitId(runtimeSchema), [runtimeSchema]);
+
+  const handleSave = useCallback(
+    (values: Record<string, unknown>, { changed }: FormUpdateMeta<Record<string, unknown>>) => {
+      const paths = (Object.keys(changed) as JsonPath[]).filter((path) => changed[path]);
+      Obj.update(subject, () => {
+        for (const path of paths) {
+          const parts = splitJsonPath(path);
+          const value = Obj.getValue(values as any, parts);
+          Obj.setValue(subject, parts, value);
+        }
+      });
+    },
+    [subject],
+  );
+
+  if (!schema) {
+    return <p className={mx(descriptionMessage)}>{t('unable-to-create-preview.message')}</p>;
+  }
+
+  return (
+    <Card.Content>
+      <Form.Root schema={schema} values={subject} autoSave onSave={handleSave}>
+        <Form.Viewport>
+          <Form.Content>
+            <Form.FieldSet />
+          </Form.Content>
+        </Form.Viewport>
+      </Form.Root>
+    </Card.Content>
+  );
+};

package/src/cards/ExpandoCard.tsx

@@ -0,0 +1,76 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import React, { useCallback, useMemo } from 'react';
+
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { Obj } from '@dxos/echo';
+import { type JsonPath, splitJsonPath } from '@dxos/effect';
+import { Card } from '@dxos/react-ui';
+import { Form } from '@dxos/react-ui-form';
+
+const schemaForValue = (value: unknown): Schema.Schema.AnyNoContext | undefined => {
+  switch (typeof value) {
+    case 'string':
+      return Schema.String;
+    case 'number':
+      return Schema.Number;
+    case 'boolean':
+      return Schema.Boolean;
+    default:
+      return undefined;
+  }
+};
+
+/**
+ * Reserved keys: `id`, plus any `~`-prefixed key (ECHO uses `~`-prefixed
+ * string keys to brand entity instances and schemas — KindId,
+ * SchemaKindId, SnapshotKindId, etc. — and the `~` namespace is reserved
+ * for that purpose). They show up in `Object.keys` but aren't user data.
+ */
+const isInternalKey = (key: string) => key === 'id' || key.startsWith('~');
+
+export const ExpandoCard = ({ subject, ignorePaths }: AppSurface.ObjectCardProps) => {
+  const schema = useMemo(() => {
+    const ignored = new Set(ignorePaths ?? []);
+    const fields: Record<string, Schema.Schema.AnyNoContext> = {};
+    for (const key of Object.keys(subject)) {
+      if (isInternalKey(key) || ignored.has(key)) {
+        continue;
+      }
+      const fieldSchema = schemaForValue((subject as any)[key]);
+      if (fieldSchema) {
+        fields[key] = fieldSchema;
+      }
+    }
+    return Schema.Struct(fields);
+  }, [subject, ignorePaths]);
+
+  const handleSave = useCallback(
+    (values: any, { changed }: { changed: Record<string, boolean> }) => {
+      const paths = Object.keys(changed).filter((path) => changed[path]);
+      Obj.update(subject, () => {
+        for (const path of paths) {
+          const value = values[path];
+          const parts = splitJsonPath(path as JsonPath);
+          Obj.setValue(subject, parts, value);
+        }
+      });
+    },
+    [subject],
+  );
+
+  return (
+    <Card.Content>
+      <Form.Root schema={schema} values={subject} autoSave onSave={handleSave}>
+        <Form.Viewport>
+          <Form.Content>
+            <Form.FieldSet />
+          </Form.Content>
+        </Form.Viewport>
+      </Form.Root>
+    </Card.Content>
+  );
+};

package/src/cards/FormCard.tsx

@@ -0,0 +1,48 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useCallback, useMemo } from 'react';
+
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { Obj } from '@dxos/echo';
+import { type JsonPath, splitJsonPath } from '@dxos/effect';
+import { Card, useTranslation } from '@dxos/react-ui';
+import { Form, omitId } from '@dxos/react-ui-form';
+import { type ProjectionModel } from '@dxos/schema';
+import { descriptionMessage, mx } from '@dxos/ui-theme';
+
+import { meta } from '#meta';
+
+export const FormCard = ({ subject, projection }: AppSurface.ObjectCardProps & { projection?: ProjectionModel }) => {
+  const { t } = useTranslation(meta.id);
+  const echoSchema = Obj.getSchema(subject);
+  const schema = useMemo(() => echoSchema && omitId(echoSchema), [echoSchema]);
+
+  const handleSave = useCallback((values: any, { changed }: { changed: Record<string, boolean> }) => {
+    const paths = Object.keys(changed).filter((path) => changed[path]);
+    Obj.update(subject, () => {
+      for (const path of paths) {
+        const value = values[path];
+        const parts = splitJsonPath(path as JsonPath);
+        Obj.setValue(subject, parts, value);
+      }
+    });
+  }, []);
+
+  if (!schema) {
+    return <p className={mx(descriptionMessage)}>{t('unable-to-create-preview.message')}</p>;
+  }
+
+  return (
+    <Card.Content>
+      <Form.Root schema={schema} projection={projection} values={subject} autoSave onSave={handleSave}>
+        <Form.Viewport>
+          <Form.Content>
+            <Form.FieldSet />
+          </Form.Content>
+        </Form.Viewport>
+      </Form.Root>
+    </Card.Content>
+  );
+};

package/src/cards/JsonCard.tsx

@@ -0,0 +1,19 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { Card } from '@dxos/react-ui';
+import { JsonHighlighter } from '@dxos/react-ui-syntax-highlighter';
+
+export const JsonCard = ({ data }: { data: unknown }) => {
+  return (
+    <Card.Content>
+      <span />
+      {/* TODO(wittjosiah): Span whole row. */}
+      <JsonHighlighter data={data} />
+      <span />
+    </Card.Content>
+  );
+};

package/src/cards/OrganizationCard.tsx

@@ -4,31 +4,26 @@
 
 import React from 'react';
 
-import { Card } from '@dxos/react-ui-stack';
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { Card } from '@dxos/react-ui';
 import { type Organization } from '@dxos/types';
 
-import { CardHeader, CardLink } from '../components';
-import { type CardPreviewProps } from '../types';
-
-export const OrganizationCard = ({
-  children,
-  subject,
-  role,
-  activeSpace,
-}: CardPreviewProps<Organization.Organization>) => {
+export const OrganizationCard = ({ subject }: AppSurface.ObjectCardProps<Organization.Organization>) => {
   const { name, image, description, website } = subject;
 
   return (
-    <Card.SurfaceRoot id={subject.id} role={role}>
+    <Card.Content>
       <Card.Poster
         alt={name ?? ''}
         {...(image ? { image } : { icon: 'ph--building-office--regular' })}
         classNames={!image && 'opacity-50'}
       />
-      <CardHeader label={name} subject={subject} activeSpace={activeSpace} />
-      {description && <Card.Text classNames='line-clamp-2'>{description}</Card.Text>}
-      {website && <CardLink label={website} href={website} />}
-      {children}
-    </Card.SurfaceRoot>
+      {description && (
+        <Card.Row>
+          <Card.Text variant='description'>{description}</Card.Text>
+        </Card.Row>
+      )}
+      {website && <Card.Link label={website} href={website} />}
+    </Card.Content>
   );
 };

package/src/cards/PersonCard.tsx

@@ -2,62 +2,64 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { Fragment } from 'react';
+import * as Effect from 'effect/Effect';
+import React, { useCallback } from 'react';
 
-import { Avatar, Icon } from '@dxos/react-ui';
-import { Card, cardHeading, cardText } from '@dxos/react-ui-stack';
-import { mx } from '@dxos/react-ui-theme';
+import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { LayoutOperation, getObjectPathFromObject, getSpacePath } from '@dxos/app-toolkit';
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { Obj } from '@dxos/echo';
+import { runAndForwardErrors } from '@dxos/effect';
+import { Avatar } from '@dxos/react-ui';
+import { Card } from '@dxos/react-ui';
 import { type Person } from '@dxos/types';
 
-import { CardRow, CardSubjectMenu, gridRow } from '../components';
-import { type CardPreviewProps } from '../types';
+export const PersonCard = ({ subject }: AppSurface.ObjectCardProps<Person.Person>) => {
+  const { invoke } = useOperationInvoker();
+  const { image, organization: { target: organization } = {}, emails = [] } = subject;
 
-export const PersonCard = ({ children, role, subject, activeSpace, onSelect }: CardPreviewProps<Person.Person>) => {
-  const { fullName, image, organization: { target: organization } = {}, emails = [] } = subject;
+  const handleOrganizationClick = useCallback(() => {
+    if (!organization) {
+      return;
+    }
+
+    return Effect.gen(function* () {
+      const organizationPath = getObjectPathFromObject(organization);
+      const db = Obj.getDatabase(organization);
+      yield* invoke(LayoutOperation.UpdatePopover, { state: false, anchorId: '' });
+      yield* invoke(LayoutOperation.Open, {
+        subject: [organizationPath],
+        workspace: db ? getSpacePath(db.spaceId) : undefined,
+      });
+    }).pipe(runAndForwardErrors);
+  }, [invoke, organization]);
 
   return (
-    <Card.SurfaceRoot id={subject.id} role={role}>
+    <Card.Content>
       <Avatar.Root>
-        <Card.Text role='group' classNames={mx('grid gap-2 grid-cols-[1fr_min-content]')}>
-          <div role='none' className={mx(gridRow, 'grid-rows-2')}>
-            {activeSpace ? <CardSubjectMenu subject={subject} activeSpace={activeSpace} /> : <div />}
-            <Avatar.Label asChild>
-              <h2 className={mx(cardHeading, 'grow truncate')}>{fullName}</h2>
-            </Avatar.Label>
-          </div>
-          <Avatar.Content
-            imgSrc={image}
-            icon='ph--user--regular'
-            size={16}
-            classNames={['text-subdued', !image && 'opacity-50']}
-            hue='neutral'
-            variant='square'
-          />
-        </Card.Text>
+        {image && (
+          <Card.Row className='py-1'>
+            <Avatar.Content
+              imgSrc={image}
+              icon='ph--user--regular'
+              size={20}
+              classNames={!image && 'opacity-50'}
+              hue='neutral'
+              variant='square'
+            />
+          </Card.Row>
+        )}
+        {organization?.name && (
+          <Card.Action icon='ph--buildings--regular' label={organization.name} onClick={handleOrganizationClick} />
+        )}
+        {emails.map(({ value }) => (
+          <Card.Row key={value} icon='ph--at--regular'>
+            <Card.Text truncate className='text-primary-text'>
+              {value}
+            </Card.Text>
+          </Card.Row>
+        ))}
       </Avatar.Root>
-      {organization?.name && (
-        <CardRow
-          icon='ph--buildings--regular'
-          label={organization.name}
-          onClick={onSelect ? () => onSelect(organization) : undefined}
-        />
-      )}
-      {emails.length > 0 && (
-        <dl className={mx(cardText, gridRow, '[&_dt]:text-subdued [&_dt]:pbs-0.5 [&_dd]:min-is-0')}>
-          {emails.map(({ label, value }) => (
-            <Fragment key={value}>
-              <dt>
-                <span className='sr-only'>{label}</span>
-                <Icon icon='ph--at--regular' size={5} />
-              </dt>
-              <dd key={value} className='col-span-2 break-words'>
-                {value}
-              </dd>
-            </Fragment>
-          ))}
-        </dl>
-      )}
-      {children}
-    </Card.SurfaceRoot>
+    </Card.Content>
   );
 };