tabs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124// Tabs' scoped effects serve the convergence/tabs service and consume legacy shared requests.
// The service emits which tab is visible; third-party plugins still open and
// close through the shared openTab/closeTab keys those writes once were.
// File reads run in the layer scope so closing/unloading never leaves a detached task.
import * as Context from "effect/Context";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import { App, Host, Notify, parse } from "convergence/effect";
import type { AppState, ViewHandle } from "convergence";
import { closeRequest, closeTab, fileResponse, initialState, openRequest, openTab, readContent } from "./tabs.ts";
import type { Tab, TabInput } from "./tabs.ts";

// What the convergence/tabs events carry: which tab, or none visible.
export interface TabRef {
  readonly kind: Tab["kind"];
  readonly path: string;
}

const makeTabs = Effect.fn("Tabs.make")(function* () {
  const host = yield* Host;
  const app = yield* App;
  const notify = yield* Notify;
  const scope = yield* Effect.scope;
  const state = initialState();
  const views: ViewHandle[] = [];
  const redraw = () => {
    for (const view of views) view.update();
  };
  // The service handle is set after the views register; until a provider
  // handle exists there is nobody to tell.
  let emitActive: ((tab: TabRef | null) => void) | undefined;
  const announce = (tab: Tab | undefined) => {
    emitActive?.(tab ? { kind: tab.kind, path: tab.path } : null);
  };
  const readFile = Effect.fn("Tabs.readFile")(function* (tab: TabInput, id: string) {
    yield* host.call("host/fs.read", { workspaceId: tab.workspaceId, path: tab.path }).pipe(
      Effect.flatMap((result) => parse("file contents", fileResponse, result)),
      Effect.tap((result) =>
        Effect.sync(() => {
          state.contents[id] = readContent(result);
        }),
      ),
      Effect.catchTag(["HostCallFailed", "NeedsReview", "PermissionNotGranted", "ParseFailed"], (error) =>
        Effect.sync(() => {
          state.contents[id] = {
            error: error._tag === "ParseFailed" ? `${error.what}: ${error.issues.join("; ")}` : error.message,
          };
        }),
      ),
    );
    redraw();
  });
  const open = Effect.fn("Tabs.open")(function* (request: TabInput) {
    const tab = openTab(state, request);
    announce(tab);
    redraw();
    if (request.kind === "file") yield* Effect.forkIn(readFile(request, tab.id), scope, { startImmediately: true });
    return tab;
  });
  const close = Effect.fn("Tabs.close")(function* (id: string) {
    announce(closeTab(state, id));
    redraw();
  });
  const select = Effect.fn("Tabs.select")(function* (tab: Tab) {
    state.active = tab.id;
    announce(tab);
    redraw();
  });
  // The convergence/tabs service methods: open and close by reference, and
  // which tab is visible. They share the open path above, without consuming
  // a legacy request.
  const closeByRef = Effect.fn("Tabs.closeByRef")(function* (ref: TabRef) {
    const tab = state.tabs.find((tab) => tab.kind === ref.kind && tab.path === ref.path);
    if (tab) yield* close(tab.id);
    return null;
  });
  const activeRef = Effect.fn("Tabs.activeRef")(function* (): Effect.fn.Return<TabRef | null> {
    const tab = state.tabs.find((tab) => tab.id === state.active) ?? state.tabs[0];
    return tab ? { kind: tab.kind, path: tab.path } : null;
  });
  const followApp = Effect.fn("Tabs.followApp")(
    function* (next: AppState) {
      const request = next.shared?.openTab;
      if (request) {
        const parsed = yield* parse("openTab", openRequest, request);
        if (parsed.nonce !== state.handled) {
          state.handled = parsed.nonce;
          yield* open(parsed);
          // Consumed requests must not reopen closed tabs after the app restarts.
          yield* app.update({ shared: { openTab: null } });
        }
      }
      const gone = next.shared?.closeTab;
      if (gone) {
        const parsed = yield* parse("closeTab", closeRequest, gone);
        if (parsed.nonce !== state.handledClose) {
          state.handledClose = parsed.nonce;
          yield* app.update({ shared: { closeTab: null } });
          const tab = state.tabs.find((tab) => tab.kind === parsed.kind && tab.path === parsed.path);
          if (tab) yield* close(tab.id);
        }
      }
    },
    // Invalid shared data is reported without ending the request subscription.
    Effect.catchTag("ParseFailed", (error) => notify.error(`${error.what}: ${error.issues.join("; ")}`)),
  );
  return {
    state,
    views,
    open,
    close,
    closeByRef,
    activeRef,
    select,
    followApp,
    emitActive: (emit: typeof emitActive) => {
      emitActive = emit;
    },
  };
});

export class Tabs extends Context.Service<Tabs, Effect.Success<ReturnType<typeof makeTabs>>>()("tabs/Tabs") {
  static readonly layer = Layer.effect(Tabs, makeTabs());
}