Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
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>;