feuerwerk/src/editor/inspector/edgeSection.ts

import { NameTransitionCommand } from '../../core/commands/graphCommands';
import { SetSendCommand } from '../../core/commands/songCommands';
import {
  type EdgeSend,
  findNode,
  type Graph,
  type GraphEdge,
  isStateNode,
  resolveDef,
  stateName,
} from '../../core/graph';
import { routedKind, sendsTapped } from '../../core/music/projectRouting';
import { SEND_TAPS, sendOf } from '../../core/music/routing';
import { TRACK_MAX_DB, TRACK_MIN_DB } from '../../core/music/song';
import type { PropertyDef } from '../../core/properties/PropertySchema';
import { graphLookup } from '../../core/model/graphLookup';
import { findGraphAsset, type Project } from '../../core/model/Project';
import { textOf } from '../../core/model/Properties';
import { Label } from '../../ui';
import { linkNoun } from '../actions';
import { createFieldRow, labelledRow } from './fieldFactory';
import { addNote, addTitle, type InspectorHost } from './host';

const NAME_KEY = 'transition-name';
const SEND_VOLUME: PropertyDef = {
  key: 'send-volume',
  label: 'Volume',
  kind: 'number',
  default: 0,
  min: TRACK_MIN_DB,
  max: TRACK_MAX_DB,
  step: 0.5,
};
const SEND_TAP: PropertyDef = {
  key: 'send-tap',
  label: 'Mode',
  kind: 'enum',
  default: 'post',
  options: SEND_TAPS.map((tap) => ({ value: tap.value, label: tap.label })),
};

/** What the panel says about one link: the two ends by the names drawn on them. */
export interface EdgeDescription {
  transition: boolean;
  from: string;
  output: string;
  to: string;
  input: string;
  /** What flows through it, as the output names it. */
  type: string;
  name: string;
  /** On a link of a song's routing (#350) or of the master routing (#351): what it sends; null on any other link. */
  send: EdgeSend | null;
  /** Whether the link may take the sound anywhere but after the level: not out of a sound, an instrument or a pattern. */
  tapped: boolean;
}

/** Null when the link is gone. An end whose node or port is gone reads `?`. */
export function describeEdge(project: Project, assetId: string, edgeId: string): EdgeDescription | null {
  const holder = findGraphAsset(project, assetId);
  const graph = holder?.graph;
  const edge = graph?.edges.find((e) => e.id === edgeId);
  if (!holder || !graph || !edge) return null;
  const lookup = graphLookup(project);
  const end = (side: GraphEdge['from'], ports: 'inputs' | 'outputs') => {
    const node = findNode(graph, side.node);
    const def = node && resolveDef(node, graph, lookup);
    const port = def?.[ports].find((p) => p.key === side.port);
    return {
      state: node !== undefined && isStateNode(node),
      node: node ? (isStateNode(node) ? stateName(node) : (def?.label ?? node.type)) : '?',
      port: port ? port.label || port.key : '?',
      type: port?.type ?? '?',
    };
  };
  const from = end(edge.from, 'outputs');
  const to = end(edge.to, 'inputs');
  return {
    transition: from.state && to.state,
    from: from.node,
    output: from.port,
    to: to.node,
    input: to.port,
    type: from.type,
    name: edge.label ?? '',
    send: holder.type === 'song' || holder.type === 'routing' ? sendOf(edge) : null,
    tapped: holder.type === 'song' || sendsTapped(fromKind(graph, edge)),
  };
}

/** The asset type a link of the master routing (#351) comes out of; `''` for anything else. */
function fromKind(graph: Graph, edge: GraphEdge): string {
  const node = findNode(graph, edge.from.node);
  return node ? routedKind(node) : '';
}

/** Structure of a link selection: how many, and for one of them what it joins. */
export function edgeSignature(
  project: Project,
  assetId: string,
  edgeId: string,
  edgeIds: readonly string[],
): string {
  if (edgeIds.length > 1) return `many:${edgeIds.length}`;
  const d = describeEdge(project, assetId, edgeId);
  return d ? [d.transition, d.from, d.output, d.to, d.input, d.type].join('|') : 'missing';
}

/**
 * One link: where it comes from and goes to. Several: how many. Hiding and deleting live in the
 * right-click menu of the line, not here.
 */
export function buildEdgeSection(
  host: InspectorHost,
  assetId: string,
  edgeId: string,
  edgeIds: readonly string[],
): void {
  const noun = linkNoun(host.state, assetId);
  if (edgeIds.length > 1) {
    addTitle(host, `${edgeIds.length} ${noun.toUpperCase()}S`);
    addNote(host, 'Delete removes all of them in one step.');
    return;
  }
  const d = describeEdge(host.state.project, assetId, edgeId);
  if (!d) return;
  addTitle(host, noun.toUpperCase());
  const fact = (label: string, value: string) => {
    const { row } = labelledRow(label);
    row.add(new Label(value), 1);
    host.body.add(row);
  };
  fact('From', d.from);
  if (!d.transition) fact('Output', d.output);
  fact('To', d.to);
  if (d.transition) {
    const name = createFieldRow(host, { key: NAME_KEY, label: 'Name', kind: 'text', default: '' }, d.name, {
      onInput: () => {},
      onChange: (next) => void host.state.execute(new NameTransitionCommand(assetId, edgeId, textOf(next))),
    });
    host.fields.set(NAME_KEY, name);
    host.body.add(name.row);
    addNote(host, 'A State transition node takes it by this name.', 'small');
  } else if (d.send) {
    const send = d.send;
    // The rows outlive an edit of the other one, so what stands is read when one of them changes.
    const set = (next: Partial<EdgeSend>) => {
      const now = describeEdge(host.state.project, assetId, edgeId)?.send ?? send;
      void host.state.execute(new SetSendCommand(assetId, edgeId, { ...now, ...next }));
    };
    const volume = createFieldRow(host, SEND_VOLUME, send.volume, {
      onInput: () => {},
      onChange: (next) => set({ volume: Number(next) }),
    });
    host.fields.set(SEND_VOLUME.key, volume);
    host.body.add(volume.row);
    if (!d.tapped) {
      addNote(host, 'In decibels, after the volume and the sound FX of the asset.', 'small');
      return;
    }
    const tap = createFieldRow(host, SEND_TAP, send.tap, {
      onInput: () => {},
      onChange: (next) => set({ tap: SEND_TAPS.find((t) => t.value === textOf(next))?.value ?? 'post' }),
    });
    host.fields.set(SEND_TAP.key, tap);
    host.body.add(tap.row);
    addNote(host, 'In decibels. Mode says where on its track or bus the link takes the sound.', 'small');
  } else {
    fact('Input', d.input);
    fact('Type', d.type);
  }
}

/** Pushes the current name into its row. False when the link is gone (rebuild). */
export function refreshEdgeSection(host: InspectorHost, assetId: string, edgeId: string): boolean {
  const d = describeEdge(host.state.project, assetId, edgeId);
  if (!d) return false;
  host.fields.get(NAME_KEY)?.setValue(d.name);
  if (d.send) {
    host.fields.get(SEND_VOLUME.key)?.setValue(d.send.volume);
    host.fields.get(SEND_TAP.key)?.setValue(d.send.tap);
  }
  return true;
}