@dxos/react-ui-canvas-compute 0.13.0 → 0.14.0

package/src/scene/defs.ts

@@ -1,158 +0,0 @@
-//
-// Copyright 2026 DXOS.org
-//
-
-//
-// The compute shapes as scene-engine node definitions (MIGRATION.md M3): each `ShapeDef` becomes a
-// `NodeDef` whose schema is the shape's with the engine's `z`, whose view renders the shape component
-// unchanged, and whose ports come from the shape's anchors. The palette groups mirror the editor's.
-//
-
-import * as Schema from 'effect/Schema';
-import * as Struct from 'effect/Struct';
-
-import * as TriggerEvent from '@dxos/compute/TriggerEvent';
-import { type ShapeDef } from '@dxos/react-ui-canvas-editor';
-import {
-  type CreateProps,
-  type NodeBase,
-  type NodeDef,
-  type NodeRegistry,
-  type Size,
-  defaultNodeRegistry,
-} from '@dxos/react-ui-canvas/scene';
-
-import {
-  AndShape,
-  AppendShape,
-  AudioShape,
-  BeaconShape,
-  ChatShape,
-  type ComputeShape,
-  ConstantShape,
-  DatabaseShape,
-  FeedShape,
-  FunctionShape,
-  GptRealtimeShape,
-  GptShape,
-  IfElseShape,
-  IfShape,
-  JsonShape,
-  JsonTransformShape,
-  NotShape,
-  OrShape,
-  RandomShape,
-  ReducerShape,
-  ScopeShape,
-  SurfaceShape,
-  SwitchShape,
-  TemplateShape,
-  TextShape,
-  TextToImageShape,
-  ThreadShape,
-  TriggerShapeSchema,
-  andShape,
-  appendShape,
-  audioShape,
-  beaconShape,
-  chatShape,
-  constantShape,
-  databaseShape,
-  feedShape,
-  functionShape,
-  getHeight,
-  gptRealtimeShape,
-  gptShape,
-  ifElseShape,
-  ifShape,
-  jsonShape,
-  jsonTransformShape,
-  notShape,
-  orShape,
-  randomShape,
-  reducerShape,
-  scopeShape,
-  surfaceShape,
-  switchShape,
-  templateShape,
-  textShape,
-  textToImageShape,
-  threadShape,
-  triggerShape,
-} from '../shapes/index.ts';
-import { computeNodeView } from './NodeView.tsx';
-import { anchorsToPorts } from './ports.ts';
-
-/** The shape's schema with the engine's z-order key, so it is a node schema. */
-const withZ = <Fields extends Schema.Struct.Fields>(shape: Schema.Struct<Fields>) =>
-  shape.mapFields(Struct.assign({ z: Schema.String }));
-
-type Entry = { group: string; def: NodeDef };
-
-/** `schema` is the shape's with `z` (`withZ`), applied at the call site so each stays a concrete struct. */
-const entry = <S extends ComputeShape>(
-  group: string,
-  shape: ShapeDef<S>,
-  schema: Schema.Codec<S & { z: string }, unknown, never, never>,
-  defaultSize: Size = shape.createShape({ id: 'default', center: { x: 0, y: 0 } }).size,
-): Entry => ({
-  group,
-  def: {
-    type: shape.type,
-    name: shape.name,
-    icon: shape.icon,
-    group,
-    schema,
-    component: computeNodeView(schema, shape.component),
-    create: ({ id, z, center, size }: CreateProps): NodeBase => ({ ...shape.createShape({ id, center }), z, size }),
-    defaultSize,
-    ports: (node) => (isShapeOf(schema, node) ? anchorsToPorts(shape.getAnchors?.(node) ?? {}, node.size) : []),
-    resizable: shape.resizable,
-    openable: shape.openable,
-  },
-});
-
-const isShapeOf = <S extends ComputeShape>(
-  schema: Schema.Codec<S, unknown, never, never>,
-  node: NodeBase,
-): node is NodeBase & S => Schema.is(schema)(node);
-
-/** Palette order, as the editor's `computeShapes`. */
-const entries: Entry[] = [
-  entry('Inputs', constantShape, withZ(ConstantShape)),
-  entry('Inputs', templateShape, withZ(TemplateShape)),
-  entry('Inputs', chatShape, withZ(ChatShape)),
-  entry('Inputs', switchShape, withZ(SwitchShape)),
-  entry('Inputs', audioShape, withZ(AudioShape)),
-  // A trigger's `createShape` makes an ECHO object, so its default size is stated rather than sampled.
-  entry('Inputs', triggerShape, withZ(TriggerShapeSchema), { width: 192, height: getHeight(TriggerEvent.EmailEvent) }),
-  entry('Inputs', randomShape, withZ(RandomShape)),
-  entry('Transform', gptShape, withZ(GptShape)),
-  entry('Transform', gptRealtimeShape, withZ(GptRealtimeShape)),
-  entry('Transform', functionShape, withZ(FunctionShape)),
-  entry('Transform', databaseShape, withZ(DatabaseShape)),
-  entry('Transform', textToImageShape, withZ(TextToImageShape)),
-  entry('Transform', appendShape, withZ(AppendShape)),
-  entry('Operations', ifShape, withZ(IfShape)),
-  entry('Operations', ifElseShape, withZ(IfElseShape)),
-  entry('Operations', andShape, withZ(AndShape)),
-  entry('Operations', orShape, withZ(OrShape)),
-  entry('Operations', notShape, withZ(NotShape)),
-  entry('Operations', reducerShape, withZ(ReducerShape)),
-  entry('Operations', jsonTransformShape, withZ(JsonTransformShape)),
-  entry('Outputs', jsonShape, withZ(JsonShape)),
-  entry('Outputs', feedShape, withZ(FeedShape)),
-  entry('Outputs', threadShape, withZ(ThreadShape)),
-  entry('Outputs', textShape, withZ(TextShape)),
-  entry('Outputs', surfaceShape, withZ(SurfaceShape)),
-  entry('Outputs', beaconShape, withZ(BeaconShape)),
-  entry('Outputs', scopeShape, withZ(ScopeShape)),
-];
-
-export const computeNodeDefs: NodeDef[] = entries.map(({ def }) => def);
-
-/** The compute types plus the engine's note under a `Misc` group. */
-export const computeNodeRegistry: NodeRegistry = {
-  ...Object.fromEntries(computeNodeDefs.map((def) => [def.type, def])),
-  note: { ...defaultNodeRegistry.note, group: 'Misc' },
-};

package/src/scene/ports.ts

@@ -1,30 +0,0 @@
-//
-// Copyright 2026 DXOS.org
-//
-
-//
-// Anchors as the scene engine's ports (MIGRATION.md §2.2): an anchor is a point relative to the shape's
-// centre, a port is a side and an offset along it; the anchor id says which way a link may run.
-//
-
-import { type Anchor } from '@dxos/react-ui-canvas-editor';
-import { type Port, type Size } from '@dxos/react-ui-canvas/scene';
-
-import { parseAnchorId } from '../shapes/defs.ts';
-
-/** The ports of a shape from its anchors; a port's direction comes from the `input.` / `output.` prefix. */
-export const anchorsToPorts = (anchors: Record<string, Anchor>, size: Size): Port[] =>
-  Object.values(anchors).map(({ id, pos }) => {
-    const [kind] = parseAnchorId(id);
-    const half = { x: size.width / 2, y: size.height / 2 };
-    // The anchor sits on whichever edge it is nearer to; ties go to the vertical edges (the input / output sides).
-    const vertical = Math.abs(Math.abs(pos.x) - half.x) <= Math.abs(Math.abs(pos.y) - half.y);
-    const side = vertical ? (pos.x < 0 ? 'w' : 'e') : pos.y < 0 ? 'n' : 's';
-    const along = vertical ? (pos.y + half.y) / size.height : (pos.x + half.x) / size.width;
-    return {
-      id,
-      side,
-      offset: Math.min(Math.max(along, 0), 1),
-      ...(kind === 'input' ? { accepts: 'in' as const } : kind === 'output' ? { accepts: 'out' as const } : {}),
-    };
-  });

package/src/shapes/common/function-anchors.ts

@@ -1,44 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import type * as Schema from 'effect/Schema';
-
-import { VoidInput, VoidOutput } from '@dxos/conductor';
-import * as SchemaAST from '@dxos/effect/SchemaAST';
-import { type Polygon } from '@dxos/react-ui-canvas-editor';
-import { createAnchors, rowHeight } from '@dxos/react-ui-canvas-editor';
-import { DEFAULT_GRID } from '@dxos/react-ui-canvas/scene';
-
-import { footerHeight, headerHeight } from '../common/index.ts';
-import { createAnchorId } from '../defs.ts';
-
-// Kept out of `FunctionBody.tsx`: react-refresh only fast-refreshes a module whose
-// exports are all components, so values exported beside them force a full page reload on every edit.
-
-/** Vertical padding inside the function body; the height maths below depends on it. */
-export const bodyPadding = 8;
-
-/**
- * A function shape's height: the chrome plus a body grown to a whole number of grid cells. One row per
- * input is a floor on the body rather than its height, so the box lands on the grid whatever its schema
- * declares — the rows used to set it exactly, and `rowHeight` divides into no grid cell.
- */
-export const getHeight = (input: Schema.Schema<any>, unit = DEFAULT_GRID) => {
-  const properties = SchemaAST.getPropertySignatures(input.ast);
-  const minBody = bodyPadding * 2 + properties.length * rowHeight + 2; // Incl. borders.
-  return headerHeight + footerHeight + Math.ceil(minBody / unit) * unit;
-};
-
-export const createFunctionAnchors = (
-  shape: Polygon,
-  input: Schema.Schema<any> = VoidInput,
-  output: Schema.Schema<any> = VoidOutput,
-) => {
-  // TODO(burdon): Set type.
-  const inputs = SchemaAST.getPropertySignatures(input.ast).map(({ name }) => createAnchorId('input', name.toString()));
-  const outputs = SchemaAST.getPropertySignatures(output.ast).map(({ name }) =>
-    createAnchorId('output', name.toString()),
-  );
-  return createAnchors({ shape, inputs, outputs, center: { x: 0, y: (headerHeight - footerHeight) / 2 + 1 } });
-};