@curvenote/theme-ui 1.0.1

package/dist/components/providers/connect.js

@@ -0,0 +1,208 @@
+/**
+ * @param serviceUrl (string) e.g. https://spyglass.hhmi.2i2c.cloud, https://sproxy.curvenote.dev;
+ * @param serviceTitle (string) e.g. 'Spyglass', 'Curvenote';
+ * @returns
+ */
+export const jupyterHubStreamingConnectFnFactory = ({ serviceUrl, clientProxyUrl, serviceTitle, gitPullerTargetPath, }) => {
+    return async function connectToJupyterHubViaStream(server) {
+        console.debug('Connecting to JupyterHub...');
+        console.debug('server.config:', server.config);
+        server.config.events.trigger('status', {
+            id: server.id,
+            subject: 'server',
+            message: `Connecting to JupyterHub at ${serviceTitle ?? serviceUrl}...`,
+        });
+        server.config.events.trigger('status', {
+            subject: 'server',
+            id: server.id,
+            message: 'Establishing connection stream...',
+        });
+        try {
+            const response = await fetch('/hub/stream', {
+                method: 'POST',
+                body: JSON.stringify({ serviceUrl, gitPullerTargetPath }),
+            });
+            if (!response.ok) {
+                throw new Error(`Could not connect to stream: ${response.status} ${response.statusText}`);
+            }
+            if (!response.body) {
+                throw new Error('ReadableStream not supported or response has no body.');
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let done = false;
+            const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+            let payload;
+            const messageDone = false;
+            let waited = 0;
+            let streamError;
+            while (!done) {
+                await delay(100); // slow down the loop and avoid blocking the thread
+                let chunk;
+                try {
+                    chunk = await reader.read();
+                }
+                catch (e) {
+                    streamError = `Stream error: ${e}`;
+                    console.error(streamError);
+                    break;
+                }
+                const { value, done: streamDone } = chunk;
+                done = streamDone && messageDone;
+                if (streamDone && !messageDone) {
+                    // we've reached the end of the stream, but we haven't received the final message
+                    // wait for a bit (each loop has a 100ms delay) and check again
+                    waited++;
+                    if (waited > 20)
+                        break;
+                }
+                if (value) {
+                    // eslint-disable-next-line @typescript-eslint/no-shadow
+                    const chunk = decoder.decode(value, { stream: true });
+                    // assume that we might have multiple JSON lines in a single chunk
+                    const lines = chunk.split('\n').filter((l) => l.length > 0);
+                    const data = lines.map((l) => JSON.parse(l));
+                    for (const item of data) {
+                        if (item.error) {
+                            server.config.events.trigger('error', {
+                                subject: 'error',
+                                id: server.id,
+                                message: item.message,
+                            });
+                        }
+                        else {
+                            server.config.events.trigger('status', {
+                                subject: 'server',
+                                id: server.id,
+                                message: item.message,
+                            });
+                            if (item.done && item.payload) {
+                                payload = item.payload;
+                                done = true;
+                            }
+                        }
+                    }
+                }
+            }
+            if (!payload) {
+                const message = streamError
+                    ? `final payload not received (${streamError})`
+                    : 'final payload not received';
+                throw new Error(message);
+            }
+            // ask server to set cookies for session persistence
+            const resp = await fetch('/hub/persist', {
+                method: 'POST',
+                body: JSON.stringify({ stash: payload.stash }),
+            });
+            if (!resp.ok) {
+                server.config.events.trigger('status', {
+                    subject: 'warning',
+                    id: server.id,
+                    message: 'Failed to persist session',
+                });
+                console.warn('Failed to persist session:', resp.statusText);
+                console.warn('Future hub connections will create new users');
+            }
+            // finish up launch sequence
+            server.config.serverSettings = {
+                baseUrl: payload.baseUrl,
+                token: payload.token,
+                appendToken: true,
+                wsUrl: `wss://${payload.baseUrl.split('://')[1]}`,
+            };
+            const noProxyBaseUrl = server.config.serverSettings.baseUrl;
+            if (clientProxyUrl) {
+                console.debug('Using client proxy:', clientProxyUrl);
+                const proxyUrl = new URL(clientProxyUrl);
+                const baseUrl = new URL(payload.baseUrl);
+                baseUrl.protocol = proxyUrl.protocol;
+                baseUrl.hostname = proxyUrl.hostname;
+                baseUrl.port = proxyUrl.port;
+                server.config.serverSettings.baseUrl = baseUrl.toString();
+            }
+            await server.connectToJupyterServer();
+            if (noProxyBaseUrl !== server.config.serverSettings.baseUrl) {
+                server.userServerUrl = `${noProxyBaseUrl}?token=${server.config.serverSettings.token}`;
+            }
+        }
+        catch (error) {
+            server.config.events.trigger('error', {
+                subject: 'server',
+                id: server.id,
+                message: `Failed to connect: ${error.message}`,
+            });
+            // TODO stop spinners & reset to a startable position?
+        }
+    };
+};
+/**
+ * @param serviceUrl (string) e.g. https://spyglass.hhmi.2i2c.cloud, https://sproxy.curvenote.dev;
+ * @param serviceTitle (string) e.g. 'Spyglass', 'Curvenote';
+ * @returns
+ */
+export const jupyterHubConnectFnFactory = ({ serviceUrl, clientProxyUrl, serviceTitle, gitPullerTargetPath, }) => {
+    return async function connectToJupyterHub(server) {
+        console.debug('Connecting to JupyterHub...');
+        console.debug('server.config:', server.config);
+        server.config.events.trigger('status', {
+            id: server.id,
+            subject: 'server',
+            message: 'Connecting to JupyterHub...',
+        });
+        server.config.events.trigger('status', {
+            id: server.id,
+            subject: 'server',
+            message: `Connecting to JupyterHub at ${serviceTitle ?? serviceUrl}...`,
+        });
+        try {
+            const response = await fetch('/hub/launch', {
+                method: 'POST',
+                body: JSON.stringify({ serviceUrl, gitPullerTargetPath }),
+            });
+            if (!response.ok) {
+                throw new Error(`${response.status} ${response.statusText}`);
+            }
+            server.config.events.trigger('status', {
+                id: server.id,
+                subject: 'server',
+                message: `Jupyter server started...`,
+            });
+            // process final response data
+            const data = await response.json();
+            console.debug('User server started on JupyterHub:', server.config.serverSettings);
+            server.config.events.trigger('status', {
+                id: server.id,
+                subject: 'server',
+                message: `Connecting to ${data.baseUrl}...`,
+            });
+            server.config.serverSettings = {
+                baseUrl: data.baseUrl,
+                token: data.token,
+                appendToken: true,
+                wsUrl: `wss://${data.baseUrl.split('://')[1]}`,
+            };
+            const noProxyBaseUrl = server.config.serverSettings.baseUrl;
+            if (clientProxyUrl) {
+                console.debug('Using client proxy:', clientProxyUrl);
+                const proxyUrl = new URL(clientProxyUrl);
+                const baseUrl = new URL(data.baseUrl);
+                baseUrl.protocol = proxyUrl.protocol;
+                baseUrl.hostname = proxyUrl.hostname;
+                baseUrl.port = proxyUrl.port;
+                server.config.serverSettings.baseUrl = baseUrl.toString();
+            }
+            await server.connectToJupyterServer();
+            if (noProxyBaseUrl !== server.config.serverSettings.baseUrl) {
+                server.userServerUrl = `${noProxyBaseUrl}?token=${server.config.serverSettings.token}`;
+            }
+        }
+        catch (error) {
+            server.config.events.trigger('error', {
+                id: server.id,
+                subject: 'server',
+                message: `Failed to connect: ${error.message}`,
+            });
+        }
+    };
+};

package/dist/components/providers/curvenote-providers.d.ts

@@ -0,0 +1,52 @@
+import type { SiteDTO, JournalThemeConfig, ArticleThemeConfig } from '@curvenote/common';
+import { type ExtendedCoreOptions } from '@curvenote/bridge-jupyter';
+import { type SiteManifest } from 'myst-config';
+import { type DesignPresetName } from './design';
+type ManifestProject = Required<SiteManifest>['projects'][0];
+/**
+ * merge the incoming dynamic site config with the hard coded theme config
+ * this allows a particular site to configure the theme by overriding the built
+ * in theme config
+ * @returns
+ */
+export declare function makeSiteTheme(site: SiteDTO): import("./types").JournalTheme;
+/**
+ * Based on the article SubmissionKind, resolve the theme config options for that kind, if specified,
+ * pulling up defaults from the base theme.config.articles object and theme.config.jupyter object as needed
+ *
+ * @param kindName
+ * @param config
+ * @returns - a resolved set of options that can be applied to the article without the need for further fallback logic
+ */
+export declare function resolveArticleConfigOptions(kindName: string, config: JournalThemeConfig): ArticleThemeConfig;
+export declare function resolveThemeAndProjectComputeOptions(resolvedArticleConfig: ArticleThemeConfig, project: Required<SiteManifest>['projects'][0]): ArticleThemeConfig;
+type RepoProviderSpec = any;
+export declare function getCustomRepoProviders(names: string[]): RepoProviderSpec[];
+/**
+ * Get the Jupyter configuration based on a combination of the theme's
+ * features and overrides, and the site manifest
+ */
+export declare function getAdditionalThemeComputeConfig(resolvedConfig: ArticleThemeConfig, mecaUrl: string | null, respectLocalServerSettings?: boolean): {
+    optionOverrideFn?: undefined;
+    customRepoProviders?: undefined;
+    customConnectFn?: undefined;
+    mecaUrl?: undefined;
+    errors?: undefined;
+} | {
+    optionOverrideFn: (opts?: ExtendedCoreOptions) => ExtendedCoreOptions | undefined;
+    customRepoProviders: any[] | undefined;
+    customConnectFn: ((server: import("thebe-core").ThebeServer) => Promise<void>) | undefined;
+    mecaUrl: string | null;
+    errors: {
+        noMecaBundle: boolean | undefined;
+    };
+};
+export declare function getFullyQualifiedUrlToMECABundle(project: ManifestProject): string | null;
+export declare function CurvenoteProviders({ children, submissionKind, designPreset, mode, }: {
+    children: React.ReactNode;
+    submissionKind: string;
+    designPreset?: DesignPresetName;
+    mode?: 'development' | 'production';
+}): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=curvenote-providers.d.ts.map

package/dist/components/providers/curvenote-providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curvenote-providers.d.ts","sourceRoot":"","sources":["../../../src/components/providers/curvenote-providers.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,kBAAkB,EAClB,kBAAkB,EAEnB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAGL,KAAK,mBAAmB,EACzB,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAShD,OAAO,EAAkC,KAAK,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAIjF,KAAK,eAAe,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;AAE7D;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,kCAK1C;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,kBAAkB,GACzB,kBAAkB,CAwBpB;AAED,wBAAgB,oCAAoC,CAClD,qBAAqB,EAAE,kBAAkB,EACzC,OAAO,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,sBAqC/C;AAED,KAAK,gBAAgB,GAAG,GAAG,CAAC;AA2B5B,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,gBAAgB,EAAE,CAE1E;AAED;;;GAGG;AACH,wBAAgB,+BAA+B,CAC7C,cAAc,EAAE,kBAAkB,EAClC,OAAO,EAAE,MAAM,GAAG,IAAI,EACtB,0BAA0B,CAAC,EAAE,OAAO;;;;;;;8BAKH,mBAAmB;;;;;;;EAwDrD;AAQD,wBAAgB,gCAAgC,CAAC,OAAO,EAAE,eAAe,GAAG,MAAM,GAAG,IAAI,CAIxF;AAED,wBAAgB,kBAAkB,CAAC,EACjC,QAAQ,EACR,cAA6B,EAC7B,YAAqB,EACrB,IAAmB,GACpB,EAAE;IACD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,gBAAgB,CAAC;IAChC,IAAI,CAAC,EAAE,aAAa,GAAG,YAAY,CAAC;CACrC,2CAmDA"}

package/dist/components/providers/curvenote-providers.js

@@ -0,0 +1,199 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ComputeOptionsProvider, ConnectionStatusTray, } from '@curvenote/bridge-jupyter';
+import { useProjectManifest, useReferences, useSiteManifest } from '@myst-theme/providers';
+import {} from 'myst-config';
+import { ComputeProvider } from './compute';
+import { checkHasMECAExport } from '../../lib';
+import { useImages } from './lightbox-provider';
+import merge from 'lodash.merge';
+import { jupyterHubStreamingConnectFnFactory } from './connect';
+import { defaultTheme, usePlatformTheme } from './platform-providers';
+import { LightboxContainer } from '../ui/lightbox-container';
+import { DESIGN_PRESETS, DesignProvider } from './design';
+import { useIsIndexPage, usePage } from './page-providers';
+/**
+ * merge the incoming dynamic site config with the hard coded theme config
+ * this allows a particular site to configure the theme by overriding the built
+ * in theme config
+ * @returns
+ */
+export function makeSiteTheme(site) {
+    if (!site.theme_config)
+        return defaultTheme;
+    // prune any keys that we don't want to allow configuration of
+    const { name, custom, ...configurable } = site.theme_config;
+    return { ...defaultTheme, config: merge({}, defaultTheme.config, configurable) };
+}
+/**
+ * Based on the article SubmissionKind, resolve the theme config options for that kind, if specified,
+ * pulling up defaults from the base theme.config.articles object and theme.config.jupyter object as needed
+ *
+ * @param kindName
+ * @param config
+ * @returns - a resolved set of options that can be applied to the article without the need for further fallback logic
+ */
+export function resolveArticleConfigOptions(kindName, config) {
+    // get jupyter settings for this kind
+    const { jupyter: byKindJupyter, ...options } = config.articles?.byKind?.[kindName] ?? config.articles?.byKind?.[kindName?.toLowerCase()] ?? {};
+    // get the jupyter default settings for articles
+    const { byKind, jupyter: articleJupyter, ...defaults } = config.articles ?? {};
+    const articleConfig = {
+        ...defaults,
+        ...options,
+    };
+    const jupyter = {
+        ...config.jupyter,
+        ...articleJupyter,
+        ...byKindJupyter,
+    };
+    if (Object.keys(jupyter).length > 0) {
+        articleConfig.jupyter = jupyter;
+    }
+    return articleConfig;
+}
+export function resolveThemeAndProjectComputeOptions(resolvedArticleConfig, project) {
+    const themeEnablesCompute = !!resolvedArticleConfig.jupyter && resolvedArticleConfig.jupyter.enable !== false;
+    const projectJupyterConfig = project.thebe ?? project.jupyter; // future proofing
+    const projectEnablesCompute = projectJupyterConfig !== undefined && projectJupyterConfig !== false;
+    if (!themeEnablesCompute || !projectEnablesCompute) {
+        resolvedArticleConfig.jupyter = { ...resolvedArticleConfig.jupyter, enable: false };
+    }
+    if (resolvedArticleConfig.jupyter?.mecaBundle && !checkHasMECAExport(project)) {
+        resolvedArticleConfig.jupyter = { ...resolvedArticleConfig.jupyter, enable: false };
+        if (typeof window !== 'undefined') {
+            console.warn('⚠️ Compute Disabled - MECA bundle not found but is required. Please add a MECA export to your project to build the MECA bundle and enable compute');
+        }
+    }
+    if (!resolvedArticleConfig.jupyter?.mecaBundle &&
+        !resolvedArticleConfig.jupyter?.dedicatedHub &&
+        resolvedArticleConfig.jupyter?.binderUrlOverride &&
+        !project.github) {
+        resolvedArticleConfig.jupyter = { ...resolvedArticleConfig.jupyter, enable: false };
+        if (typeof window !== 'undefined') {
+            console.warn('⚠️ Compute Disabled - Binder URL override requires a GitHub repository to be set up. No github key found in project.');
+        }
+    }
+    return resolvedArticleConfig;
+}
+const customRepoProviders = {
+    meca: {
+        name: 'meca',
+        makeUrls: (config) => {
+            if (!config.binder.repo)
+                throw Error('repo is required for meca provider');
+            const binderUrl = config.binder.binderUrl?.replace(/(\/?$)/g, '');
+            // default to a random session key if we cannot resolve the repo url
+            let storageKey = `thebe-meca-${Math.floor(Math.random() * 0xffffff)
+                .toString(16)
+                .padEnd(6, '0')}`;
+            if (config.binder.repo) {
+                const repoUrl = new URL(config.binder.repo);
+                storageKey = `thebe-meca-${binderUrl}/build/meca/${repoUrl.origin + repoUrl.pathname}`;
+            }
+            return {
+                build: `${binderUrl}/build/meca/${encodeURIComponent(config.binder.repo ?? '')}`,
+                launch: `${binderUrl}/v2/meca/${encodeURIComponent(config.binder.repo ?? '')}`,
+                storageKey,
+            };
+        },
+    },
+};
+export function getCustomRepoProviders(names) {
+    return names.map((name) => customRepoProviders[name]);
+}
+/**
+ * Get the Jupyter configuration based on a combination of the theme's
+ * features and overrides, and the site manifest
+ */
+export function getAdditionalThemeComputeConfig(resolvedConfig, mecaUrl, respectLocalServerSettings) {
+    const jupyter = resolvedConfig.jupyter;
+    if (!jupyter || jupyter.enable === false)
+        return {};
+    const optionOverrideFn = (opts) => {
+        if (!jupyter || jupyter.enable === false)
+            return undefined;
+        if (opts?.serverSettings && respectLocalServerSettings)
+            return opts;
+        const { useJupyterLite, ...rest } = opts ?? {};
+        const enableJupyterLite = jupyter.allowLite && useJupyterLite;
+        const useBinder = !enableJupyterLite && jupyter.dedicatedHub === undefined;
+        const mecaWillBeUsed = jupyter.mecaBundle && mecaUrl;
+        if (mecaWillBeUsed) {
+            console.log('Using MECA bundle', mecaUrl);
+        }
+        const overrides = {
+            ...rest,
+            useJupyterLite: enableJupyterLite,
+            useBinder,
+            binderOptions: {
+                ...opts?.binderOptions,
+                binderUrl: jupyter.binderUrlOverride ?? opts?.binderOptions?.binderUrl,
+                repoProvider: mecaWillBeUsed ? 'meca' : opts?.binderOptions?.repoProvider,
+                repo: mecaWillBeUsed ? mecaUrl : opts?.binderOptions?.repo,
+                ref: mecaWillBeUsed ? undefined : opts?.binderOptions?.ref,
+            },
+            savedSessionOptions: {
+                enabled: true,
+                storagePrefix: 'curvenote-jupyter-',
+            },
+        };
+        return overrides;
+    };
+    const myCustomRepoProviders = jupyter?.mecaBundle ? getCustomRepoProviders(['meca']) : undefined;
+    // TODO remove after types package release
+    const hubOptions = jupyter?.dedicatedHub;
+    const customConnectFn = jupyter?.dedicatedHub
+        ? jupyterHubStreamingConnectFnFactory({
+            serviceUrl: hubOptions.url,
+            serviceTitle: hubOptions.title,
+            clientProxyUrl: hubOptions.clientProxyUrl,
+            gitPullerTargetPath: hubOptions.gitPullerTargetPath,
+        })
+        : undefined;
+    return {
+        optionOverrideFn,
+        customRepoProviders: myCustomRepoProviders,
+        customConnectFn,
+        mecaUrl,
+        errors: {
+            noMecaBundle: mecaUrl == null && jupyter?.mecaBundle,
+        },
+    };
+}
+export function getFullyQualifiedUrlToMECABundle(project) {
+    if (!project?.exports)
+        return null;
+    const meca = (project?.exports).find((e) => e.format === 'meca');
+    return meca?.url ?? null;
+}
+export function CurvenoteProviders({ children, submissionKind = 'SITE_PAGES', designPreset = 'book', mode = 'production', }) {
+    const site = useSiteManifest();
+    const project = useProjectManifest();
+    const page = usePage();
+    const isIndex = useIsIndexPage();
+    const theme = usePlatformTheme();
+    const config = resolveArticleConfigOptions(submissionKind, theme.config);
+    const references = useReferences();
+    const articleConfig = resolveThemeAndProjectComputeOptions(config, project);
+    const mecaUrl = getFullyQualifiedUrlToMECABundle(project);
+    const respectLocalServerSettings = mode === 'development';
+    const resolved = {
+        ...articleConfig,
+        ...getAdditionalThemeComputeConfig(articleConfig, mecaUrl, respectLocalServerSettings),
+    };
+    const images = useImages({ mdast: references?.article });
+    const enable = articleConfig?.jupyter?.enable !== false;
+    const features = {
+        notebookCompute: (enable && resolved?.jupyter?.notebookCompute) ?? false,
+        figureCompute: (enable && resolved?.jupyter?.figureCompute) ?? false,
+        launchBinder: (enable && resolved?.jupyter?.launchBinder) ?? false,
+        openInServerRoot: (enable && resolved?.jupyter?.openInServerRoot) ?? false,
+        openInServerTargetPath: (enable && resolved?.jupyter?.openInServerTargetPath) ?? undefined,
+    };
+    const baseDesignOptions = site?.options;
+    const articleDesignOptions = page?.frontmatter?.site;
+    const designPresetOptions = DESIGN_PRESETS[designPreset];
+    const presetBase = designPresetOptions?.base;
+    const presetPage = isIndex ? designPresetOptions?.index : designPresetOptions?.page;
+    return (_jsx(DesignProvider, { designs: [presetBase, presetPage, baseDesignOptions, articleDesignOptions], children: _jsx(ComputeOptionsProvider, { features: features, optionOverrideFn: resolved?.optionOverrideFn, customRepoProviders: resolved?.customRepoProviders, customConnectFn: resolved?.customConnectFn, children: _jsxs(ComputeProvider, { article: page, children: [_jsx(LightboxContainer, { imageList: images, children: children }), _jsx(ConnectionStatusTray, {})] }) }) }));
+}

package/dist/components/providers/design.d.ts

@@ -0,0 +1,39 @@
+import React from 'react';
+export type Image = {
+    url: string;
+};
+export type DesignOptions = {
+    preset?: 'article' | 'book';
+    logo?: Image;
+    logo_dark?: Image;
+    favicon?: Image;
+    layout?: 'article' | 'app';
+    frontmatter_layout?: 'article' | 'blog';
+    hide_outline?: boolean;
+    hide_top_nav?: boolean;
+    hide_toc?: boolean;
+    hide_footer_links?: boolean;
+    hide_backmatter?: boolean;
+    hide_title_block?: boolean;
+    hide_abbreviation_list?: boolean;
+    hide_bibliography?: boolean;
+    hide_license_description?: boolean;
+    hide_footnotes?: boolean;
+    hide_search?: boolean;
+    hide_downloads?: boolean;
+    disable_search?: boolean;
+    outline_maxdepth?: number;
+};
+export type DesignPresetName = 'landing' | 'single_article' | 'single_article_supporting' | 'book' | string;
+export type PresetConfig = {
+    base?: DesignOptions;
+    index?: DesignOptions;
+    page?: DesignOptions;
+};
+export declare const DESIGN_PRESETS: Record<DesignPresetName, PresetConfig>;
+export declare function DesignProvider({ children, designs, }: {
+    children: React.ReactNode;
+    designs: (Record<string, any> | undefined)[];
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useDesign(): DesignOptions;
+//# sourceMappingURL=design.d.ts.map

package/dist/components/providers/design.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"design.d.ts","sourceRoot":"","sources":["../../../src/components/providers/design.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAoC,MAAM,OAAO,CAAC;AAEzD,MAAM,MAAM,KAAK,GAAG;IAClB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC;IAC5B,IAAI,CAAC,EAAE,KAAK,CAAC;IACb,SAAS,CAAC,EAAE,KAAK,CAAC;IAClB,OAAO,CAAC,EAAE,KAAK,CAAC;IAChB,MAAM,CAAC,EAAE,SAAS,GAAG,KAAK,CAAC;IAC3B,kBAAkB,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC;IACxC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,gBAAgB,GACxB,SAAS,GACT,gBAAgB,GAChB,2BAA2B,GAC3B,MAAM,GACN,MAAM,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,CAAC,EAAE,aAAa,CAAC;IACrB,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,IAAI,CAAC,EAAE,aAAa,CAAC;CACtB,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,gBAAgB,EAAE,YAAY,CAsCjE,CAAC;AAIF,wBAAgB,cAAc,CAAC,EAC7B,QAAQ,EACR,OAAO,GACR,EAAE;IACD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,OAAO,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC,EAAE,CAAC;CAC9C,2CAIA;AAED,wBAAgB,SAAS,IAAI,aAAa,CAGzC"}

package/dist/components/providers/design.js

@@ -0,0 +1,50 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React, { createContext, useContext } from 'react';
+export const DESIGN_PRESETS = {
+    landing: {
+        index: {
+            layout: 'article',
+            hide_outline: true,
+            hide_title_block: true,
+            hide_search: true,
+            hide_downloads: true,
+        },
+        page: {
+            layout: 'article',
+        },
+    },
+    single_article: {
+        index: {
+            layout: 'article',
+            hide_search: true,
+        },
+        page: {
+            layout: 'app',
+        },
+    },
+    single_article_supporting: {
+        base: {
+            layout: 'app',
+            hide_search: true,
+        },
+        index: {},
+        page: {
+            hide_license_description: true,
+        },
+    },
+    book: {
+        base: {
+            layout: 'app',
+            hide_search: true,
+        },
+    },
+};
+const DesignContext = createContext(undefined);
+export function DesignProvider({ children, designs, }) {
+    const designOptions = designs.filter(Boolean).reduce((acc, curr) => ({ ...acc, ...curr }), {});
+    return _jsx(DesignContext.Provider, { value: designOptions, children: children });
+}
+export function useDesign() {
+    const contextDesign = useContext(DesignContext);
+    return contextDesign ?? {};
+}

package/dist/components/providers/index.d.ts

@@ -0,0 +1,10 @@
+export { ComputeProvider } from './compute';
+export { CurvenoteProviders } from './curvenote-providers';
+export { MystProviders } from './myst-providers';
+export * from './ping-boundary';
+export * from './platform-providers';
+export * from './types';
+export { LightboxProvider, useLightbox, type LightboxImageData, useImages, } from './lightbox-provider';
+export { PageProviders, useIsIndexPage, usePage } from './page-providers';
+export { DesignProvider, useDesign, type DesignOptions } from './design';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/providers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/providers/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,SAAS,CAAC;AAGxB,OAAO,EACL,gBAAgB,EAChB,WAAW,EACX,KAAK,iBAAiB,EACtB,SAAS,GACV,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAE1E,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,KAAK,aAAa,EAAE,MAAM,UAAU,CAAC"}

package/dist/components/providers/index.js

@@ -0,0 +1,12 @@
+// Provider Components
+export { ComputeProvider } from './compute';
+export { CurvenoteProviders } from './curvenote-providers';
+export { MystProviders } from './myst-providers';
+export * from './ping-boundary';
+export * from './platform-providers';
+export * from './types';
+// Lightbox Provider
+export { LightboxProvider, useLightbox, useImages, } from './lightbox-provider';
+// Page Providers
+export { PageProviders, useIsIndexPage, usePage } from './page-providers';
+export { DesignProvider, useDesign } from './design';

package/dist/components/providers/lightbox-provider.d.ts

@@ -0,0 +1,31 @@
+import * as React from 'react';
+import type { GenericParent } from 'myst-common';
+export declare function useImages({ mdast }: {
+    mdast?: GenericParent;
+}): LightboxImageData[];
+export interface LightboxImageData {
+    src: string;
+    srcOptimized?: string;
+    urlSource?: string;
+    alt?: string;
+    caption?: string | GenericParent;
+}
+interface LightboxContextType {
+    isOpen: boolean;
+    currentImage: LightboxImageData | null;
+    imageList: LightboxImageData[];
+    currentIndex: number;
+    openLightbox: (image: LightboxImageData) => void;
+    closeLightbox: () => void;
+    navigate: (direction: 'prev' | 'next') => void;
+    hasNext: boolean;
+    hasPrev: boolean;
+}
+interface LightboxProviderProps {
+    children: React.ReactNode;
+    imageList?: LightboxImageData[];
+}
+export declare function LightboxProvider({ children, imageList: initialImageList, }: LightboxProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useLightbox(): LightboxContextType;
+export {};
+//# sourceMappingURL=lightbox-provider.d.ts.map

package/dist/components/providers/lightbox-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lightbox-provider.d.ts","sourceRoot":"","sources":["../../../src/components/providers/lightbox-provider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAMjD,wBAAgB,SAAS,CAAC,EAAE,KAAK,EAAE,EAAE;IAAE,KAAK,CAAC,EAAE,aAAa,CAAA;CAAE,uBAwC7D;AAED,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,GAAG,aAAa,CAAC;CAClC;AAED,UAAU,mBAAmB;IAC3B,MAAM,EAAE,OAAO,CAAC;IAChB,YAAY,EAAE,iBAAiB,GAAG,IAAI,CAAC;IACvC,SAAS,EAAE,iBAAiB,EAAE,CAAC;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;IACjD,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B,QAAQ,EAAE,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,KAAK,IAAI,CAAC;IAC/C,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;CAClB;AAID,UAAU,qBAAqB;IAC7B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,SAAS,CAAC,EAAE,iBAAiB,EAAE,CAAC;CACjC;AAED,wBAAgB,gBAAgB,CAAC,EAC/B,QAAQ,EACR,SAAS,EAAE,gBAAqB,GACjC,EAAE,qBAAqB,2CA0EvB;AAED,wBAAgB,WAAW,wBAM1B"}