@dxos/plugin-deck 0.8.4-main.3f58842 → 0.8.4-main.52d7546f51

package/dist/lib/node-esm/operation-resolver-ZQGNATPX.mjs

@@ -0,0 +1,598 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  closeEntry,
+  computeActiveUpdates,
+  createEntryId,
+  incrementPlank,
+  openEntry
+} from "./chunk-ADPMWKLL.mjs";
+import {
+  DeckCapabilities,
+  DeckOperation,
+  PLANK_COMPANION_TYPE,
+  defaultDeck,
+  getMode,
+  isLayoutMode,
+  meta
+} from "./chunk-CVYHPJIN.mjs";
+
+// src/capabilities/operation-resolver/operation-resolver.ts
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Option from "effect/Option";
+import { Capabilities, Capability, UndoOperation } from "@dxos/app-framework";
+import { AppCapabilities, LayoutOperation } from "@dxos/app-toolkit";
+import { Obj } from "@dxos/echo";
+import { invariant } from "@dxos/invariant";
+import { log } from "@dxos/log";
+import { OperationResolver } from "@dxos/operation";
+import { Operation } from "@dxos/operation";
+import { AttentionCapabilities } from "@dxos/plugin-attention";
+import { Graph, Node } from "@dxos/plugin-graph";
+import { ObservabilityOperation } from "@dxos/plugin-observability/types";
+import { byPosition, isNonNullable } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-deck/src/capabilities/operation-resolver/operation-resolver.ts";
+var updateActiveDeck = (current, deckUpdates) => {
+  const currentDeck = current.decks[current.activeDeck];
+  invariant(currentDeck, `Deck not found: ${current.activeDeck}`, {
+    F: __dxlog_file,
+    L: 41,
+    S: void 0,
+    A: [
+      "currentDeck",
+      "`Deck not found: ${current.activeDeck}`"
+    ]
+  });
+  return {
+    ...current,
+    decks: {
+      ...current.decks,
+      [current.activeDeck]: {
+        ...currentDeck,
+        ...deckUpdates
+      }
+    }
+  };
+};
+var operation_resolver_default = Capability.makeModule(Effect.fnUntraced(function* () {
+  return Capability.contributes(Capabilities.OperationResolver, [
+    //
+    // UpdateSidebar
+    //
+    OperationResolver.make({
+      operation: LayoutOperation.UpdateSidebar,
+      handler: Effect.fnUntraced(function* (input) {
+        const state = yield* Capabilities.getAtomValue(DeckCapabilities.State);
+        const next = input.state ?? state.sidebarState;
+        if (next !== state.sidebarState) {
+          yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state2) => ({
+            ...state2,
+            sidebarState: next
+          }));
+        }
+      })
+    }),
+    //
+    // UpdateComplementary
+    //
+    OperationResolver.make({
+      operation: LayoutOperation.UpdateComplementary,
+      handler: Effect.fnUntraced(function* (input) {
+        const state = yield* Capabilities.getAtomValue(DeckCapabilities.State);
+        const panelChanged = state.complementarySidebarPanel !== input.subject;
+        const next = input.subject ? "expanded" : input.state ?? state.complementarySidebarState;
+        const stateChanged = next !== state.complementarySidebarState;
+        if (panelChanged || stateChanged) {
+          yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state2) => ({
+            ...state2,
+            complementarySidebarPanel: panelChanged ? input.subject : state2.complementarySidebarPanel,
+            complementarySidebarState: stateChanged ? next : state2.complementarySidebarState
+          }));
+        }
+      })
+    }),
+    //
+    // UpdateDialog
+    //
+    OperationResolver.make({
+      operation: LayoutOperation.UpdateDialog,
+      handler: Effect.fnUntraced(function* (input) {
+        yield* Capabilities.updateAtomValue(DeckCapabilities.EphemeralState, (state) => ({
+          ...state,
+          dialogOpen: input.state ?? Boolean(input.subject),
+          dialogType: input.type ?? "default",
+          dialogBlockAlign: input.blockAlign ?? "center",
+          dialogOverlayClasses: input.overlayClasses,
+          dialogOverlayStyle: input.overlayStyle,
+          dialogContent: input.subject ? {
+            component: input.subject,
+            props: input.props
+          } : null
+        }));
+      })
+    }),
+    //
+    // UpdatePopover
+    //
+    OperationResolver.make({
+      operation: LayoutOperation.UpdatePopover,
+      handler: Effect.fnUntraced(function* (input) {
+        yield* Capabilities.updateAtomValue(DeckCapabilities.EphemeralState, (state) => ({
+          ...state,
+          popoverOpen: input.state ?? Boolean(input.subject),
+          popoverKind: input.kind ?? "base",
+          popoverTitle: input.kind === "card" ? input.title : void 0,
+          popoverContentRef: input.subjectRef,
+          popoverContent: typeof input.subject === "string" ? {
+            component: input.subject,
+            props: input.props
+          } : input.subject ? {
+            subject: input.subject
+          } : null,
+          popoverSide: input.side,
+          popoverAnchor: input.variant === "virtual" ? input.anchor : state.popoverAnchor,
+          popoverAnchorId: input.variant !== "virtual" ? input.anchorId : state.popoverAnchorId
+        }));
+      })
+    }),
+    //
+    // AddToast
+    //
+    OperationResolver.make({
+      operation: LayoutOperation.AddToast,
+      handler: Effect.fnUntraced(function* (input) {
+        yield* Capabilities.updateAtomValue(DeckCapabilities.EphemeralState, (state) => ({
+          ...state,
+          toasts: [
+            ...state.toasts,
+            input
+          ]
+        }));
+      })
+    }),
+    //
+    // ShowUndo
+    //
+    OperationResolver.make({
+      operation: UndoOperation.ShowUndo,
+      handler: Effect.fnUntraced(function* (input) {
+        const historyTracker = yield* Capability.get(Capabilities.HistoryTracker);
+        const newUndoId = `show-undo-${Date.now()}`;
+        yield* Capabilities.updateAtomValue(DeckCapabilities.EphemeralState, (state) => {
+          const filteredToasts = state.currentUndoId ? state.toasts.filter((toast2) => toast2.id !== state.currentUndoId) : state.toasts;
+          const toast = {
+            id: newUndoId,
+            title: input.message ?? [
+              "undo available label",
+              {
+                ns: meta.id
+              }
+            ],
+            duration: 1e4,
+            actionLabel: [
+              "undo action label",
+              {
+                ns: meta.id
+              }
+            ],
+            actionAlt: [
+              "undo action alt",
+              {
+                ns: meta.id
+              }
+            ],
+            closeLabel: [
+              "undo close label",
+              {
+                ns: meta.id
+              }
+            ],
+            onAction: () => historyTracker.undoPromise()
+          };
+          return {
+            ...state,
+            currentUndoId: newUndoId,
+            toasts: [
+              ...filteredToasts,
+              toast
+            ]
+          };
+        });
+      })
+    }),
+    //
+    // SetLayoutMode
+    //
+    OperationResolver.make({
+      operation: LayoutOperation.SetLayoutMode,
+      filter: (input) => {
+        if ("mode" in input) {
+          return isLayoutMode(input.mode);
+        }
+        return true;
+      },
+      handler: Effect.fnUntraced(function* (input) {
+        const state = yield* Capabilities.getAtomValue(DeckCapabilities.State);
+        const deck = yield* DeckCapabilities.getDeck();
+        const computeModeUpdate = (mode, subject) => {
+          const current = deck.solo ? [
+            deck.solo
+          ] : deck.active;
+          const next = (mode !== "deck" ? [
+            subject ?? deck.solo ?? deck.active[0]
+          ] : [
+            ...deck.active,
+            deck.solo
+          ]).filter(isNonNullable);
+          const removed = current.filter((id) => !next.includes(id));
+          const closed = Array.from(/* @__PURE__ */ new Set([
+            ...deck.inactive.filter((id) => !next.includes(id)),
+            ...removed
+          ]));
+          const soloUpdate = mode !== "deck" && next[0] ? {
+            solo: next[0]
+          } : mode === "deck" && deck.solo ? {
+            solo: void 0,
+            initialized: true
+          } : {};
+          const fullscreenUpdate = mode === "solo--fullscreen" ? {
+            fullscreen: !deck.fullscreen
+          } : {};
+          return {
+            inactive: closed,
+            ...soloUpdate,
+            ...fullscreenUpdate
+          };
+        };
+        if ("mode" in input) {
+          const currentMode = getMode(deck);
+          const deckUpdates = computeModeUpdate(input.mode, "subject" in input ? input.subject : void 0);
+          yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state2) => {
+            const newPreviousMode = currentMode !== input.mode ? {
+              ...state2.previousMode,
+              [state2.activeDeck]: currentMode
+            } : state2.previousMode;
+            return {
+              ...updateActiveDeck(state2, deckUpdates),
+              previousMode: newPreviousMode
+            };
+          });
+        } else if ("revert" in input) {
+          const last = state.previousMode[state.activeDeck];
+          const deckUpdates = computeModeUpdate(last ?? "solo");
+          yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state2) => updateActiveDeck(state2, deckUpdates));
+        } else {
+          log.warn("Invalid layout mode", input, {
+            F: __dxlog_file,
+            L: 253,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+        }
+      })
+    }),
+    //
+    // SwitchWorkspace
+    //
+    OperationResolver.make({
+      operation: LayoutOperation.SwitchWorkspace,
+      handler: Effect.fnUntraced(function* (input) {
+        const { graph } = yield* Capability.get(AppCapabilities.AppGraph);
+        {
+          const state = yield* Capabilities.getAtomValue(DeckCapabilities.State);
+          const shouldUpdatePrevious = !state.activeDeck.startsWith("!");
+          yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state2) => {
+            const newDecks = state2.decks[input.subject] ? state2.decks : {
+              ...state2.decks,
+              [input.subject]: {
+                ...defaultDeck
+              }
+            };
+            return {
+              ...state2,
+              previousDeck: shouldUpdatePrevious ? state2.activeDeck : state2.previousDeck,
+              activeDeck: input.subject,
+              decks: newDecks
+            };
+          });
+        }
+        {
+          const state = yield* Capabilities.getAtomValue(DeckCapabilities.State);
+          const deck = state.decks[input.subject];
+          invariant(deck, `Deck not found: ${input.subject}`, {
+            F: __dxlog_file,
+            L: 288,
+            S: this,
+            A: [
+              "deck",
+              "`Deck not found: ${input.subject}`"
+            ]
+          });
+          const first = deck.solo ? deck.solo : deck.active[0];
+          if (first) {
+            yield* Operation.schedule(LayoutOperation.ScrollIntoView, {
+              subject: first
+            });
+          } else {
+            const [item] = Graph.getConnections(graph, input.subject).filter((node) => !Node.isActionLike(node) && !node.properties.disposition);
+            if (item) {
+              yield* Operation.schedule(LayoutOperation.Open, {
+                subject: [
+                  item.id
+                ]
+              });
+            }
+          }
+        }
+      })
+    }),
+    //
+    // RevertWorkspace
+    //
+    OperationResolver.make({
+      operation: LayoutOperation.RevertWorkspace,
+      handler: Effect.fnUntraced(function* () {
+        const state = yield* Capabilities.getAtomValue(DeckCapabilities.State);
+        yield* Operation.invoke(LayoutOperation.SwitchWorkspace, {
+          subject: state.previousDeck
+        });
+      })
+    }),
+    //
+    // Open
+    //
+    OperationResolver.make({
+      operation: LayoutOperation.Open,
+      handler: Effect.fnUntraced(function* (input) {
+        const { graph } = yield* Capability.get(AppCapabilities.AppGraph);
+        const attention = yield* Capability.get(AttentionCapabilities.Attention);
+        const settings = yield* Capabilities.getAtomValue(DeckCapabilities.Settings);
+        {
+          const state = yield* Capabilities.getAtomValue(DeckCapabilities.State);
+          if (input.workspace && state.activeDeck !== input.workspace) {
+            yield* Operation.invoke(LayoutOperation.SwitchWorkspace, {
+              subject: input.workspace
+            });
+          }
+        }
+        let previouslyOpenIds;
+        {
+          const deck = yield* DeckCapabilities.getDeck();
+          previouslyOpenIds = new Set(deck.solo ? [
+            deck.solo
+          ] : deck.active);
+          const next = deck.solo ? input.subject.map((id) => createEntryId(id, input.variant)) : input.subject.reduce((acc, entryId) => openEntry(acc, entryId, {
+            key: input.key,
+            positioning: input.positioning ?? settings?.newPlankPositioning,
+            pivotId: input.pivotId,
+            variant: input.variant
+          }), deck.active);
+          const { deckUpdates, toAttend: _toAttend } = computeActiveUpdates({
+            next,
+            deck,
+            attention
+          });
+          yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) => updateActiveDeck(state, deckUpdates));
+        }
+        {
+          const deck = yield* DeckCapabilities.getDeck();
+          const ids = deck.solo ? [
+            deck.solo
+          ] : deck.active;
+          const newlyOpen = ids.filter((i) => !previouslyOpenIds.has(i));
+          if (input.scrollIntoView !== false && (newlyOpen[0] ?? input.subject[0])) {
+            yield* Operation.schedule(LayoutOperation.ScrollIntoView, {
+              subject: newlyOpen[0] ?? input.subject[0]
+            });
+          }
+          if (newlyOpen[0] ?? input.subject[0]) {
+            yield* Operation.schedule(LayoutOperation.Expose, {
+              subject: newlyOpen[0] ?? input.subject[0]
+            });
+          }
+          for (const subjectId of newlyOpen) {
+            const typename = Option.match(Graph.getNode(graph, subjectId), {
+              onNone: () => void 0,
+              onSome: (node) => {
+                const active = node.data;
+                return Obj.isObject(active) ? Obj.getTypename(active) : void 0;
+              }
+            });
+            yield* Operation.schedule(ObservabilityOperation.SendEvent, {
+              name: "navigation.activate",
+              properties: {
+                subjectId,
+                typename
+              }
+            });
+          }
+        }
+      })
+    }),
+    //
+    // UpdatePlankSize
+    //
+    OperationResolver.make({
+      operation: DeckOperation.UpdatePlankSize,
+      handler: Effect.fnUntraced(function* (input) {
+        yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) => updateActiveDeck(state, {
+          plankSizing: {
+            ...state.decks[state.activeDeck]?.plankSizing,
+            [input.id]: input.size
+          }
+        }));
+      })
+    }),
+    //
+    // Adjust
+    //
+    OperationResolver.make({
+      operation: DeckOperation.Adjust,
+      handler: Effect.fnUntraced(function* (input) {
+        const _state = yield* Capabilities.getAtomValue(DeckCapabilities.State);
+        const deck = yield* DeckCapabilities.getDeck();
+        const attention = yield* Capability.get(AttentionCapabilities.Attention);
+        const { graph } = yield* Capability.get(AppCapabilities.AppGraph);
+        let soloOperation;
+        if (input.type === "increment-end" || input.type === "increment-start") {
+          const next = incrementPlank(deck.active, input);
+          const { deckUpdates } = computeActiveUpdates({
+            next,
+            deck,
+            attention
+          });
+          yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) => updateActiveDeck(state, deckUpdates));
+        }
+        if (input.type.startsWith("solo")) {
+          const entryId = input.id;
+          if (!deck.solo) {
+            soloOperation = {
+              type: "solo",
+              entryId,
+              mode: input.type
+            };
+          } else {
+            if (input.type === "solo--fullscreen") {
+              soloOperation = {
+                type: "solo",
+                entryId,
+                mode: "solo--fullscreen"
+              };
+            } else if (input.type === "solo") {
+              soloOperation = {
+                type: "unsolo",
+                entryId
+              };
+            }
+          }
+        }
+        if (soloOperation?.type === "solo") {
+          yield* Operation.invoke(LayoutOperation.SetLayoutMode, {
+            subject: soloOperation.entryId,
+            mode: soloOperation.mode
+          });
+        } else if (soloOperation?.type === "unsolo") {
+          yield* Operation.invoke(LayoutOperation.SetLayoutMode, {
+            mode: "deck"
+          });
+          yield* Operation.invoke(LayoutOperation.Open, {
+            subject: [
+              soloOperation.entryId
+            ]
+          });
+        }
+        if (input.type === "companion") {
+          const companion = Function.pipe(Graph.getNode(graph, input.id), Option.map((node) => Graph.getConnections(graph, node.id).filter((n) => n.type === PLANK_COMPANION_TYPE).toSorted((a, b) => byPosition(a.properties, b.properties))), Option.flatMap((companions) => companions.length > 0 ? Option.some(companions[0]) : Option.none()));
+          if (Option.isSome(companion)) {
+            yield* Operation.invoke(DeckOperation.ChangeCompanion, {
+              primary: input.id,
+              companion: companion.value.id
+            });
+          }
+        }
+      })
+    }),
+    //
+    // ChangeCompanion
+    //
+    OperationResolver.make({
+      operation: DeckOperation.ChangeCompanion,
+      handler: Effect.fnUntraced(function* (input) {
+        const deck = yield* DeckCapabilities.getDeck();
+        if (input.companion === null) {
+          const { [input.primary]: _, ...nextActiveCompanions } = deck.activeCompanions ?? {};
+          yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) => updateActiveDeck(state, {
+            activeCompanions: nextActiveCompanions
+          }));
+        } else {
+          const companion = input.companion;
+          invariant(companion !== input.primary, void 0, {
+            F: __dxlog_file,
+            L: 494,
+            S: this,
+            A: [
+              "companion !== input.primary",
+              ""
+            ]
+          });
+          yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) => updateActiveDeck(state, {
+            activeCompanions: {
+              ...deck.activeCompanions,
+              [input.primary]: companion
+            }
+          }));
+        }
+      })
+    }),
+    //
+    // Close
+    //
+    OperationResolver.make({
+      operation: LayoutOperation.Close,
+      handler: Effect.fnUntraced(function* (input) {
+        const deck = yield* DeckCapabilities.getDeck();
+        const attention = yield* Capability.get(AttentionCapabilities.Attention);
+        const active = deck.solo ? [
+          deck.solo
+        ] : deck.active;
+        const next = input.subject.reduce((acc, id) => closeEntry(acc, id), active);
+        const { deckUpdates, toAttend } = computeActiveUpdates({
+          next,
+          deck,
+          attention
+        });
+        yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) => updateActiveDeck(state, deckUpdates));
+        for (const id of input.subject) {
+          if (deck.activeCompanions && id in deck.activeCompanions) {
+            yield* Operation.invoke(DeckOperation.ChangeCompanion, {
+              primary: id,
+              companion: null
+            });
+          }
+        }
+        if (toAttend) {
+          yield* Operation.schedule(LayoutOperation.ScrollIntoView, {
+            subject: toAttend
+          });
+        }
+      })
+    }),
+    //
+    // Set
+    //
+    OperationResolver.make({
+      operation: LayoutOperation.Set,
+      handler: Effect.fnUntraced(function* (input) {
+        const deck = yield* DeckCapabilities.getDeck();
+        const attention = yield* Capability.get(AttentionCapabilities.Attention);
+        const { deckUpdates, toAttend } = computeActiveUpdates({
+          next: input.subject,
+          deck,
+          attention
+        });
+        yield* Capabilities.updateAtomValue(DeckCapabilities.State, (state) => updateActiveDeck(state, deckUpdates));
+        if (toAttend) {
+          yield* Operation.schedule(LayoutOperation.ScrollIntoView, {
+            subject: toAttend
+          });
+        }
+      })
+    }),
+    //
+    // ScrollIntoView
+    //
+    OperationResolver.make({
+      operation: LayoutOperation.ScrollIntoView,
+      handler: Effect.fnUntraced(function* (input) {
+        yield* Capabilities.updateAtomValue(DeckCapabilities.EphemeralState, (state) => ({
+          ...state,
+          scrollIntoView: input.subject
+        }));
+      })
+    })
+  ]);
+}));
+export {
+  operation_resolver_default as default
+};
+//# sourceMappingURL=operation-resolver-ZQGNATPX.mjs.map