Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

5.1 KB
Raw Blame
import { createSignal, untrack } from 'solid-js';
import { createPanes } from '../panes/panes';
import { createRoutesManifest, resolveBranch } from '../routes/manifest';
import type {
  Entry,
  PaneId,
  PreloadIntent,
  SplitLocation,
} from '../routes/types';
import { createClaims } from './claims';
import { createLayout } from './layout';
import { createLeaveGuards } from './leave-guards';
import { createPaneList } from './pane-list';
import { createPaneNavigation } from './pane-navigation';
import { createPhaseScopes } from './phases';
import { preloadLocation } from './preload';
import { createRunner } from './runner';
import type { RouteMatchInfo, SplitRouterOptions } from './types';
import { createUrl } from './url';
import { createUrlNavigation } from './url-navigation';

export function createSplitRouter(options: SplitRouterOptions) {
  const routes = createRoutesManifest(options.routes);
  const history =
    typeof options.history === 'function'
      ? options.history(routes)
      : options.history;
  const [ready, setReady] = createSignal(false);
  let disposed = false;

  const guards = createLeaveGuards();

  const panes = createPanes<Entry, SplitLocation>({
    store: options.paneStore,
    policy: options.policy,
    createPaneId: options.createPaneId,
    onRemove: guards.forget,
  });

  const url = createUrl({ routes, history, panes });

  const preloadLifetime = new AbortController();
  const phaseOptions = {
    preloadSignal: preloadLifetime.signal,
    routes,
    middleware: options.middleware ?? [],
    guards,
    current: (pane: PaneId) => untrack(() => panes.current(pane)),
    preloadBudgetMs: options.preloadBudgetMs ?? 150,
  };

  const runner = createRunner({
    phases: (waiting, onCommit) =>
      createPhaseScopes(phaseOptions, waiting, onCommit),
    live: () => untrack(panes.ids),
  });

  const claims = createClaims({
    routes,
    panes,
    runner,
    carrySearch: (pane, destination, mode) =>
      paneNavigation.carrySearch(pane, destination, mode),
  });

  const urlNavigation = createUrlNavigation({
    routes,
    history,
    panes,
    url,
    runner,
    guards,
    markReady: () => setReady(true),
  });

  const paneNavigation = createPaneNavigation({
    routes,
    panes,
    url,
    runner,
    claims,
    navigateToLocation: urlNavigation.navigateToLocation,
  });

  const paneList = createPaneList({
    routes,
    panes,
    url,
    runner,
    claims,
    navigation: paneNavigation,
  });

  const layout = createLayout({ routes, panes, url, runner });

  const disconnect = urlNavigation.connect();

  const matches = (pane: PaneId): RouteMatchInfo[] => {
    const entry = panes.current(pane);
    if (!entry) return [];

    const { route } = entry.location;

    return resolveBranch(routes, route).map((node, depth) => ({
      id: node.definition.id,
      params: route.matches[depth]!.params,
      info: node.definition.info,
    }));
  };

  const preload = (
    location: SplitLocation,
    intent: PreloadIntent = 'hover'
  ): Promise<unknown> | undefined => {
    if (disposed) return;
    const context = { location, intent, signal: preloadLifetime.signal };

    return untrack(() => preloadLocation(routes, context));
  };

  const dispose = (): void => {
    if (disposed) return;

    disposed = true;
    preloadLifetime.abort();
    disconnect();
    runner.dispose();
    claims.dispose();
  };

  return {
    routes,
    claims: claims.registry,
    ready,
    panes: panes.ids,
    /** How the panes tile; its panes in order are `panes()`. */
    layout: panes.layout,
    /** How a pane tiles, open or parked: the layout it is (or was) shown in. */
    layoutOf: panes.layoutOf,
    /** Sizes the split at a path; sizes stay out of the URL and history. */
    resizeLayout: panes.resize,
    resetLayoutSizes: panes.resetShares,
    /** Open and parked panes; see `openLayout` and `showLayout`. */
    retainedPanes: panes.retained,
    navigate: urlNavigation.navigate,
    navigatePane: paneNavigation.navigate,
    /** Cancels pending navigation and new panes requested from this pane. */
    cancelNavigation: (pane: PaneId) =>
      runner.act(undefined, () => {
        runner.abort(pane);
        paneList.cancelOpeningFrom(pane);
      }),
    updateSearch: paneNavigation.updateSearch,
    goBackTo: paneNavigation.goBackTo,
    removeEntries: paneNavigation.removeEntries,
    rewriteCurrent: paneNavigation.rewriteCurrent,
    canGo: paneNavigation.canGo,
    open: paneList.open,
    close: paneList.close,
    remove: paneList.remove,
    move: paneList.move,
    entry: panes.current,
    history: panes.read,
    arrival: panes.arrival,
    pending: runner.pending,
    matches,
    preload,
    href: url.href,
    layoutSnapshot: layout.snapshot,
    restoreLayout: layout.restore,
    openLayout: layout.open,
    showLayout: layout.show,
    discardPanes: layout.discard,
    layoutFromHref: layout.fromHref,
    layoutHref: layout.href,
    createPaneId: panes.createPaneId,
    activatePane: panes.activate,
    registerGuard: guards.register,
    settled: runner.settled,
    dispose,
  };
}

export type SplitRouter = ReturnType<typeof createSplitRouter>;