@myst-theme/jupyter 0.3.3 → 0.3.5

package/dist/cjs/execute/leaf.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="react" />
+import type { ExecuteScopeAction } from './actions';
+import type { IdKeyMap, ExecuteScopeState } from './types';
+export declare function MdastFetcher({ slug, url, dispatch, }: {
+    slug: string;
+    url: string;
+    dispatch: React.Dispatch<ExecuteScopeAction>;
+}): import("react/jsx-runtime").JSX.Element | null;
+export declare function NotebookBuilder({ pageSlug, notebookSlug, idkmap, state, dispatch, }: {
+    pageSlug: string;
+    notebookSlug: string;
+    idkmap: IdKeyMap;
+    state: ExecuteScopeState;
+    dispatch: React.Dispatch<ExecuteScopeAction>;
+}): null;
+export declare function SessionStarter({ pageSlug, notebookSlug, state, dispatch, }: {
+    pageSlug: string;
+    notebookSlug: string;
+    state: ExecuteScopeState;
+    dispatch: React.Dispatch<ExecuteScopeAction>;
+}): null;
+export declare function ServerMonitor({ state, dispatch, }: {
+    state: ExecuteScopeState;
+    dispatch: React.Dispatch<ExecuteScopeAction>;
+}): null;
+//# sourceMappingURL=leaf.d.ts.map

package/dist/cjs/execute/leaf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"leaf.d.ts","sourceRoot":"","sources":["../../../src/execute/leaf.tsx"],"names":[],"mappings":";AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,KAAK,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAO3D,wBAAgB,YAAY,CAAC,EAC3B,IAAI,EACJ,GAAG,EACH,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAC;CAC9C,kDAkBA;AAED,wBAAgB,eAAe,CAAC,EAC9B,QAAQ,EACR,YAAY,EACZ,MAAM,EACN,KAAK,EACL,QAAQ,GACT,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,QAAQ,CAAC;IACjB,KAAK,EAAE,iBAAiB,CAAC;IACzB,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAC;CAC9C,QA8CA;AAED,wBAAgB,cAAc,CAAC,EAC7B,QAAQ,EACR,YAAY,EACZ,KAAK,EACL,QAAQ,GACT,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,iBAAiB,CAAC;IACzB,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAC;CAC9C,QAoEA;AAED,wBAAgB,aAAa,CAAC,EAC5B,KAAK,EACL,QAAQ,GACT,EAAE;IACD,KAAK,EAAE,iBAAiB,CAAC;IACzB,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAC;CAC9C,QA4BA"}

package/dist/cjs/execute/leaf.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerMonitor = exports.SessionStarter = exports.NotebookBuilder = exports.MdastFetcher = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const thebe_react_1 = require("thebe-react");
+const utils_1 = require("./utils");
+const selectors_1 = require("./selectors");
+const myst_to_react_1 = require("myst-to-react");
+function MdastFetcher({ slug, url, dispatch, }) {
+    const { data, error } = (0, myst_to_react_1.useFetchMdast)({ remote: true, dataUrl: `${url}.json` });
+    (0, react_1.useEffect)(() => {
+        if (!data)
+            return;
+        dispatch({ type: 'ADD_MDAST', payload: { slug, mdast: data.mdast } });
+    }, [data]);
+    if (error) {
+        return ((0, jsx_runtime_1.jsxs)("div", { children: ["error: ", slug, error.message] }));
+    }
+    return null;
+}
+exports.MdastFetcher = MdastFetcher;
+function NotebookBuilder({ pageSlug, notebookSlug, idkmap, state, dispatch, }) {
+    var _a;
+    const { core } = (0, thebe_react_1.useThebeLoader)();
+    const { config } = (0, thebe_react_1.useThebeConfig)();
+    const lock = (0, react_1.useRef)(false); // TODO can be removed if we solve double render from provider
+    const scopeHasNotebook = !!((_a = state.pages[pageSlug]) === null || _a === void 0 ? void 0 : _a.scopes[notebookSlug]);
+    (0, react_1.useEffect)(() => {
+        var _a;
+        if (!core || !config || scopeHasNotebook || lock.current)
+            return;
+        lock.current = true;
+        console.debug(`Jupyter: NotebookBuilder - ${notebookSlug} being added to scope ${pageSlug}`);
+        const rendermime = core === null || core === void 0 ? void 0 : core.makeRenderMimeRegistry(config === null || config === void 0 ? void 0 : config.mathjax);
+        const notebook = (0, utils_1.notebookFromMdast)(core, config, pageSlug, notebookSlug, state.mdast[notebookSlug].root, idkmap, rendermime);
+        // hook up computable targets
+        const computables = (_a = state.pages[pageSlug]) === null || _a === void 0 ? void 0 : _a.computables;
+        computables === null || computables === void 0 ? void 0 : computables.forEach((c) => {
+            if (idkmap[c.label]) {
+                idkmap[c.outputKey] = idkmap[c.label];
+                idkmap[c.embedKey] = idkmap[c.label];
+            }
+        });
+        dispatch({
+            type: 'ADD_NOTEBOOK',
+            payload: { pageSlug, notebookSlug, rendermime, notebook },
+        });
+    }, [core, config, pageSlug, notebookSlug, scopeHasNotebook, lock]);
+    // TODO find a way to check if the all the notebooks are built and do a single dispatch
+    // potentilly use a move the loop down into this component
+    const allNotebooksAreBuilt = (0, selectors_1.selectAreAllNotebookScopesBuilt)(state, pageSlug);
+    (0, react_1.useEffect)(() => {
+        if (!allNotebooksAreBuilt)
+            return;
+        dispatch({ type: 'BUILD_STATUS', payload: { slug: pageSlug, status: 'wait-for-server' } });
+    }, [allNotebooksAreBuilt]);
+    return null;
+}
+exports.NotebookBuilder = NotebookBuilder;
+function SessionStarter({ pageSlug, notebookSlug, state, dispatch, }) {
+    var _a;
+    const { core } = (0, thebe_react_1.useThebeLoader)();
+    const { config, server } = (0, thebe_react_1.useThebeServer)();
+    const lock = (0, react_1.useRef)(false); // TODO can be removed if we solve double render from provider
+    const scope = (_a = state.pages[pageSlug]) === null || _a === void 0 ? void 0 : _a.scopes[notebookSlug];
+    (0, react_1.useEffect)(() => {
+        if (!core || !server || scope.session || lock.current)
+            return;
+        lock.current = true;
+        console.debug(`Jupyter: Starting session for ${pageSlug}-${notebookSlug}`);
+        server.listRunningSessions().then((sessions) => {
+            console.debug('Jupyter: running sessions', sessions);
+            const path = `/${pageSlug}-${notebookSlug}.ipynb`;
+            const existing = sessions.find((s) => s.path === path);
+            if (existing) {
+                console.debug(`session already exists for ${pageSlug}-${notebookSlug}`, existing);
+                server.connectToExistingSession(existing, scope.rendermime).then((sesh) => {
+                    var _a;
+                    if (sesh == null) {
+                        console.error(`Could not connect to session for ${pageSlug} ${notebookSlug}`);
+                        return;
+                    }
+                    console.debug(`reconnected to session for ${pageSlug}/${notebookSlug}`, sesh);
+                    console.debug('restarting session', sesh);
+                    (_a = sesh.kernel) === null || _a === void 0 ? void 0 : _a.restart().then(() => {
+                        var _a;
+                        const notebook = (_a = state.pages[pageSlug]) === null || _a === void 0 ? void 0 : _a.scopes[notebookSlug].notebook;
+                        notebook.attachSession(sesh);
+                        dispatch({ type: 'ADD_SESSION', payload: { pageSlug, notebookSlug, session: sesh } });
+                    });
+                });
+            }
+            else {
+                server
+                    .startNewSession(scope.rendermime, Object.assign(Object.assign({}, config === null || config === void 0 ? void 0 : config.kernels), { name: `${pageSlug}-${notebookSlug}.ipynb`, path }))
+                    .then((sesh) => {
+                    var _a;
+                    if (sesh == null) {
+                        server === null || server === void 0 ? void 0 : server.getKernelSpecs().then((specs) => {
+                            console.error(`Could not start session for ${pageSlug} ${notebookSlug}`);
+                            console.debug(`Available kernels: ${Object.keys(specs)}`);
+                        });
+                        return;
+                    }
+                    console.debug(`session started for ${pageSlug}/${notebookSlug}`, sesh);
+                    const notebook = (_a = state.pages[pageSlug]) === null || _a === void 0 ? void 0 : _a.scopes[notebookSlug].notebook;
+                    notebook.attachSession(sesh);
+                    dispatch({ type: 'ADD_SESSION', payload: { pageSlug, notebookSlug, session: sesh } });
+                });
+            }
+        });
+    }, [core, config, pageSlug, notebookSlug, lock]);
+    // TODO avoid multiple dispatch?
+    const allSessionsAreStarted = (0, selectors_1.selectAreAllSessionsStarted)(state, pageSlug);
+    (0, react_1.useEffect)(() => {
+        if (!allSessionsAreStarted)
+            return;
+        dispatch({
+            type: 'SET_RENDERING_READY',
+            payload: { slug: pageSlug },
+        });
+    }, [allSessionsAreStarted]);
+    return null;
+}
+exports.SessionStarter = SessionStarter;
+function ServerMonitor({ state, dispatch, }) {
+    const { core, load, loading } = (0, thebe_react_1.useThebeLoader)();
+    const { ready, error } = (0, thebe_react_1.useThebeServer)();
+    (0, react_1.useEffect)(() => {
+        if (core || loading)
+            return;
+        load();
+    }, [core, load, loading]);
+    // When server is ready, move any waiting builds onto the start session step
+    (0, react_1.useEffect)(() => {
+        if (ready) {
+            // TODO optimize to do a single dispatch
+            Object.entries(state.builds).forEach(([slug, { status }]) => {
+                if (status === 'wait-for-server') {
+                    dispatch({ type: 'BUILD_STATUS', payload: { slug, status: 'start-session' } });
+                }
+            });
+        }
+    }, [ready, state]);
+    (0, react_1.useEffect)(() => {
+        if (!error)
+            return;
+        // TODO
+        // dispatch({ type: 'SERVER_ERROR', payload: error });
+    }, [error]);
+    return null;
+}
+exports.ServerMonitor = ServerMonitor;

package/dist/cjs/execute/provider.d.ts

@@ -0,0 +1,29 @@
+import type { Dependency } from 'myst-common';
+import { SourceFileKind } from 'myst-common';
+import type { Root } from 'mdast';
+import React from 'react';
+import type { ExecuteScopeAction } from './actions';
+import type { ExecuteScopeState, IdKeyMap } from './types';
+export interface ExecuteScopeType {
+    slug: string;
+    state: ExecuteScopeState;
+    dispatch: React.Dispatch<ExecuteScopeAction>;
+    idkmap: IdKeyMap;
+}
+export declare const ExecuteScopeContext: React.Context<ExecuteScopeType | undefined>;
+type ArticleContents = {
+    slug: string;
+    kind: SourceFileKind;
+    mdast: Root;
+    dependencies?: Dependency[];
+};
+/**
+ *  The ExecuteScopeProvider is responsible for maintaining the state of the
+ *  execution scope. It is also responsible for fetching the json for dependencies
+ *  and adding them to the sources tree.
+ */
+export declare function ExecuteScopeProvider({ children, contents, }: React.PropsWithChildren<{
+    contents: ArticleContents;
+}>): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=provider.d.ts.map

package/dist/cjs/execute/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../src/execute/provider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC;AAClC,OAAO,KAAwC,MAAM,OAAO,CAAC;AAE7D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,KAAK,EAAc,iBAAiB,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAUvE,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,iBAAiB,CAAC;IACzB,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAC;IAC7C,MAAM,EAAE,QAAQ,CAAC;CAClB;AAED,eAAO,MAAM,mBAAmB,6CAA+D,CAAC;AAEhG,KAAK,eAAe,GAAG;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,cAAc,CAAC;IACrB,KAAK,EAAE,IAAI,CAAC;IACZ,YAAY,CAAC,EAAE,UAAU,EAAE,CAAC;CAC7B,CAAC;AA8DF;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,EACnC,QAAQ,EACR,QAAQ,GACT,EAAE,KAAK,CAAC,iBAAiB,CAAC;IAAE,QAAQ,EAAE,eAAe,CAAA;CAAE,CAAC,2CAgGxD"}

package/dist/cjs/execute/provider.js

@@ -0,0 +1,126 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecuteScopeProvider = exports.ExecuteScopeContext = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const myst_common_1 = require("myst-common");
+const react_1 = __importStar(require("react"));
+const unist_util_select_1 = require("unist-util-select");
+const reducer_1 = require("./reducer");
+const selectors_1 = require("./selectors");
+const leaf_1 = require("./leaf");
+exports.ExecuteScopeContext = react_1.default.createContext(undefined);
+function useScopeNavigate({ contents: { slug, kind, mdast, dependencies }, state, dispatch, }) {
+    (0, react_1.useEffect)(() => {
+        if (state.pages[slug]) {
+            console.debug(`Jupyter: ExecuteScopeProvider - ${slug} is already in scope`);
+            return;
+        }
+        const computables = (0, unist_util_select_1.selectAll)('container > embed', mdast).map((node) => {
+            const { key, label, source } = node;
+            const output = (0, unist_util_select_1.selectAll)('output', node);
+            if (output.length === 0)
+                console.error(`embed must have exactly one output ${key}`);
+            if (output.length > 1)
+                console.warn(`embed has more than one output block ${key}}`);
+            return { embedKey: key, outputKey: output[0].key, label, source };
+        });
+        dispatch({
+            type: 'NAVIGATE',
+            payload: {
+                kind: kind,
+                slug: slug,
+                mdast: mdast,
+                dependencies: dependencies !== null && dependencies !== void 0 ? dependencies : [],
+                computables,
+            },
+        });
+    }, [slug]);
+}
+function useExecutionScopeFetcher({ slug, state, dispatch, }) {
+    (0, react_1.useEffect)(() => {
+        if (!state.builds[slug])
+            return;
+        // TODO could be moved to the leaf
+        if (state.builds[slug].status === 'pending') {
+            dispatch({ type: 'BUILD_STATUS', payload: { slug, status: 'fetching' } });
+        }
+        // TODO could be moved to the leaf
+        if (state.builds[slug].status === 'fetching') {
+            if ((0, selectors_1.selectAreAllDependenciesReady)(state, slug)) {
+                dispatch({ type: 'BUILD_STATUS', payload: { slug, status: 'build-notebooks' } });
+            }
+        }
+    }, [state.builds, state.mdast]);
+}
+/**
+ *  The ExecuteScopeProvider is responsible for maintaining the state of the
+ *  execution scope. It is also responsible for fetching the json for dependencies
+ *  and adding them to the sources tree.
+ */
+function ExecuteScopeProvider({ children, contents, }) {
+    var _a;
+    // compute incoming for first render
+    const computables = (0, unist_util_select_1.selectAll)('container > embed', contents.mdast).map((node) => {
+        const { key, label, source } = node;
+        const output = (0, unist_util_select_1.selectAll)('output', node);
+        if (output.length === 0)
+            console.error(`embed must have exactly one output ${key}`);
+        if (output.length > 1)
+            console.warn(`embed has mpre than one output block ${key}}`);
+        return { embedKey: key, outputKey: output[0].key, label, source };
+    });
+    const initialState = {
+        mdast: {
+            [contents.slug]: { root: contents.mdast },
+        },
+        pages: {
+            [contents.slug]: {
+                computable: computables.length > 0 || contents.kind === myst_common_1.SourceFileKind.Notebook,
+                kind: contents.kind,
+                slug: contents.slug,
+                dependencies: (_a = contents.dependencies) !== null && _a !== void 0 ? _a : [],
+                computables,
+                ready: false,
+                scopes: {},
+            },
+        },
+        builds: {},
+    };
+    const [state, dispatch] = (0, react_1.useReducer)(reducer_1.reducer, initialState);
+    const idkmap = (0, react_1.useRef)({});
+    useScopeNavigate({ contents, state: state, dispatch });
+    // TODO phase this out as it is based on the current slug only!
+    useExecutionScopeFetcher({ slug: contents.slug, state: state, dispatch });
+    const fetchTargets = (0, selectors_1.selectDependenciesToFetch)(state);
+    const notebookBuildTargets = (0, selectors_1.selectScopeNotebooksToBuild)(state);
+    const sessionStartTargets = (0, selectors_1.selectSessionsToStart)(state);
+    const memo = react_1.default.useMemo(() => ({ slug: contents.slug, state, dispatch, idkmap: idkmap.current }), [state, contents.slug]);
+    if (typeof window !== 'undefined') {
+        window.executeScope = memo;
+    }
+    return ((0, jsx_runtime_1.jsxs)(exports.ExecuteScopeContext.Provider, { value: memo, children: [(0, jsx_runtime_1.jsxs)("div", { className: "hidden", children: [fetchTargets.length > 0 && ((0, jsx_runtime_1.jsx)("div", { className: "p-1 pl-4", children: fetchTargets.map(({ slug, url }) => ((0, jsx_runtime_1.jsx)(leaf_1.MdastFetcher, { slug: slug, url: url, dispatch: dispatch }, `fetch-${slug}`))) })), notebookBuildTargets.length > 0 && ((0, jsx_runtime_1.jsx)("div", { className: "p-1 pl-4", children: notebookBuildTargets.map(({ pageSlug, notebookSlug }) => ((0, jsx_runtime_1.jsx)(leaf_1.NotebookBuilder, { pageSlug: pageSlug, notebookSlug: notebookSlug, idkmap: idkmap.current, state: state, dispatch: dispatch }, `build-${pageSlug}-${notebookSlug}`))) })), sessionStartTargets.length > 0 && ((0, jsx_runtime_1.jsx)("div", { className: "p-1 pl-4", children: sessionStartTargets.map(({ pageSlug, notebookSlug }) => ((0, jsx_runtime_1.jsx)(leaf_1.SessionStarter, { pageSlug: pageSlug, notebookSlug: notebookSlug, state: state, dispatch: dispatch }, `session-${pageSlug}-${notebookSlug}`))) }))] }), (0, jsx_runtime_1.jsx)(leaf_1.ServerMonitor, { state: state, dispatch: dispatch }), children] }));
+}
+exports.ExecuteScopeProvider = ExecuteScopeProvider;

package/dist/cjs/execute/reducer.d.ts

@@ -0,0 +1,4 @@
+import type { ExecuteScopeAction } from './actions';
+import type { ExecuteScopeState } from './types';
+export declare function reducer(state: ExecuteScopeState, action: ExecuteScopeAction): ExecuteScopeState;
+//# sourceMappingURL=reducer.d.ts.map

package/dist/cjs/execute/reducer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reducer.d.ts","sourceRoot":"","sources":["../../../src/execute/reducer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AASpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjD,wBAAgB,OAAO,CAAC,KAAK,EAAE,iBAAiB,EAAE,MAAM,EAAE,kBAAkB,GAAG,iBAAiB,CAuL/F"}

package/dist/cjs/execute/reducer.js

@@ -0,0 +1,136 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reducer = void 0;
+const myst_common_1 = require("myst-common");
+const actions_1 = require("./actions");
+function reducer(state, action) {
+    switch (action.type) {
+        case 'NAVIGATE': {
+            if (!(0, actions_1.isNavigatePayload)(action.payload)) {
+                console.error(action.payload);
+                throw new Error('invalid NAVIGATE payload');
+            }
+            const { kind, slug, mdast, dependencies, computables } = action.payload;
+            if (state.pages[slug])
+                return state;
+            return Object.assign(Object.assign({}, state), { mdast: Object.assign(Object.assign({}, state.mdast), { [slug]: { root: mdast } }), pages: Object.assign(Object.assign({}, state.pages), { [slug]: {
+                        kind,
+                        slug,
+                        dependencies,
+                        computables,
+                        computable: computables.length > 0 || kind === myst_common_1.SourceFileKind.Notebook,
+                        ready: false,
+                        scopes: {},
+                    } }) });
+        }
+        case 'ADD_MDAST': {
+            if (!(0, actions_1.isAddMdastPayload)(action.payload)) {
+                console.error(action.payload);
+                throw new Error('invalid ADD_MDAST payload');
+            }
+            const { slug, mdast } = action.payload;
+            if (state.mdast[slug])
+                return state;
+            return Object.assign(Object.assign({}, state), { mdast: Object.assign(Object.assign({}, state.mdast), { [slug]: { root: mdast } }) });
+        }
+        case 'REQUEST_BUILD': {
+            if (!(0, actions_1.isSlugPayload)(action.payload)) {
+                console.error(action.payload);
+                throw new Error('invalid REQUEST_BUILD payload');
+            }
+            const { slug } = action.payload;
+            if (!!state.builds[slug] && state.builds[slug].status === 'pending')
+                return state;
+            return Object.assign(Object.assign({}, state), { builds: Object.assign(Object.assign({}, state.builds), { [slug]: {
+                        status: 'pending',
+                    } }) });
+        }
+        case 'BUILD_STATUS': {
+            if (!(0, actions_1.isBuildStatusPayload)(action.payload)) {
+                console.error(action.payload);
+                throw new Error('invalid BUILD_STATUS payload');
+            }
+            const { slug } = action.payload;
+            if (!state.builds[slug]) {
+                console.error(state, action.payload);
+                throw new Error('Trying to set build status when there is no build state');
+            }
+            if (state.builds[slug].status === action.payload.status)
+                return state;
+            return Object.assign(Object.assign({}, state), { builds: Object.assign(Object.assign({}, state.builds), { [slug]: Object.assign(Object.assign({}, state.builds[slug]), { status: action.payload.status }) }) });
+        }
+        case 'CLEAR_BUILD': {
+            if (!(0, actions_1.isSlugPayload)(action.payload)) {
+                console.error(action.payload);
+                throw new Error('invalid CLEAR_BUILD payload');
+            }
+            const { slug } = action.payload;
+            if (!state.builds[slug])
+                return state;
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _a = state.builds, _b = slug, _ = _a[_b], builds = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+            return Object.assign(Object.assign({}, state), { builds });
+        }
+        case 'SET_RENDERING_READY': {
+            if (!(0, actions_1.isSlugPayload)(action.payload)) {
+                console.error(action.payload);
+                throw new Error('invalid SET_READY payload');
+            }
+            const { slug } = action.payload;
+            if (state.pages[slug].ready)
+                return state;
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _c = state.builds, _d = slug, _ = _c[_d], builds = __rest(_c, [typeof _d === "symbol" ? _d : _d + ""]);
+            const newState = Object.assign(Object.assign({}, state), { builds, pages: Object.assign(Object.assign({}, state.pages), { [slug]: Object.assign(Object.assign({}, state.pages[slug]), { ready: true }) }) });
+            return newState;
+        }
+        case 'ADD_NOTEBOOK': {
+            if (!(0, actions_1.isAddNotebookPayload)(action.payload)) {
+                console.error(action.payload);
+                throw new Error('invalid ADD_NOTEBOOK payload');
+            }
+            const { pageSlug, notebookSlug, notebook, rendermime } = action.payload;
+            if (!state.pages[pageSlug]) {
+                console.error(state, action.payload);
+                throw new Error('Trying to add notebook when there is no rendering state');
+            }
+            if (state.pages[pageSlug].scopes[notebookSlug]) {
+                console.warn('Trying to add notebook scope when rendering already has one', action.payload);
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { pages: Object.assign(Object.assign({}, state.pages), { [pageSlug]: Object.assign(Object.assign({}, state.pages[pageSlug]), { scopes: Object.assign(Object.assign({}, state.pages[pageSlug].scopes), { [notebookSlug]: {
+                                notebook,
+                                rendermime,
+                            } }) }) }) });
+        }
+        case 'ADD_SESSION': {
+            if (!(0, actions_1.isAddSessionPayload)(action.payload)) {
+                console.error(action.payload);
+                throw new Error('invalid ADD_SESSION payload');
+            }
+            const { pageSlug, notebookSlug, session } = action.payload;
+            if (!state.pages[pageSlug]) {
+                console.error(state, action.payload);
+                throw new Error('Trying to add session when there is no rendering state');
+            }
+            if (state.pages[pageSlug].scopes[notebookSlug].session) {
+                console.warn('Trying to add session scope when rendering already has one', action.payload);
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { pages: Object.assign(Object.assign({}, state.pages), { [pageSlug]: Object.assign(Object.assign({}, state.pages[pageSlug]), { scopes: Object.assign(Object.assign({}, state.pages[pageSlug].scopes), { [notebookSlug]: Object.assign(Object.assign({}, state.pages[pageSlug].scopes[notebookSlug]), { session }) }) }) }) });
+        }
+    }
+    return state;
+}
+exports.reducer = reducer;

package/dist/cjs/execute/selectors.d.ts

@@ -0,0 +1,22 @@
+import type { BuildStatus, ExecuteScopeState } from './types';
+export declare function selectIsComputable(state: ExecuteScopeState, slug: string): boolean;
+export declare function selectAreExecutionScopesReady(state: ExecuteScopeState, slug: string): boolean;
+export declare function selectAreExecutionScopesBuilding(state: ExecuteScopeState, slug: string): boolean;
+export declare function selectExecutionScopeStatus(state: ExecuteScopeState, slug: string): BuildStatus | "ready";
+export declare function selectDependenciesToFetch(state: ExecuteScopeState): {
+    slug: string;
+    url: string;
+}[];
+export declare const selectScopeNotebooksToBuild: (state: ExecuteScopeState) => {
+    pageSlug: string;
+    notebookSlug: string;
+}[];
+export declare const selectSessionsToStart: (state: ExecuteScopeState) => {
+    pageSlug: string;
+    notebookSlug: string;
+}[];
+export declare function selectAreAllDependenciesReady(state: ExecuteScopeState, slug: string): boolean;
+export declare function selectAreAllNotebookScopesBuilt(state: ExecuteScopeState, slug: string): boolean;
+export declare function selectAreAllSessionsStarted(state: ExecuteScopeState, slug: string): boolean;
+export declare function selectNotebookCellIds(state: ExecuteScopeState, pageSlug: string, notebookSlug: string): string[];
+//# sourceMappingURL=selectors.d.ts.map

package/dist/cjs/execute/selectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.d.ts","sourceRoot":"","sources":["../../../src/execute/selectors.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAE9D,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,WAExE;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,WAEnF;AAED,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,WAEtF;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,yBAEhF;AAQD,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,iBAAiB;UAKpD,MAAM;SACP,MAAM;IAclB;AAsBD,eAAO,MAAM,2BAA2B,UAlBvB,iBAAiB,KAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,EAkBS,CAAC;AACzF,eAAO,MAAM,qBAAqB,UAnBjB,iBAAiB,KAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,EAmBC,CAAC;AAEjF,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,WAEnF;AAED,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,WAGrF;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,WAIjF;AAED,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,iBAAiB,EACxB,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,YAGrB"}

package/dist/cjs/execute/selectors.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectNotebookCellIds = exports.selectAreAllSessionsStarted = exports.selectAreAllNotebookScopesBuilt = exports.selectAreAllDependenciesReady = exports.selectSessionsToStart = exports.selectScopeNotebooksToBuild = exports.selectDependenciesToFetch = exports.selectExecutionScopeStatus = exports.selectAreExecutionScopesBuilding = exports.selectAreExecutionScopesReady = exports.selectIsComputable = void 0;
+const myst_common_1 = require("myst-common");
+function selectIsComputable(state, slug) {
+    var _a, _b;
+    return (_b = (_a = state.pages[slug]) === null || _a === void 0 ? void 0 : _a.computable) !== null && _b !== void 0 ? _b : false;
+}
+exports.selectIsComputable = selectIsComputable;
+function selectAreExecutionScopesReady(state, slug) {
+    var _a;
+    return (_a = state.pages[slug]) === null || _a === void 0 ? void 0 : _a.ready;
+}
+exports.selectAreExecutionScopesReady = selectAreExecutionScopesReady;
+function selectAreExecutionScopesBuilding(state, slug) {
+    var _a;
+    return !((_a = state.pages[slug]) === null || _a === void 0 ? void 0 : _a.ready) && !!state.builds[slug];
+}
+exports.selectAreExecutionScopesBuilding = selectAreExecutionScopesBuilding;
+function selectExecutionScopeStatus(state, slug) {
+    var _a, _b, _c;
+    return ((_a = state.pages[slug]) === null || _a === void 0 ? void 0 : _a.ready) ? 'ready' : (_c = (_b = state.builds[slug]) === null || _b === void 0 ? void 0 : _b.status) !== null && _c !== void 0 ? _c : 'unknown';
+}
+exports.selectExecutionScopeStatus = selectExecutionScopeStatus;
+//
+// The following teo functions are ripe for generaizing but also it would be good to
+// see if we can memoize them, potentially with reselect.
+//
+// TODO Memoize?
+function selectDependenciesToFetch(state) {
+    return Object.entries(state.builds)
+        .filter(([, { status }]) => status === 'fetching')
+        .reduce((targets, [slug]) => [
+        ...targets,
+        ...state.pages[slug].dependencies
+            .filter((d) => { var _a; return !state.mdast[(_a = d.slug) !== null && _a !== void 0 ? _a : d.url]; })
+            .map((d) => {
+            var _a;
+            return ({
+                slug: (_a = d.slug) !== null && _a !== void 0 ? _a : d.url,
+                url: d.url,
+            });
+        }),
+    ], []);
+}
+exports.selectDependenciesToFetch = selectDependenciesToFetch;
+// // TODO Memoize?
+function makeSelectScopeEventStatus(statusName) {
+    return (state) => {
+        return Object.entries(state.builds)
+            .filter(([, { status }]) => status === statusName)
+            .reduce((all, [slug]) => {
+            const targets = [];
+            if (state.pages[slug].kind === myst_common_1.SourceFileKind.Notebook)
+                targets.push({ pageSlug: slug, notebookSlug: slug });
+            targets.push(...state.pages[slug].dependencies.map((d) => {
+                var _a;
+                return ({
+                    pageSlug: slug,
+                    notebookSlug: (_a = d.slug) !== null && _a !== void 0 ? _a : d.url,
+                });
+            }));
+            return [...all, ...targets];
+        }, []);
+    };
+}
+exports.selectScopeNotebooksToBuild = makeSelectScopeEventStatus('build-notebooks');
+exports.selectSessionsToStart = makeSelectScopeEventStatus('start-session');
+function selectAreAllDependenciesReady(state, slug) {
+    var _a;
+    return (_a = state.pages[slug]) === null || _a === void 0 ? void 0 : _a.dependencies.every((dep) => { var _a; return !!state.mdast[(_a = dep.slug) !== null && _a !== void 0 ? _a : dep.url]; });
+}
+exports.selectAreAllDependenciesReady = selectAreAllDependenciesReady;
+function selectAreAllNotebookScopesBuilt(state, slug) {
+    const rendering = state.pages[slug];
+    return rendering === null || rendering === void 0 ? void 0 : rendering.dependencies.every((dep) => { var _a; return !!rendering.scopes[(_a = dep.slug) !== null && _a !== void 0 ? _a : dep.url]; });
+}
+exports.selectAreAllNotebookScopesBuilt = selectAreAllNotebookScopesBuilt;
+function selectAreAllSessionsStarted(state, slug) {
+    const rendering = state.pages[slug];
+    // TODO is this working??
+    return rendering === null || rendering === void 0 ? void 0 : rendering.dependencies.every((dep) => { var _a, _b; return !!((_b = rendering.scopes[(_a = dep.slug) !== null && _a !== void 0 ? _a : dep.url]) === null || _b === void 0 ? void 0 : _b.session); });
+}
+exports.selectAreAllSessionsStarted = selectAreAllSessionsStarted;
+function selectNotebookCellIds(state, pageSlug, notebookSlug) {
+    var _a, _b, _c, _d;
+    return (_d = (_c = (_b = (_a = state.pages[pageSlug]) === null || _a === void 0 ? void 0 : _a.scopes[notebookSlug]) === null || _b === void 0 ? void 0 : _b.notebook) === null || _c === void 0 ? void 0 : _c.cells.map(({ id }) => id)) !== null && _d !== void 0 ? _d : [];
+}
+exports.selectNotebookCellIds = selectNotebookCellIds;

package/dist/cjs/execute/types.d.ts

@@ -0,0 +1,49 @@
+import type { Root } from 'mdast';
+import type { SourceFileKind, Dependency } from 'myst-common';
+import type { IRenderMimeRegistry, ThebeNotebook, ThebeSession } from 'thebe-core';
+export type BuildStatus = 'pending' | 'fetching' | 'build-notebooks' | 'wait-for-server' | 'start-session' | 'error';
+export type IdOrKey = string;
+export type CellId = string;
+export type IdKeyMapTarget = {
+    pageSlug: string;
+    notebookSlug: string;
+    cellId: CellId;
+};
+export type IdKeyMap = Record<IdOrKey, IdKeyMapTarget>;
+export interface ExecuteScopeState {
+    mdast: {
+        [slug: string]: {
+            root: Root;
+        };
+    };
+    pages: {
+        [pageSlug: string]: {
+            slug: string;
+            kind: SourceFileKind;
+            computable: boolean;
+            dependencies: Dependency[];
+            computables: Computable[];
+            ready: boolean;
+            scopes: {
+                [notebookSlug: string]: ExecutionScope;
+            };
+        };
+    };
+    builds: {
+        [pageSlug: string]: {
+            status: BuildStatus;
+        };
+    };
+}
+export interface ExecutionScope {
+    rendermime: IRenderMimeRegistry;
+    notebook: ThebeNotebook;
+    session?: ThebeSession;
+}
+export interface Computable {
+    embedKey: string;
+    outputKey: string;
+    label: string;
+    source: Dependency;
+}
+//# sourceMappingURL=types.d.ts.map