@dxos/plugin-script 0.8.4-main.c4373fc → 0.8.4-main.d9fc60f731

package/src/components/NotebookStack/NotebookStack.tsx

@@ -2,111 +2,95 @@
 // Copyright 2025 DXOS.org
 //
 
-import React, { useMemo } from 'react';
+import React from 'react';
 
-import { createDocAccessor } from '@dxos/react-client/echo';
-import { DropdownMenu, Icon, useTranslation } from '@dxos/react-ui';
-import { createDataExtensions } from '@dxos/react-ui-editor';
-import { Stack, StackItem } from '@dxos/react-ui-stack';
+import { DropdownMenu, IconButton, type ThemedClassName, useTranslation } from '@dxos/react-ui';
+import { composable, composableProps } from '@dxos/react-ui';
+import { Stack, StackItem, type StackProps } from '@dxos/react-ui-stack';
+
+import { meta } from '#meta';
+import { type Notebook } from '#types';
 
-import { meta } from '../../meta';
-import { type ComputeGraph } from '../../notebook';
-import { type Notebook } from '../../types';
-import { TypescriptEditor } from '../TypescriptEditor';
 import { type TypescriptEditorProps } from '../TypescriptEditor';
+import { NotebookCell, type NotebookCellProps } from './NotebookCell';
+import { NotebookMenu } from './NotebookMenu';
 
-export type NotebookStackProps = {
-  notebook?: Notebook.Notebook;
-} & Pick<NotebookSectionProps, 'graph' | 'onCellInsert' | 'onCellDelete'> &
-  Pick<TypescriptEditorProps, 'env'>;
+const minSectionHeight = 'min-h-[16rem]';
 
-// TODO(burdon): Option for narrow rail (with compact buttons that align with first button in toolbar).
-export const NotebookStack = ({ notebook, ...props }: NotebookStackProps) => {
-  return (
-    <Stack orientation='vertical' size='contain' rail>
-      {notebook?.cells.map((cell, i) => (
-        <NotebookSection key={i} cell={cell} {...props} />
-      ))}
-    </Stack>
-  );
-};
+export type NotebookStackProps = ThemedClassName<
+  {
+    notebook?: Notebook.Notebook;
+    onRearrange?: StackProps['onRearrange'];
+  } & (Pick<NotebookSectionProps, 'db' | 'graph' | 'promptResults' | 'onCellInsert' | 'onCellDelete'> &
+    Pick<TypescriptEditorProps, 'env'>)
+>;
 
-// TODO(burdon): Support calling named deployed functions (as with sheet).
-// TODO(burdon): Different section types (value, query, expression, prompt).
-// TODO(burdon): Display errors.
-// TODO(burdon): Allow moving cursor between sections (CMD Up/Down).
+// TODO(burdon): Option for narrow rail (with compact buttons that align with first button in toolbar).
+export const NotebookStack = composable<HTMLDivElement, NotebookStackProps>(
+  ({ notebook, onRearrange, db, graph, promptResults, onCellInsert, onCellDelete, env, ...props }, forwardedRef) => {
+    const sectionProps = { db, graph, promptResults, onCellInsert, onCellDelete, env };
+    return (
+      <Stack
+        {...composableProps(props)}
+        orientation='vertical'
+        size='contain'
+        rail
+        onRearrange={onRearrange}
+        ref={forwardedRef}
+      >
+        {notebook?.cells.map((cell, i) => (
+          <NotebookSection key={i} cell={cell} {...sectionProps} />
+        ))}
+      </Stack>
+    );
+  },
+);
 
-type NotebookSectionProps = {
-  cell: Notebook.Cell;
-  graph?: ComputeGraph;
-  onCellInsert?: (after: string | undefined) => void;
-  onCellDelete?: (id: string) => void;
-} & Pick<TypescriptEditorProps, 'env'>;
+type NotebookSectionProps = NotebookCellProps;
 
-const NotebookSection = ({ cell, graph, env, onCellInsert, onCellDelete }: NotebookSectionProps) => {
+const NotebookSection = ({
+  cell,
+  db,
+  env,
+  promptResults,
+  onCellInsert,
+  onCellDelete,
+  ...props
+}: NotebookSectionProps) => {
   const { t } = useTranslation(meta.id);
-  const extensions = useMemo(() => {
-    return cell.script.target
-      ? [createDataExtensions({ id: cell.id, text: createDocAccessor(cell.script.target, ['content']) })]
-      : [];
-  }, [cell.script.target]);
-
-  const name = graph?.expressions.value[cell.id]?.name;
-  const value = graph?.values.value[cell.id];
+  const resizable = cell.type === 'query';
 
   return (
-    <StackItem.Root role='section' item={cell}>
-      <StackItem.Heading classNames='attention-surface'>
-        <StackItem.HeadingStickyContent>
-          <DropdownMenu.Root>
-            <DropdownMenu.Trigger asChild>
-              <StackItem.SigilButton>
-                <Icon icon='ph--list--regular' size={5} />
-              </StackItem.SigilButton>
-            </DropdownMenu.Trigger>
-            <DropdownMenu.Portal>
-              <DropdownMenu.Content>
-                <DropdownMenu.Viewport>
-                  <DropdownMenu.Item onClick={() => onCellInsert?.(cell.id)}>
-                    {t('notebook cell insert label')}
-                  </DropdownMenu.Item>
-                  <DropdownMenu.Item onClick={() => onCellDelete?.(cell.id)}>
-                    {t('notebook cell delete label')}
-                  </DropdownMenu.Item>
-                </DropdownMenu.Viewport>
-                <DropdownMenu.Arrow />
-              </DropdownMenu.Content>
-            </DropdownMenu.Portal>
-          </DropdownMenu.Root>
-        </StackItem.HeadingStickyContent>
+    <StackItem.Root role='section' item={cell} draggable classNames={resizable && minSectionHeight}>
+      <StackItem.Heading classNames='h-full p-1 justify-between dx-attention-surface'>
+        <StackItem.DragHandle asChild>
+          <IconButton variant='ghost' icon='ph--dots-six-vertical--regular' iconOnly label='Drag handle' />
+        </StackItem.DragHandle>
+        <DropdownMenu.Root>
+          <DropdownMenu.Trigger asChild>
+            <IconButton
+              variant='ghost'
+              icon='ph--dots-three--regular'
+              iconOnly
+              label={t('notebook-cell-insert.label')}
+            />
+          </DropdownMenu.Trigger>
+          <NotebookMenu cell={cell} onCellInsert={onCellInsert} onCellDelete={onCellDelete} />
+        </DropdownMenu.Root>
+        {resizable && <StackItem.ResizeHandle />}
       </StackItem.Heading>
 
-      <StackItem.Content>
-        <TypescriptEditor
-          id={cell.id}
-          role='section'
-          initialValue={cell.script.target?.content}
-          extensions={extensions}
-          env={env}
-          options={{
-            placeholder: t('notebook cell placeholder'),
-            highlightActiveLine: false,
-            lineNumbers: false,
-          }}
-          classNames='p-2 pbs-3'
-        />
-
-        {value != null && (
-          <div className='flex p-2 bg-groupSurface border-t border-subduedSeparator text-description font-mono'>
-            {name && (
-              <>
-                <span className='text-successText'>{name}</span>
-                <span className='text-description'>&nbsp;=&nbsp;</span>
-              </>
-            )}
-            <span>{value}</span>
-          </div>
+      {/* TODO(burdon): Move drag preview to outer stack (uniformly). */}
+      <StackItem.DragPreview>
+        {({ item: cell }) => (
+          <StackItem.Content classNames='overflow-visible bg-group-surface border border-subdued-separator'>
+            <NotebookCell db={db} cell={cell} env={env} dragging />
+          </StackItem.Content>
         )}
+      </StackItem.DragPreview>
+
+      <StackItem.Content classNames='overflow-visible'>
+        <NotebookCell db={db} cell={cell} env={env} promptResults={promptResults} {...props} />
       </StackItem.Content>
     </StackItem.Root>
   );

package/src/components/NotebookStack/index.ts

@@ -2,4 +2,5 @@
 // Copyright 2025 DXOS.org
 //
 
+export * from './NotebookMenu';
 export * from './NotebookStack';

package/src/components/QueryEditor/QueryEditor.stories.tsx

@@ -0,0 +1,96 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React, { useCallback, useMemo, useState } from 'react';
+
+import { createDocAccessor } from '@dxos/echo-db';
+import { QuerySandbox } from '@dxos/echo-query';
+import { createObject } from '@dxos/react-client/echo';
+import { Panel, Toolbar, useAsyncEffect } from '@dxos/react-ui';
+import { JsonHighlighter } from '@dxos/react-ui-syntax-highlighter';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
+import { createDataExtensions } from '@dxos/ui-editor';
+import { trim } from '@dxos/util';
+
+import { QueryEditor, type QueryEditorProps } from './QueryEditor';
+
+const SCRIPT = trim`
+  Query.select(Filter.type('org.dxos.type.person'))
+`;
+
+const DefaultStory = (props: QueryEditorProps) => {
+  const object = useMemo(() => createObject({ content: SCRIPT }), []);
+  const [result, setResult] = useState<object | undefined>({});
+  const [sandbox, setSandbox] = useState<QuerySandbox>();
+
+  useAsyncEffect(async () => {
+    const sandbox = new QuerySandbox();
+    await sandbox.open();
+    setSandbox(sandbox);
+
+    return () => {
+      void sandbox.close();
+    };
+  }, []);
+
+  const extensions = useMemo(
+    () => [
+      createDataExtensions({
+        id: object.id,
+        text: createDocAccessor(object, ['content']),
+      }),
+    ],
+    [],
+  );
+
+  const handleRun = useCallback(async () => {
+    try {
+      const result = sandbox?.eval(object.content);
+
+      setResult({
+        timestamp: Date.now(),
+        result,
+      });
+    } catch (err) {
+      setResult({
+        timestamp: Date.now(),
+        error: String(err),
+      });
+    }
+  }, [object, sandbox]);
+
+  return (
+    <Panel.Root>
+      <Panel.Toolbar asChild>
+        <Toolbar.Root>
+          <Toolbar.Button onClick={handleRun}>Run</Toolbar.Button>
+        </Toolbar.Root>
+      </Panel.Toolbar>
+      <Panel.Content>
+        <div className='grid grid-rows-[1fr_min-content] h-full overflow-hidden text-sm'>
+          <QueryEditor {...props} initialValue={object.content} extensions={extensions} />
+          <JsonHighlighter data={result} classNames='shrink-0 p-2 border-y border-subdued-separator' />
+        </div>
+      </Panel.Content>
+    </Panel.Root>
+  );
+};
+
+const meta = {
+  title: 'plugins/plugin-script/components/QueryEditor',
+  component: QueryEditor,
+  render: DefaultStory,
+  decorators: [withTheme(), withLayout({ layout: 'column', classNames: 'w-document-max-width' })],
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {
+  args: {
+    id: 'test',
+  },
+};

package/src/components/QueryEditor/QueryEditor.tsx

@@ -0,0 +1,49 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import React, { useState } from 'react';
+import { ModuleResolutionKind, ScriptTarget } from 'typescript';
+
+import queryApi from '@dxos/echo-query/api.d.ts?raw';
+import { useAsyncEffect } from '@dxos/react-ui';
+
+import { Compiler } from '../../compiler';
+import { TypescriptEditor, type TypescriptEditorProps } from '../TypescriptEditor';
+
+const GLOBALS = `
+  namespace QueryAPI {
+    ${queryApi}
+  }
+
+  declare global {
+    const Query: typeof QueryAPI.Query;
+    const Filter: typeof QueryAPI.Filter;
+    const Order: typeof QueryAPI.Order;
+  }
+
+  export {};
+`;
+
+export type QueryEditorProps = Omit<TypescriptEditorProps, 'env'>;
+
+export const QueryEditor = (props: QueryEditorProps) => {
+  const [compiler, setCompiler] = useState<Compiler>();
+
+  useAsyncEffect(async () => {
+    const compiler = new Compiler({
+      lib: ['ES5'],
+      target: ScriptTarget.ES2022,
+      // Avoid `@typescript/vfs`'s deprecated `node10` default (rejected by TS 6).
+      moduleResolution: ModuleResolutionKind.Bundler,
+    });
+    await compiler.initialize(GLOBALS);
+    setCompiler(compiler);
+  }, []);
+
+  if (!compiler) {
+    return null;
+  }
+
+  return <TypescriptEditor {...props} env={compiler.environment} />;
+};

package/src/components/QueryEditor/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export * from './QueryEditor';

package/src/components/ScriptPluginSettings/ScriptPluginSettings.stories.tsx

@@ -0,0 +1,32 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
+
+import { translations } from '#translations';
+
+import { ScriptPluginSettings } from './ScriptPluginSettings';
+
+const meta = {
+  title: 'plugins/plugin-script/components/ScriptPluginSettings',
+  component: ScriptPluginSettings,
+  tags: ['settings'],
+  decorators: [withTheme(), withLayout({ layout: 'fullscreen' })],
+  parameters: {
+    layout: 'fullscreen',
+    translations,
+  },
+} satisfies Meta<typeof ScriptPluginSettings>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {
+  args: {
+    settings: { editorInputMode: 'default' },
+  },
+};

package/src/components/ScriptPluginSettings/ScriptPluginSettings.tsx

@@ -0,0 +1,42 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import React from 'react';
+
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { Button, useTranslation } from '@dxos/react-ui';
+import { Settings as SettingsForm } from '@dxos/react-ui-form';
+
+import { meta } from '#meta';
+import { Settings } from '#types';
+
+export type ScriptPluginSettingsProps = AppSurface.SettingsArticleProps<
+  Settings.Settings,
+  {
+    onAuthenticate?: () => void;
+  }
+>;
+
+export const ScriptPluginSettings = ({ settings, onSettingsChange, onAuthenticate }: ScriptPluginSettingsProps) => {
+  const { t } = useTranslation(meta.id);
+
+  return (
+    <SettingsForm.Viewport>
+      <SettingsForm.Section title={t('settings.title', { ns: meta.id })}>
+        {/* TODO(wittjosiah): Hide outside of dev environments. */}
+        <SettingsForm.Item title={t('authenticate-action.label')} description={t('authenticate-action.description')}>
+          <Button disabled={!onSettingsChange} onClick={onAuthenticate}>
+            {t('authenticate-button.label')}
+          </Button>
+        </SettingsForm.Item>
+        <SettingsForm.FieldSet
+          readonly={!onSettingsChange}
+          schema={Settings.Settings}
+          values={settings}
+          onValuesChanged={(values) => onSettingsChange?.(() => values)}
+        />
+      </SettingsForm.Section>
+    </SettingsForm.Viewport>
+  );
+};

package/src/components/ScriptPluginSettings/index.ts

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

package/src/components/ScriptToolbar/ScriptToolbar.stories.tsx

@@ -2,45 +2,68 @@
 // Copyright 2023 DXOS.org
 //
 
+import { Atom, Registry } from '@effect-atom/atom-react';
 import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React, { useMemo } from 'react';
 
-import { IntentPlugin } from '@dxos/app-framework';
+import { ProcessManagerPlugin } from '@dxos/app-framework';
 import { withPluginManager } from '@dxos/app-framework/testing';
-import { Obj, Ref } from '@dxos/echo';
-import { ScriptType } from '@dxos/functions';
-import { ClientPlugin } from '@dxos/plugin-client';
-import { withTheme } from '@dxos/react-ui/testing';
-import { DataType } from '@dxos/schema';
+import { Script } from '@dxos/compute';
+import { ClientPlugin } from '@dxos/plugin-client/testing';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
 
-import { translations } from '../../translations';
+import { type ScriptToolbarState, type ScriptToolbarStateStore } from '#hooks';
+import { translations } from '#translations';
 
 import { ScriptToolbar } from './ScriptToolbar';
 
+// Create a mock store for stories.
+const createMockStore = (initialState: ScriptToolbarState = {}): ScriptToolbarStateStore => {
+  const registry = Registry.make();
+  const atom = Atom.make<ScriptToolbarState>(initialState);
+  return {
+    atom,
+    get value() {
+      return registry.get(atom);
+    },
+    update: (updater) => registry.set(atom, updater(registry.get(atom))),
+    set: (key, value) => registry.set(atom, { ...registry.get(atom), [key]: value }),
+  };
+};
+
+const ScriptToolbarStory = () => {
+  const state = useMemo(() => createMockStore(), []);
+  const script = useMemo(
+    () =>
+      Script.make({
+        name: 'test',
+        description: 'test',
+        source: 'test',
+      }),
+    [],
+  );
+  return <ScriptToolbar state={state} script={script} />;
+};
+
 const meta = {
-  title: 'plugins/plugin-script/Toolbar',
-  component: ScriptToolbar,
+  title: 'plugins/plugin-script/components/Toolbar',
+  component: ScriptToolbarStory,
   // TODO(wittjosiah): Try to write story which does not depend on plugin manager.
-  decorators: [withTheme, withPluginManager({ plugins: [IntentPlugin(), ClientPlugin({})] })],
+  decorators: [
+    withTheme(),
+    withLayout({ classNames: 'w-document-max-width' }),
+    withPluginManager({
+      plugins: [ProcessManagerPlugin(), ClientPlugin({})],
+    }),
+  ],
   parameters: {
-    layout: {
-      type: 'centered',
-      className: 'is-prose',
-    },
+    layout: 'centered',
     translations,
   },
-} satisfies Meta<typeof ScriptToolbar>;
+} satisfies Meta<typeof ScriptToolbarStory>;
 
 export default meta;
 
 type Story = StoryObj<typeof meta>;
 
-export const Default: Story = {
-  args: {
-    state: {},
-    script: Obj.make(ScriptType, {
-      name: 'test',
-      description: 'test',
-      source: Ref.make(DataType.makeText('test')),
-    }),
-  },
-};
+export const Default: Story = {};

package/src/components/ScriptToolbar/ScriptToolbar.tsx

@@ -2,64 +2,59 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Rx } from '@effect-rx/rx-react';
+import { Atom } from '@effect-atom/atom-react';
 import React, { useMemo } from 'react';
 
-import { type ScriptType } from '@dxos/functions';
-import { fullyQualifiedId } from '@dxos/react-client/echo';
-import { ElevationProvider, type ThemedClassName, useTranslation } from '@dxos/react-ui';
-import {
-  type ActionGraphProps,
-  MenuProvider,
-  ToolbarMenu,
-  createGapSeparator,
-  rxFromSignal,
-  useMenuActions,
-} from '@dxos/react-ui-menu';
+import { type Script } from '@dxos/compute';
+import { ElevationProvider, useTranslation } from '@dxos/react-ui';
+import { composable, composableProps } from '@dxos/react-ui';
+import { type ActionGraphProps, Menu, MenuRootProps, createGapSeparator, useMenuActions } from '@dxos/react-ui-menu';
 
 import {
   type CreateDeployOptions,
-  type ScriptToolbarState,
+  type ScriptToolbarStateStore,
   createDeploy,
   createFormat,
   createTemplateSelect,
   useDeployDeps,
-} from '../../hooks';
-import { meta } from '../../meta';
+} from '#hooks';
+import { meta } from '#meta';
 
-export type ScriptToolbarProps = ThemedClassName<{
-  role?: string;
-  script: ScriptType;
-  state: ScriptToolbarState;
-}>;
+export type ScriptToolbarProps = Pick<MenuRootProps, 'attendableId'> & {
+  script: Script.Script;
+  state: ScriptToolbarStateStore;
+};
 
-export const ScriptToolbar = ({ script, role, state, classNames }: ScriptToolbarProps) => {
-  const { t } = useTranslation(meta.id);
-  const options = useDeployDeps({ script });
-  const menu = useMemo(() => createToolbarActions({ state, script, t, ...options }), [state, script, options, t]);
-  const actions = useMenuActions(menu);
+export const ScriptToolbar = composable<HTMLDivElement, ScriptToolbarProps>(
+  ({ script, attendableId, role, state, ...props }, forwardedRef) => {
+    const { t } = useTranslation(meta.id);
+    const options = useDeployDeps({ script });
+    const menuCreator = useMemo(
+      () => createToolbarActions({ state, script, t, ...options }),
+      [state, script, options, t],
+    );
+    const menuActions = useMenuActions(menuCreator);
 
-  return (
-    <ElevationProvider elevation={role === 'section' ? 'positioned' : 'base'}>
-      <MenuProvider {...actions} attendableId={fullyQualifiedId(script)}>
-        <ToolbarMenu classNames={classNames} />
-      </MenuProvider>
-    </ElevationProvider>
-  );
-};
+    return (
+      <ElevationProvider elevation={role === 'section' ? 'positioned' : 'base'}>
+        <Menu.Root {...menuActions} attendableId={attendableId}>
+          <Menu.Toolbar {...composableProps(props)} ref={forwardedRef} />
+        </Menu.Root>
+      </ElevationProvider>
+    );
+  },
+);
 
-const createToolbarActions = ({ state, script, ...options }: CreateDeployOptions): Rx.Rx<ActionGraphProps> =>
-  Rx.make((get) =>
-    get(
-      rxFromSignal(() => {
-        const templateSelect = createTemplateSelect(script);
-        const format = createFormat(script);
-        const gap = createGapSeparator();
-        const deploy = createDeploy({ state, script, ...options });
-        return {
-          nodes: [...templateSelect.nodes, ...format.nodes, ...gap.nodes, ...deploy.nodes],
-          edges: [...templateSelect.edges, ...format.edges, ...gap.edges, ...deploy.edges],
-        };
-      }),
-    ),
-  );
+const createToolbarActions = ({ state, script, ...options }: CreateDeployOptions): Atom.Atom<ActionGraphProps> =>
+  Atom.make((get) => {
+    // Subscribe to state changes.
+    get(state.atom);
+    const templateSelect = createTemplateSelect(script);
+    const format = createFormat(script);
+    const gap = createGapSeparator();
+    const deploy = createDeploy({ state, script, ...options });
+    return {
+      nodes: [...templateSelect.nodes, ...format.nodes, ...gap.nodes, ...deploy.nodes],
+      edges: [...templateSelect.edges, ...format.edges, ...gap.edges, ...deploy.edges],
+    };
+  });