@parallelworks/ui 0.51.0 → 0.53.0

package/dist/editor/index.d.ts

@@ -1,11 +1,12 @@
-export { default as Editor } from './Editor.js';
-export { default as EditorField, type IEditorField } from './EditorField.js';
-export { default as FormCodePanel } from './FormCodePanel.js';
+export { Editor } from './Editor.js';
+export { EditorField, type IEditorField } from './EditorField.js';
+export { FormCodePanel, type FormCodePanelProps } from './FormCodePanel.js';
+export { addEditorLanguages, type EditorLanguages } from './languages.js';
 export { HOST_MARKER_OWNER, LINT_OWNER } from './lintOwner.js';
-export type { IEditorProps, ISchemaError } from './Monaco.js';
+export type { EditorMarker, EditorProps, ValidationMarker } from './Monaco.js';
 export { type NestedWorkflowText, nestedWorkflowText } from './nestedText.js';
 export { revealLines } from './reveal.js';
 export { INPUT_YAML_PATH, JOB_YAML_PATH, type JsonSchema, SETTINGS_YAML_PATH, STEP_YAML_PATH, settingsSchemas, } from './settingsYaml.js';
 export { defineEditorThemes, followThemeTokens, getThemeName } from './themes.js';
 export { setupMonacoWorkers } from './workers.js';
-export { configureEditorYaml } from './yaml.js';
+export { configureEditorYaml, type SchemasSettings } from './yaml.js';

package/dist/editor/index.js

@@ -1,11 +1,12 @@
 import { HOST_MARKER_OWNER, LINT_OWNER } from "./lintOwner.js";
 import { INPUT_YAML_PATH, JOB_YAML_PATH, SETTINGS_YAML_PATH, STEP_YAML_PATH, settingsSchemas } from "./settingsYaml.js";
-import Editor from "./Editor.js";
-import EditorField from "./EditorField.js";
-import FormCodePanel from "./FormCodePanel.js";
+import { addEditorLanguages } from "./languages.js";
+import { Editor } from "./Editor.js";
+import { EditorField } from "./EditorField.js";
+import { FormCodePanel } from "./FormCodePanel.js";
 import { nestedWorkflowText } from "./nestedText.js";
 import { revealLines } from "./reveal.js";
 import { defineEditorThemes, followThemeTokens, getThemeName } from "./themes.js";
 import { setupMonacoWorkers } from "./workers.js";
 import { configureEditorYaml } from "./yaml.js";
-export { Editor, EditorField, FormCodePanel, HOST_MARKER_OWNER, INPUT_YAML_PATH, JOB_YAML_PATH, LINT_OWNER, SETTINGS_YAML_PATH, STEP_YAML_PATH, configureEditorYaml, defineEditorThemes, followThemeTokens, getThemeName, nestedWorkflowText, revealLines, settingsSchemas, setupMonacoWorkers };
+export { Editor, EditorField, FormCodePanel, HOST_MARKER_OWNER, INPUT_YAML_PATH, JOB_YAML_PATH, LINT_OWNER, SETTINGS_YAML_PATH, STEP_YAML_PATH, addEditorLanguages, configureEditorYaml, defineEditorThemes, followThemeTokens, getThemeName, nestedWorkflowText, revealLines, settingsSchemas, setupMonacoWorkers };

package/dist/editor/languages.d.ts

@@ -0,0 +1,24 @@
+/** Languages a host adds to the ones the editor carries. */
+export interface EditorLanguages {
+    /**
+     * Imports Monaco's registration for the languages, such as
+     * `() => import('monaco-editor/languages/definitions/ruby/register')`. It runs when the next
+     * editor mounts, so Monaco still loads only once an editor needs it.
+     */
+    load: () => Promise<unknown>;
+    /**
+     * A worker for each language service the registration brings, by the label Monaco asks for,
+     * such as `typescript` and `javascript`. Basic languages color text on the page and need none.
+     */
+    workers?: Record<string, () => Worker>;
+}
+/**
+ * Adds language services with their workers, such as TypeScript's, or languages of the host's
+ * own, to the coloring the editor has for every Monaco language. Call it once at startup, before
+ * the first editor mounts; an editor that mounts while they load waits for them.
+ */
+export declare function addEditorLanguages({ load, workers: added }: EditorLanguages): void;
+/** The languages still loading, starting any added since, or undefined once all have. */
+export declare function editorLanguagesLoading(): Promise<unknown> | undefined;
+/** The host's worker for a Monaco worker label, if it added one. */
+export declare function hostEditorWorker(label: string): (() => Worker) | undefined;

package/dist/editor/languages.js

@@ -0,0 +1,31 @@
+//#region src/editor/languages.ts
+var workers = /* @__PURE__ */ new Map();
+var waiting = [];
+var loading;
+/**
+* Adds language services with their workers, such as TypeScript's, or languages of the host's
+* own, to the coloring the editor has for every Monaco language. Call it once at startup, before
+* the first editor mounts; an editor that mounts while they load waits for them.
+*/
+function addEditorLanguages({ load, workers: added = {} }) {
+	for (const [label, create] of Object.entries(added)) workers.set(label, create);
+	waiting.push(load);
+}
+/** The languages still loading, starting any added since, or undefined once all have. */
+function editorLanguagesLoading() {
+	if (waiting.length > 0) {
+		const loads = waiting;
+		waiting = [];
+		const started = Promise.all([loading, ...loads.map((load) => load().catch((error) => console.error("An editor language failed to load", error)))]).finally(() => {
+			if (loading === started) loading = void 0;
+		});
+		loading = started;
+	}
+	return loading;
+}
+/** The host's worker for a Monaco worker label, if it added one. */
+function hostEditorWorker(label) {
+	return workers.get(label);
+}
+//#endregion
+export { addEditorLanguages, editorLanguagesLoading, hostEditorWorker };

package/dist/editor/monacoFeatures.d.ts

@@ -0,0 +1,7 @@
+import 'monaco-editor/features/register.all';
+import 'monaco-editor/editor/contrib/caretOperations/browser/caretOperations';
+import 'monaco-editor/editor/contrib/dropOrPasteInto/browser/copyPasteContribution';
+import 'monaco-editor/editor/contrib/gotoError/browser/markerSelectionStatus';
+import 'monaco-editor/editor/contrib/semanticTokens/browser/documentSemanticTokens';
+import 'monaco-editor/languages/definitions/register.all';
+import 'monaco-editor/languages/features/json/register';

package/dist/editor/monacoFeatures.js

@@ -0,0 +1,19 @@
+import { languages } from "monaco-editor/editor/editor.api";
+import "monaco-editor/features/register.all";
+import "monaco-editor/editor/contrib/caretOperations/browser/caretOperations";
+import "monaco-editor/editor/contrib/dropOrPasteInto/browser/copyPasteContribution";
+import "monaco-editor/editor/contrib/gotoError/browser/markerSelectionStatus";
+import "monaco-editor/editor/contrib/semanticTokens/browser/documentSemanticTokens";
+import "monaco-editor/languages/definitions/register.all";
+import "monaco-editor/languages/features/json/register";
+//#region src/editor/monacoFeatures.ts
+var shell = () => import("monaco-editor/languages/definitions/shell/shell");
+languages.register({
+	id: "bash",
+	aliases: ["Bash", "bash"]
+});
+languages.registerTokensProviderFactory("bash", { create: async () => (await shell()).language });
+languages.onLanguageEncountered("bash", async () => {
+	languages.setLanguageConfiguration("bash", (await shell()).conf);
+});
+//#endregion

package/dist/editor/themes.d.ts

@@ -1,8 +1,11 @@
 import type * as monaco from 'monaco-editor';
 export declare function expandShorthandHex(color: string): string;
-/** Monaco themes read from the document's tokens: call again after the host applies another theme. */
-export declare function defineEditorThemes(monacoEditor: typeof monaco.editor): void;
-/** Redefines the editor themes when the host applies other tokens to the document,
- *  and sets `current()` again, so an open editor follows a theme being edited. */
+/**
+ * Defines the light and dark Monaco themes from the document's tokens. Call it again after the
+ * host applies other tokens; it returns whether anything changed.
+ */
+export declare function defineEditorThemes(monacoEditor: typeof monaco.editor): boolean;
+/** Redefines the editor themes when the host applies other tokens or another scheme to the
+ *  document, and sets `current()` again, so an open editor follows a theme being edited. */
 export declare function followThemeTokens(monacoEditor: typeof monaco.editor, current: () => string): () => void;
-export declare function getThemeName(isDark: boolean, disabled?: boolean): string;
+export declare function getThemeName(isDark: boolean): string;

package/dist/editor/themes.js

@@ -9,9 +9,8 @@ var fallbacks = {};
 /** A token as Monaco takes it: a 6-digit hex. Monaco can't read display-p3, so
 *  a wide-gamut value is mapped back into sRGB; the default theme fills in for
 *  a host that sets no tokens. */
-function token(name, mode) {
-	const set = typeof window === "undefined" ? "" : getComputedStyle(document.documentElement).getPropertyValue(name).trim();
-	const color = parseColor(expandShorthandHex(set));
+function token(style, name, mode) {
+	const color = parseColor(expandShorthandHex(style?.getPropertyValue(name).trim() ?? ""));
 	if (color) return toHex(color);
 	fallbacks[mode] ??= deriveTheme(schemeFor(DEFAULT_THEME, mode));
 	return fallbacks[mode][name];
@@ -37,54 +36,88 @@ var RULES = [
 	["delimiter", "--theme-code-text"],
 	["operators", "--theme-code-text"]
 ];
-function editorTheme(mode, disabled) {
-	const c = (name) => token(name, mode);
-	const foreground = disabled ? c("--theme-muted-text-color") : c("--theme-code-text");
-	const background = disabled ? c("--theme-input-disabled-bg") : c("--theme-panel-bg");
+function editorTheme(style, mode) {
+	const c = (name) => token(style, name, mode);
 	return {
 		base: mode === "dark" ? "vs-dark" : "vs",
 		inherit: true,
-		rules: disabled ? [{
-			token: "",
-			foreground: foreground.slice(1)
-		}] : RULES.map(([name, t, fontStyle]) => ({
+		rules: RULES.map(([name, t, fontStyle]) => ({
 			token: name,
 			foreground: c(t).slice(1),
 			...fontStyle ? { fontStyle } : {}
 		})),
 		colors: {
-			"editor.foreground": foreground,
-			"editor.background": background,
+			"editor.foreground": c("--theme-code-text"),
+			"editor.background": c("--theme-panel-bg"),
 			"editor.border": c("--theme-border"),
-			"editorCursor.foreground": disabled ? background : c("--theme-app"),
-			"editor.lineHighlightBackground": disabled ? background : c("--theme-hover"),
+			"editorCursor.foreground": c("--theme-app"),
+			"editor.lineHighlightBackground": c("--theme-hover"),
 			"editorLineNumber.foreground": c("--theme-placeholder"),
 			"editorLineNumber.activeForeground": c("--theme-muted-text-color"),
-			"editor.selectionBackground": c("--theme-accent-subtle"),
-			"editor.inactiveSelectionBackground": c("--theme-hover")
+			...mode === "dark" ? {
+				"editor.selectionBackground": `${c("--theme-accent")}66`,
+				"editor.inactiveSelectionBackground": `${c("--theme-accent")}40`
+			} : {
+				"editor.selectionBackground": c("--theme-accent-subtle"),
+				"editor.inactiveSelectionBackground": c("--theme-hover")
+			}
 		}
 	};
 }
-/** Monaco themes read from the document's tokens: call again after the host applies another theme. */
+var definedFor = /* @__PURE__ */ new WeakMap();
+/**
+* Defines the light and dark Monaco themes from the document's tokens. Call it again after the
+* host applies other tokens; it returns whether anything changed.
+*/
 function defineEditorThemes(monacoEditor) {
-	for (const mode of ["light", "dark"]) for (const disabled of [false, true]) monacoEditor.defineTheme(getThemeName(mode === "dark", disabled), editorTheme(mode, disabled));
+	const style = typeof window === "undefined" ? void 0 : getComputedStyle(document.documentElement);
+	const themes = ["light", "dark"].map((mode) => [mode, editorTheme(style, mode)]);
+	const snapshot = JSON.stringify(themes);
+	if (definedFor.get(monacoEditor) === snapshot) return false;
+	definedFor.set(monacoEditor, snapshot);
+	for (const [mode, data] of themes) monacoEditor.defineTheme(getThemeName(mode === "dark"), data);
+	return true;
 }
-/** Redefines the editor themes when the host applies other tokens to the document,
-*  and sets `current()` again, so an open editor follows a theme being edited. */
+var followers = /* @__PURE__ */ new Set();
+var observer;
+var frame = 0;
+function flush() {
+	frame = 0;
+	for (const follow of followers) follow();
+}
+/** Redefines the editor themes when the host applies other tokens or another scheme to the
+*  document, and sets `current()` again, so an open editor follows a theme being edited. */
 function followThemeTokens(monacoEditor, current) {
 	if (typeof MutationObserver === "undefined") return () => {};
-	const observer = new MutationObserver(() => {
-		defineEditorThemes(monacoEditor);
-		monacoEditor.setTheme(current());
-	});
-	observer.observe(document.documentElement, {
-		attributes: true,
-		attributeFilter: ["style"]
-	});
-	return () => observer.disconnect();
+	const follow = () => {
+		if (defineEditorThemes(monacoEditor)) monacoEditor.setTheme(current());
+	};
+	followers.add(follow);
+	if (!observer) {
+		observer = new MutationObserver(() => {
+			frame ||= requestAnimationFrame(flush);
+		});
+		observer.observe(document.documentElement, {
+			attributes: true,
+			attributeFilter: [
+				"style",
+				"class",
+				"data-theme"
+			]
+		});
+	}
+	return () => {
+		followers.delete(follow);
+		if (followers.size === 0) {
+			observer?.disconnect();
+			observer = void 0;
+			cancelAnimationFrame(frame);
+			frame = 0;
+		}
+	};
 }
-function getThemeName(isDark, disabled) {
-	return `app-${isDark ? "dark" : "light"}${disabled ? "-disabled" : ""}`;
+function getThemeName(isDark) {
+	return `app-${isDark ? "dark" : "light"}`;
 }
 //#endregion
 export { defineEditorThemes, expandShorthandHex, followThemeTokens, getThemeName };

package/dist/editor/workers.d.ts

@@ -1,7 +1,7 @@
 /**
- * Points window.MonacoEnvironment at the bundled workers. Idempotent, and a
- * host that already configured its own MonacoEnvironment wins — the editor
- * calls this on first load only when nothing is configured.
+ * Points window.MonacoEnvironment at the bundled workers and those a host added with
+ * `addEditorLanguages`. Idempotent, and a host that already configured its own
+ * MonacoEnvironment wins — the editor calls this on first load only when nothing is configured.
  */
 export declare function setupMonacoWorkers(): void;
 /**

package/dist/editor/workers.js

@@ -1,20 +1,24 @@
+import { hostEditorWorker } from "./languages.js";
 //#region src/editor/workers.ts
 var monacoEnvironment = { getWorker(_moduleId, label) {
+	const host = hostEditorWorker(label);
+	if (host) return host();
 	if (label === "json") return new Worker(new URL(
 		/* @vite-ignore */
 		new URL("../assets/json.worker-BKkHJbNB.js", import.meta.url).href,
 		"" + import.meta.url
 	), { type: "module" });
-	return new Worker(new URL(
+	if (label === "editorWorkerService") return new Worker(new URL(
 		/* @vite-ignore */
 		new URL("../assets/editor.worker-Cc3TfJ_-.js", import.meta.url).href,
 		"" + import.meta.url
 	), { type: "module" });
+	throw new Error(`The editor has no worker for Monaco's "${label}" service: pass one to addEditorLanguages.`);
 } };
 /**
-* Points window.MonacoEnvironment at the bundled workers. Idempotent, and a
-* host that already configured its own MonacoEnvironment wins — the editor
-* calls this on first load only when nothing is configured.
+* Points window.MonacoEnvironment at the bundled workers and those a host added with
+* `addEditorLanguages`. Idempotent, and a host that already configured its own
+* MonacoEnvironment wins — the editor calls this on first load only when nothing is configured.
 */
 function setupMonacoWorkers() {
 	if (window.MonacoEnvironment) return;

package/dist/editor/yaml.d.ts

@@ -7,7 +7,11 @@ export interface SchemasSettings {
     /** The schema itself, used instead of fetching `uri`. */
     schema?: object;
 }
-/** Adds JSON schemas that validate and complete YAML models whose URI matches. */
-export declare function configureEditorYaml(added: SchemasSettings[]): void;
+/**
+ * Adds JSON schemas that validate and complete YAML models whose URI matches. A schema with the
+ * `uri` of one already added replaces it, so calling this again, as a reload or a second mount
+ * does, adds nothing twice. Returns a function that removes these schemas.
+ */
+export declare function configureEditorYaml(added: SchemasSettings[]): () => void;
 /** Lets the loaded editor pick up schemas added before or after it loads. */
 export declare function onYamlSchemas(listener: (schemas: SchemasSettings[]) => void): void;

package/dist/editor/yaml.js

@@ -1,10 +1,19 @@
 //#region src/editor/yaml.ts
 var schemas = [];
 var apply;
-/** Adds JSON schemas that validate and complete YAML models whose URI matches. */
+/**
+* Adds JSON schemas that validate and complete YAML models whose URI matches. A schema with the
+* `uri` of one already added replaces it, so calling this again, as a reload or a second mount
+* does, adds nothing twice. Returns a function that removes these schemas.
+*/
 function configureEditorYaml(added) {
-	schemas = [...schemas, ...added];
+	const uris = new Set(added.map((schema) => schema.uri));
+	schemas = [...schemas.filter((schema) => !uris.has(schema.uri)), ...added];
 	apply?.(schemas);
+	return () => {
+		schemas = schemas.filter((schema) => !added.includes(schema));
+		apply?.(schemas);
+	};
 }
 /** Lets the loaded editor pick up schemas added before or after it loads. */
 function onYamlSchemas(listener) {

package/dist/editor/yamlLanguage.js

@@ -1,6 +1,6 @@
 import { createYamlWorker } from "./workers.js";
 import { onYamlSchemas } from "./yaml.js";
-import * as monaco from "monaco-editor";
+import * as monaco from "monaco-editor/editor/editor.api";
 //#region src/editor/yamlLanguage.ts
 var LANGUAGE_ID = "yaml";
 var MARKER_OWNER = "yaml";
@@ -186,41 +186,59 @@ function answerServer(method, params) {
 	return null;
 }
 function startYamlLanguage() {
-	const worker = createYamlWorker();
-	worker.postMessage({});
-	const connection = new WorkerConnection(worker, answerServer);
+	let server;
+	let schemas = [];
 	const open = /* @__PURE__ */ new Map();
-	const ready = connection.request("initialize", {
-		processId: null,
-		rootUri: null,
-		capabilities: {
-			workspace: { configuration: true },
-			textDocument: {
-				synchronization: {},
-				completion: { completionItem: {
-					snippetSupport: true,
-					insertReplaceSupport: true,
-					documentationFormat: ["markdown", "plaintext"]
-				} },
-				hover: { contentFormat: ["markdown", "plaintext"] },
-				publishDiagnostics: {}
-			}
-		}
-	}).then(() => {
-		connection.notify("initialized", {});
-		connection.notify("workspace/didChangeConfiguration", { settings: null });
-	});
-	onYamlSchemas((schemas) => {
-		ready.then(() => connection.notify("json/schemaAssociations", [schemas]));
-	});
-	connection.onNotification("textDocument/publishDiagnostics", (params) => {
-		const { uri, diagnostics } = params;
-		const model = open.get(uri);
-		if (model && !model.isDisposed()) monaco.editor.setModelMarkers(model, MARKER_OWNER, diagnostics.map(toMarker));
+	function connect() {
+		if (server) return server;
+		const worker = createYamlWorker();
+		worker.postMessage({});
+		const connection = new WorkerConnection(worker, answerServer);
+		connection.onNotification("textDocument/publishDiagnostics", (params) => {
+			const { uri, diagnostics } = params;
+			const model = open.get(uri);
+			if (model && !model.isDisposed()) monaco.editor.setModelMarkers(model, MARKER_OWNER, diagnostics.map(toMarker));
+		});
+		server = {
+			connection,
+			ready: connection.request("initialize", {
+				processId: null,
+				rootUri: null,
+				capabilities: {
+					workspace: { configuration: true },
+					textDocument: {
+						synchronization: {},
+						completion: { completionItem: {
+							snippetSupport: true,
+							insertReplaceSupport: true,
+							documentationFormat: ["markdown", "plaintext"]
+						} },
+						hover: { contentFormat: ["markdown", "plaintext"] },
+						publishDiagnostics: {}
+					}
+				}
+			}).then(() => {
+				connection.notify("initialized", {});
+				connection.notify("workspace/didChangeConfiguration", { settings: null });
+				sendSchemas();
+			})
+		};
+		return server;
+	}
+	function notify(method, params) {
+		const { connection, ready } = connect();
+		ready.then(() => connection.notify(method, params));
+	}
+	function sendSchemas() {
+		server?.connection.notify("json/schemaAssociations", [schemas]);
+	}
+	onYamlSchemas((added) => {
+		schemas = added;
+		server?.ready.then(sendSchemas);
 	});
 	function close(uri, model) {
 		open.delete(uri);
-		ready.then(() => connection.notify("textDocument/didClose", { textDocument: { uri } }));
+		notify("textDocument/didClose", { textDocument: { uri } });
 		if (!model.isDisposed()) monaco.editor.setModelMarkers(model, MARKER_OWNER, []);
 	}
 	function track(model) {
@@ -229,26 +247,24 @@ function startYamlLanguage() {
 			const isYaml = model.getLanguageId() === LANGUAGE_ID;
 			if (isYaml && !open.has(uri)) {
 				open.set(uri, model);
-				const textDocument = {
+				notify("textDocument/didOpen", { textDocument: {
 					uri,
 					languageId: LANGUAGE_ID,
 					version: model.getVersionId(),
 					text: model.getValue()
-				};
-				ready.then(() => connection.notify("textDocument/didOpen", { textDocument }));
+				} });
 			} else if (!isYaml && open.has(uri)) close(uri, model);
 		};
 		model.onDidChangeLanguage(sync);
 		model.onDidChangeContent(() => {
 			if (!open.has(uri)) return;
-			const params = {
+			notify("textDocument/didChange", {
 				textDocument: {
 					uri,
 					version: model.getVersionId()
 				},
 				contentChanges: [{ text: model.getValue() }]
-			};
-			ready.then(() => connection.notify("textDocument/didChange", params));
+			});
 		});
 		model.onWillDispose(() => {
 			if (open.get(uri) === model) close(uri, model);
@@ -258,6 +274,7 @@ function startYamlLanguage() {
 	for (const model of monaco.editor.getModels()) track(model);
 	monaco.editor.onDidCreateModel(track);
 	async function request(method, model, params, token) {
+		const { connection, ready } = connect();
 		await ready;
 		return connection.request(method, {
 			textDocument: { uri: model.uri.toString() },

package/dist/file-explorer/FileExplorer.d.ts

@@ -2,7 +2,22 @@ import { type ReactNode } from 'react';
 import { type RowAction } from '../list/index.js';
 import type { IFileExplorerClient, IFileExplorerProvider } from './lib/fileExplorer.js';
 import type { ExplorerObject, TreeNode, TStorage } from './lib/types.js';
-interface IFileExplorerProps {
+/** How the explorer moves between folders and files. */
+type ExplorerNavigation = {
+    /** The URL of a path, for a host that keeps the path in its URL. Rows, the
+     * tree, the trail and each row menu's "Open folder" are then links through
+     * the host's router (`useLink`), so a path opens in a new tab, shows its
+     * URL and can be copied, and back and forward move between paths. */
+    pathHref: (path: string) => string;
+    /** Moves to a path without a link: from the keyboard, a delete, an upload.
+     * Absent, the explorer goes to `pathHref(path)` through the provider's
+     * `navigation.goTo`. */
+    onPathChange?: ((path: string) => void) | undefined;
+} | {
+    pathHref?: undefined;
+    onPathChange: (path: string) => void;
+};
+type IFileExplorerProps = ExplorerNavigation & {
     storages: TStorage[];
     /** Resolves the storage's injected provider pair; the host owns caching. */
     getProviderAndClient: (storage: TStorage) => Promise<{
@@ -21,7 +36,6 @@ interface IFileExplorerProps {
     }[] | undefined;
     groupsLoading?: boolean;
     selectedPath: string;
-    onPathChange: (path: string) => void;
     /** Renders only the tree, for a host that embeds it as a navigator and owns
      * the pane beside it (the notebooks page puts its editor there). The host
      * also owns the width, so the tree fills its container instead of carrying
@@ -48,6 +62,6 @@ interface IFileExplorerProps {
     extraRowActions?: ((node: TreeNode, storage: TStorage | undefined) => RowAction[]) | undefined;
     /** Host content for the selected folder's header, before its badges. */
     headerAccessory?: ((node: TreeNode, storage: TStorage | undefined) => ReactNode) | undefined;
-}
-export default function FileExplorer({ storages, onRefresh, refreshKey, onOpenFile, showUserHierarchy, groups, groupsLoading, selectedPath, onPathChange, getProviderAndClient, treeOnly, initialExpandedPaths, onExpandedPathsChange, objectUris, downloadCommand, extraRowActions, headerAccessory, }: IFileExplorerProps): import("react").JSX.Element;
+};
+export default function FileExplorer({ storages, onRefresh, refreshKey, onOpenFile, showUserHierarchy, groups, groupsLoading, selectedPath, onPathChange, pathHref, getProviderAndClient, treeOnly, initialExpandedPaths, onExpandedPathsChange, objectUris, downloadCommand, extraRowActions, headerAccessory, }: IFileExplorerProps): import("react").JSX.Element;
 export {};