@dxos/plugin-space 0.8.4-main.e8ec1fe → 0.8.4-main.effb148878

package/src/components/SpaceSettings/SpaceSettingsContainer.stories.tsx

@@ -1,46 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { type Meta, type StoryObj } from '@storybook/react-vite';
-import React from 'react';
-
-import { IntentPlugin } from '@dxos/app-framework';
-import { withPluginManager } from '@dxos/app-framework/testing';
-import { useClientProvider, withClientProvider } from '@dxos/react-client/testing';
-import { withTheme } from '@dxos/react-ui/testing';
-
-import { translations } from '../../translations';
-
-import { SpaceSettingsContainer, type SpaceSettingsContainerProps } from './SpaceSettingsContainer';
-
-const Story = (props: Partial<SpaceSettingsContainerProps>) => {
-  const { space } = useClientProvider();
-  return (
-    <div role='none' className='p-2 border border-primary-500 rounded'>
-      <SpaceSettingsContainer {...props} space={space!} />
-    </div>
-  );
-};
-
-const meta = {
-  title: 'plugins/plugin-space/SpaceSettingsContainer',
-  component: SpaceSettingsContainer,
-  render: Story,
-  decorators: [
-    withTheme,
-    withClientProvider({ createIdentity: true, createSpace: true }),
-    // TODO(wittjosiah): Try to write story which does not depend on plugin manager.
-    withPluginManager({ plugins: [IntentPlugin()] }),
-  ],
-  parameters: {
-    translations,
-    layout: 'centered',
-  },
-} satisfies Meta<typeof SpaceSettingsContainer>;
-
-export default meta;
-
-type Story = StoryObj<typeof meta>;
-
-export const Default: StoryObj<typeof SpaceSettingsContainer> = {};

package/src/components/SpaceSettings/SpaceSettingsContainer.tsx

@@ -1,205 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import * as Function from 'effect/Function';
-import * as Schema from 'effect/Schema';
-import React, { type ChangeEvent, useCallback, useMemo, useState } from 'react';
-
-import { LayoutAction, chain, createIntent } from '@dxos/app-framework';
-import { useIntentDispatcher } from '@dxos/app-framework/react';
-import { log } from '@dxos/log';
-import { EdgeReplicationSetting } from '@dxos/protocols/proto/dxos/echo/metadata';
-import { useClient } from '@dxos/react-client';
-import { type Space, SpaceState } from '@dxos/react-client/echo';
-import { Button, Input, useFileDownload, useMulticastObservable, useTranslation } from '@dxos/react-ui';
-import {
-  ControlItem,
-  ControlItemInput,
-  ControlPage,
-  ControlSection,
-  Form,
-  type InputComponent,
-} from '@dxos/react-ui-form';
-import { HuePicker, IconPicker } from '@dxos/react-ui-pickers';
-import { StackItem } from '@dxos/react-ui-stack';
-
-import { meta } from '../../meta';
-import { SpaceAction, SpaceForm } from '../../types';
-
-const FormSchema = SpaceForm.pipe(
-  Schema.extend(
-    Schema.Struct({
-      archived: Schema.Boolean.annotations({ title: 'Archive Space' }),
-    }),
-  ),
-);
-
-export type SpaceSettingsContainerProps = {
-  space: Space;
-};
-
-// TODO(wittjosiah): Handle space migrations here?
-export const SpaceSettingsContainer = ({ space }: SpaceSettingsContainerProps) => {
-  const { t } = useTranslation(meta.id);
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
-  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 handleSave = useCallback(
-    (properties: Schema.Schema.Type<typeof FormSchema>) => {
-      void toggleEdgeReplication(properties.edgeReplication);
-      if (properties.name !== space.properties.name) {
-        space.properties.name = properties.name;
-      }
-      if (properties.icon !== space.properties.icon) {
-        space.properties.icon = properties.icon;
-      }
-      if (properties.hue !== space.properties.hue) {
-        space.properties.hue = properties.hue;
-      }
-      if (properties.archived && !archived) {
-        void dispatch(
-          Function.pipe(
-            createIntent(SpaceAction.Close, { space }),
-            chain(LayoutAction.SwitchWorkspace, {
-              part: 'workspace',
-              subject: client.spaces.default.id,
-            }),
-          ),
-        );
-      } else if (!properties.archived && archived) {
-        void dispatch(createIntent(SpaceAction.Open, { space }));
-      }
-    },
-    [space, toggleEdgeReplication, archived],
-  );
-
-  const values = 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 customElements: Partial<Record<string, InputComponent>> = useMemo(
-    () => ({
-      name: ({ type, label, getValue, onValueChange }) => {
-        const handleChange = useCallback(
-          ({ target: { value } }: ChangeEvent<HTMLInputElement>) => onValueChange(type, value),
-          [onValueChange, type],
-        );
-        return (
-          <ControlItemInput title={label} description={t('display name description')}>
-            <Input.TextInput
-              value={getValue()}
-              onChange={handleChange}
-              placeholder={t('display name input placeholder')}
-              classNames='min-is-64'
-            />
-          </ControlItemInput>
-        );
-      },
-      icon: ({ type, label, getValue, onValueChange }) => {
-        const handleChange = useCallback((icon: string) => onValueChange(type, icon), [onValueChange, type]);
-        const handleReset = useCallback(() => onValueChange(type, undefined), [onValueChange, type]);
-        return (
-          <ControlItem title={label} description={t('icon description')}>
-            <IconPicker
-              value={getValue()}
-              onChange={handleChange}
-              onReset={handleReset}
-              classNames='justify-self-end'
-            />
-          </ControlItem>
-        );
-      },
-      hue: ({ type, label, getValue, onValueChange }) => {
-        const handleChange = useCallback((nextHue: string) => onValueChange(type, nextHue), [onValueChange, type]);
-        const handleReset = useCallback(() => onValueChange(type, undefined), [onValueChange, type]);
-        return (
-          <ControlItem title={label} description={t('hue description')}>
-            <HuePicker value={getValue()} onChange={handleChange} onReset={handleReset} classNames='justify-self-end' />
-          </ControlItem>
-        );
-      },
-      edgeReplication: ({ type, label, getValue, onValueChange }) => {
-        const handleChange = useCallback((checked: boolean) => onValueChange(type, checked), [onValueChange, type]);
-        return (
-          <ControlItemInput title={label} description={t('edge replication description')}>
-            <Input.Switch checked={getValue()} onCheckedChange={handleChange} classNames='justify-self-end' />
-          </ControlItemInput>
-        );
-      },
-      archived: ({ type, label, getValue, onValueChange }) => {
-        const handleChange = useCallback(() => onValueChange(type, !getValue()), [onValueChange, type, getValue]);
-        return (
-          <ControlItemInput title={label} description={t('archive space description')}>
-            <Button
-              disabled={space === client.spaces.default}
-              variant={getValue() ? 'default' : 'destructive'}
-              onClick={handleChange}
-            >
-              {getValue() ? t('unarchive space label') : t('archive space label')}
-            </Button>
-          </ControlItemInput>
-        );
-      },
-    }),
-    [t, space],
-  );
-
-  const download = useFileDownload();
-  const handleBackup = useCallback(async () => {
-    const archive = await space.internal.export();
-    download(new Blob([archive.contents as Uint8Array<ArrayBuffer>]), archive.filename);
-  }, [space, download]);
-
-  return (
-    <StackItem.Content scrollable>
-      <ControlPage>
-        <ControlSection
-          title={t('space properties settings verbose label', { ns: meta.id })}
-          description={t('space properties settings description', {
-            ns: meta.id,
-          })}
-        >
-          <Form
-            schema={FormSchema}
-            values={values}
-            autoSave
-            onSave={handleSave}
-            Custom={customElements}
-            outerSpacing={false}
-            classNames='container-max-width grid grid-cols-1 md:grid-cols-[1fr_min-content]'
-          />
-        </ControlSection>
-        <ControlItemInput
-          title={t('backup space label', { ns: meta.id })}
-          description={t('backup space description', { ns: meta.id })}
-        >
-          <Button onClick={handleBackup}>{t('download backup')}</Button>
-        </ControlItemInput>
-      </ControlPage>
-    </StackItem.Content>
-  );
-};

package/src/components/ViewEditor.tsx

@@ -1,92 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-import React, { useCallback, useState } from 'react';
-
-import { createIntent } from '@dxos/app-framework';
-import { useIntentDispatcher } from '@dxos/app-framework/react';
-import { DXN, Filter, Obj, Query, type QueryAST, Tag, Type } from '@dxos/echo';
-import { useClient } from '@dxos/react-client';
-import { getSpace, useQuery } from '@dxos/react-client/echo';
-import { useAsyncEffect } from '@dxos/react-ui';
-import { ViewEditor as NaturalViewEditor } from '@dxos/react-ui-form';
-import { View } from '@dxos/schema';
-
-import { resolveSchemaWithClientAndSpace } from '../helpers';
-import { useTypeOptions } from '../hooks';
-import { SpaceAction } from '../types';
-
-export type ViewEditorProps = { view: View.View };
-
-export const ViewEditor = ({ view }: ViewEditorProps) => {
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
-  const client = useClient();
-  const space = getSpace(view);
-  const [schema, setSchema] = useState<Schema.Schema.AnyNoContext>(() => Schema.Struct({}));
-  const tags = useQuery(space, Filter.type(Tag.Tag));
-  const types = useTypeOptions({ space, annotation: ['dynamic', 'limited-static', 'object-form'] });
-
-  useAsyncEffect(async () => {
-    if (!view?.query || !space) {
-      return;
-    }
-
-    const foundSchema = await resolveSchemaWithClientAndSpace(client, space, view.query.ast);
-    if (foundSchema && foundSchema !== schema) {
-      setSchema(() => foundSchema);
-    }
-  }, [client, space, view, schema]);
-
-  const handleQueryChanged = useCallback(
-    async (newQuery: QueryAST.Query, target?: string) => {
-      if (!view || !space) {
-        return;
-      }
-
-      const queue = target && DXN.tryParse(target) ? target : undefined;
-      const query = queue ? Query.fromAst(newQuery).options({ queues: [queue] }) : Query.fromAst(newQuery);
-      view.query.ast = query.ast;
-      const newSchema = await resolveSchemaWithClientAndSpace(client, space, query.ast);
-      if (!newSchema) {
-        return;
-      }
-
-      const newView = View.make({
-        query,
-        jsonSchema: Type.toJsonSchema(newSchema),
-        presentation: Obj.make(Type.Expando, {}),
-      });
-      view.projection = Obj.getSnapshot(newView).projection;
-
-      setSchema(() => newSchema);
-    },
-    [view, schema],
-  );
-
-  const handleDelete = useCallback(
-    (fieldId: string) => {
-      void dispatch(createIntent(SpaceAction.DeleteField, { view, fieldId }));
-    },
-    [dispatch, view],
-  );
-
-  if (!space || !schema) {
-    return null;
-  }
-
-  return (
-    <NaturalViewEditor
-      registry={space.db.schemaRegistry}
-      schema={schema}
-      view={view}
-      mode='query'
-      outerSpacing={false}
-      tags={tags}
-      types={types}
-      onQueryChanged={handleQueryChanged}
-      onDelete={Type.isMutable(schema) ? handleDelete : undefined}
-    />
-  );
-};

package/src/events.ts

@@ -1,15 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Events, defineEvent } from '@dxos/app-framework';
-
-import { meta } from './meta';
-
-export namespace SpaceEvents {
-  export const StateReady = Events.createStateEvent(`${meta.id}/event/state-ready`);
-  export const SetupSettingsPanel = defineEvent(`${meta.id}/event/setup-settings-panel`);
-  export const DefaultSpaceReady = defineEvent(`${meta.id}/event/default-space-ready`);
-  export const SpaceCreated = defineEvent(`${meta.id}/event/space-created`);
-  export const SchemaAdded = defineEvent(`${meta.id}/event/schema-added`);
-}

package/src/helpers/query.test.ts

@@ -1,24 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { describe, expect, it } from 'vitest';
-
-import { evalQuery } from './query';
-
-describe('evalQuery', () => {
-  it('should evaluate a query string', () => {
-    const query = evalQuery('Query.select(Filter.type(Person.Person))');
-    expect(query.ast).toMatchInlineSnapshot(`
-      {
-        "filter": {
-          "id": undefined,
-          "props": {},
-          "type": "object",
-          "typename": "dxn:type:dxos.org/type/Person:0.1.0",
-        },
-        "type": "select",
-      }
-    `);
-  });
-});

package/src/helpers/query.ts

@@ -1,158 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Array from 'effect/Array';
-import * as Effect from 'effect/Effect';
-import * as EffectFunction from 'effect/Function';
-import * as Match from 'effect/Match';
-import * as Option from 'effect/Option';
-import type * as Schema from 'effect/Schema';
-import * as SchemaAST from 'effect/SchemaAST';
-
-import { DXN, Filter, Query, type QueryAST } from '@dxos/echo';
-import {
-  ReferenceAnnotationId,
-  type ReferenceAnnotationValue,
-  getTypeAnnotation,
-  unwrapOptional,
-} from '@dxos/echo/internal';
-import { log } from '@dxos/log';
-import { type Client } from '@dxos/react-client';
-import { type Space } from '@dxos/react-client/echo';
-import { Person } from '@dxos/types';
-
-// TODO(wittjosiah): Factor out and add tests.
-// TODO(wittjosiah): Support arbitrary type imports.
-export const evalQuery = (queryString: string): Query.Any => {
-  const globals = { Query, Filter, Person };
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-implied-eval
-    return new Function(...Object.keys(globals), `return ${queryString}`)(...Object.values(globals));
-  } catch (err) {
-    log.catch(err);
-    return Query.select(Filter.nothing());
-  }
-};
-
-export const resolveSchemaWithClientAndSpace = (client: Client, space: Space, query: QueryAST.Query) => {
-  const resolve = Effect.fn(function* (dxn: string) {
-    const typename = DXN.parse(dxn).asTypeDXN()?.type;
-    if (!typename) {
-      return Option.none();
-    }
-
-    const staticSchema = client.graph.schemaRegistry.getSchema(typename);
-    if (staticSchema) {
-      return Option.some(staticSchema);
-    }
-
-    const query = space.db.schemaRegistry.query({ typename });
-    const schemas = yield* Effect.promise(() => query.run());
-    return Array.head(schemas).pipe(Option.map((schema) => schema.snapshot));
-  });
-
-  return resolveSchema(query, resolve).pipe(
-    Effect.map((schema) => Option.getOrUndefined(schema)),
-    Effect.runPromise,
-  );
-};
-
-const resolveSchema = (
-  query: QueryAST.Query,
-  resolve: (dxn: string) => Effect.Effect<Option.Option<Schema.Schema.AnyNoContext>>,
-): Effect.Effect<Option.Option<Schema.Schema.AnyNoContext>> => {
-  return Match.value(query).pipe(
-    Match.withReturnType<Effect.Effect<Option.Option<Schema.Schema.AnyNoContext>>>(),
-    // TODO(wittjosiah): Reconcile with filter match?
-    Match.when({ type: 'select' }, ({ filter }) =>
-      typenameFromFilter(filter).pipe(
-        Option.map((typename) => resolve(typename)),
-        Option.getOrElse(() => Effect.succeed(Option.none<Schema.Schema.AnyNoContext>())),
-      ),
-    ),
-    Match.when({ type: 'filter' }, ({ filter }) =>
-      typenameFromFilter(filter).pipe(
-        Option.map((typename) => resolve(typename)),
-        Option.getOrElse(() => Effect.succeed(Option.none<Schema.Schema.AnyNoContext>())),
-      ),
-    ),
-    Match.when({ type: 'reference-traversal' }, ({ anchor, property }) =>
-      resolveSchema(anchor, resolve).pipe(
-        Effect.map((base) =>
-          base.pipe(
-            Option.map((schema) => SchemaAST.getPropertySignatures(schema.ast)),
-            Option.flatMap((properties) => Array.findFirst(properties, (p) => p.name === property)),
-            Option.flatMap((property) =>
-              SchemaAST.getAnnotation<ReferenceAnnotationValue>(ReferenceAnnotationId)(unwrapOptional(property)),
-            ),
-            Option.map((annotation) => annotation.typename),
-          ),
-        ),
-        Effect.flatMap(
-          Option.match({
-            onNone: () => Effect.succeed(Option.none()),
-            onSome: (typename) => resolve(DXN.fromTypename(typename).toString()),
-          }),
-        ),
-      ),
-    ),
-    Match.when({ type: 'relation', filter: Match.defined }, ({ filter }) =>
-      typenameFromFilter(filter).pipe(
-        Option.map((typename) => resolve(typename)),
-        Option.getOrElse(() => Effect.succeed(Option.none<Schema.Schema.AnyNoContext>())),
-      ),
-    ),
-    Match.when({ type: 'relation-traversal' }, ({ anchor, direction }) =>
-      resolveSchema(anchor, resolve).pipe(
-        Effect.map((base) =>
-          base.pipe(
-            Option.map((schema) => getTypeAnnotation(schema)),
-            Option.flatMap((annotation) =>
-              Option.fromNullable(direction === 'source' ? annotation?.sourceSchema : annotation?.targetSchema),
-            ),
-          ),
-        ),
-        Effect.flatMap(
-          Option.match({
-            onNone: () => Effect.succeed(Option.none()),
-            onSome: (typename) => resolve(typename),
-          }),
-        ),
-      ),
-    ),
-    Match.when({ type: 'options' }, ({ query }) => resolveSchema(query, resolve)),
-    Match.orElse((_q) => {
-      // TODO(wittjosiah): Implement other cases.
-      return Effect.succeed(Option.none());
-    }),
-  );
-};
-
-const typenameFromFilter = (filter: QueryAST.Filter): Option.Option<string> =>
-  Match.value(filter).pipe(
-    Match.withReturnType<Option.Option<string>>(),
-    Match.when({ type: 'object' }, ({ typename }) => Option.fromNullable(typename)),
-    Match.when({ type: 'and' }, ({ filters }) =>
-      EffectFunction.pipe(filters, Array.map(typenameFromFilter), Array.findFirst(Option.isSome), Option.flatten),
-    ),
-    Match.when({ type: 'or' }, ({ filters }) =>
-      EffectFunction.pipe(filters, Array.map(typenameFromFilter), Array.findFirst(Option.isSome), Option.flatten),
-    ),
-    Match.orElse(() => Option.none()),
-  );
-
-// TODO(wittjosiah): Currently assumes options is at the top-level of the ast.
-export const getQueryTarget = (query: QueryAST.Query, space?: Space) => {
-  return Match.value(query).pipe(
-    Match.when({ type: 'options' }, ({ options }) => {
-      return Option.fromNullable(options.queues).pipe(
-        Option.flatMap((queues) => Array.head(queues)),
-        Option.flatMap((queueDxn) => Option.fromNullable(DXN.tryParse(queueDxn))),
-        Option.flatMap((queueDxn) => Option.fromNullable(space?.queues.get(queueDxn))),
-        Option.getOrElse(() => space),
-      );
-    }),
-    Match.orElse(() => space),
-  );
-};

package/src/hooks/useActiveSpace.ts

@@ -1,21 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Capabilities, type PluginContext } from '@dxos/app-framework';
-import { useLayout } from '@dxos/app-framework/react';
-import { ClientCapabilities } from '@dxos/plugin-client';
-import { parseId, useSpace } from '@dxos/react-client/echo';
-
-export const getActiveSpace = (context: PluginContext) => {
-  const client = context.getCapability(ClientCapabilities.Client);
-  const layout = context.getCapability(Capabilities.Layout);
-  const { spaceId } = parseId(layout.workspace);
-  return spaceId ? client.spaces.get(spaceId) : undefined;
-};
-
-export const useActiveSpace = () => {
-  const layout = useLayout();
-  const { spaceId } = parseId(layout.workspace);
-  return useSpace(spaceId);
-};

package/src/hooks/useTypeOptions.ts

@@ -1,59 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { useMemo } from 'react';
-
-import { useCapabilities } from '@dxos/app-framework/react';
-import { Type } from '@dxos/echo';
-import { ClientCapabilities } from '@dxos/plugin-client';
-import { useClient } from '@dxos/react-client';
-import { type Space } from '@dxos/react-client/echo';
-import { useTranslation } from '@dxos/react-ui';
-import { Collection, type TypenameAnnotation, getTypenames } from '@dxos/schema';
-
-import { SpaceCapabilities } from '../capabilities';
-
-const OMIT = [Collection.Collection.typename, Type.getTypename(Collection.QueryCollection)];
-
-export const useTypeOptions = ({ space, annotation }: { space?: Space; annotation: TypenameAnnotation[] }) => {
-  const { t } = useTranslation();
-  const client = useClient();
-
-  const schemaWhitelists = useCapabilities(ClientCapabilities.SchemaWhiteList);
-  const whitelistedTypenames = useMemo(
-    () => new Set(schemaWhitelists.flatMap((typeArray) => typeArray.map((type) => Type.getTypename(type)))),
-    [schemaWhitelists],
-  );
-
-  const objectForms = useCapabilities(SpaceCapabilities.ObjectForm);
-  const objectFormTypenames = useMemo(
-    () =>
-      new Set(
-        objectForms
-          .map((form) => Type.getTypename(form.objectSchema))
-          // TODO(wittjosiah): Remove.
-          .filter((typename) => !OMIT.includes(typename) && !typename.endsWith('View')),
-      ),
-    [objectForms],
-  );
-
-  const typenames = getTypenames({
-    annotation,
-    whitelistedTypenames,
-    objectFormTypenames,
-    space,
-    client,
-  });
-
-  return useMemo(
-    () =>
-      typenames
-        .map((typename) => ({
-          value: typename,
-          label: t('typename label', { ns: typename, defaultValue: typename }),
-        }))
-        .toSorted((a, b) => a.label.localeCompare(b.label)),
-    [t, typenames],
-  );
-};