@parallelworks/ui 0.18.0 → 0.19.1

package/dist/editor/FormCodePanel.js

@@ -0,0 +1,173 @@
+import { useNotify, useStrings, useWorkflowEngine } from "../components/Provider.js";
+import { CheckIcon, CopyIcon, EyeIcon, EyeOffIcon } from "../icons.js";
+import SwitchToggleSmall from "../components/SwitchToggleSmall.js";
+import Editor from "./Editor.js";
+import { flattenGroups, impureSetValueFromPath } from "../form/lib.js";
+import cx from "classnames";
+import { useId, useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/editor/FormCodePanel.tsx
+var isObject = (value) => typeof value === "object" && value !== null;
+var shouldIgnoreField = (engine, fieldSchema, inputs, arrayIndex) => {
+	if (!fieldSchema?.["ignore"] || !fieldSchema?.["hidden"]) return false;
+	if (!engine.isReady()) return false;
+	return engine.evaluate({
+		inputs,
+		obj: engine.convertInputs(fieldSchema),
+		index: arrayIndex ?? -1
+	})["hidden"] === true;
+};
+var filterFields = (engine, formJSON, data, prefix, rootData, arrayIndex) => {
+	const filteredFields = [];
+	return {
+		filteredFields,
+		filtered: Object.keys(data).reduce((acc, key) => {
+			const value = data[key];
+			const fieldSchema = formJSON[key];
+			if (value !== null && Array.isArray(value)) {
+				const items = [];
+				acc[key] = items;
+				if (!fieldSchema) return acc;
+				const nestedSchema = isObject(fieldSchema) ? fieldSchema["options"] : void 0;
+				for (let i = 0; i < value.length; i++) {
+					let filteredFieldsNested = [];
+					let filteredNested = {};
+					const item = value[i];
+					if (isObject(item)) {
+						const result = filterFields(engine, isObject(nestedSchema) ? nestedSchema : {}, item, key + `[${i}].`, rootData || data, i);
+						filteredNested = result.filtered;
+						filteredFieldsNested = result.filteredFields;
+					} else filteredNested = item;
+					filteredFields.push(...filteredFieldsNested);
+					items[i] = filteredNested;
+				}
+				return acc;
+			}
+			if (fieldSchema && isObject(value)) {
+				const { filteredFields: filteredFieldsNested, filtered: filteredNested } = filterFields(engine, isObject(fieldSchema) ? fieldSchema : {}, value, key + ".", rootData || data, arrayIndex);
+				filteredFields.push(...filteredFieldsNested);
+				acc[key] = filteredNested;
+				return acc;
+			}
+			if (isObject(fieldSchema) && fieldSchema["sensitive"]) {
+				const name = prefix ? prefix + key : key;
+				filteredFields.push({
+					key: name,
+					value
+				});
+				return acc;
+			}
+			const contextData = rootData || data;
+			if (isObject(fieldSchema) && shouldIgnoreField(engine, fieldSchema, contextData, arrayIndex)) return acc;
+			acc[key] = value;
+			return acc;
+		}, {})
+	};
+};
+var populateFiltered = (filteredFields, data) => {
+	filteredFields.forEach((element) => {
+		impureSetValueFromPath(data, element.key, element.value);
+	});
+	return data;
+};
+function FormCodePanel({ formJSON, data, mutate, height = "600px", disabled = false }) {
+	const engine = useWorkflowEngine();
+	const notify = useNotify();
+	const { common: t } = useStrings();
+	const uid = useId();
+	const [jsonHasErrors, setJsonHasErrors] = useState(false);
+	const [showHidden, setShowHidden] = useState(false);
+	const [copied, setCopied] = useState(false);
+	const copyResetRef = useRef(void 0);
+	const isValidJson = (errors) => {
+		setJsonHasErrors(errors.length > 0);
+	};
+	const { filteredFields, filtered } = filterFields(engine, flattenGroups(formJSON), data || {});
+	const hasHiddenFields = filteredFields.length > 0;
+	const displayObj = showHidden && hasHiddenFields ? populateFiltered(filteredFields, structuredClone(filtered)) : filtered;
+	const showHiddenRef = useRef(showHidden);
+	showHiddenRef.current = showHidden;
+	const filteredFieldsRef = useRef(filteredFields);
+	filteredFieldsRef.current = filteredFields;
+	const json = JSON.stringify(displayObj, null, 2);
+	const handleCopy = async () => {
+		try {
+			await navigator.clipboard.writeText(json);
+			setCopied(true);
+			clearTimeout(copyResetRef.current);
+			copyResetRef.current = setTimeout(() => setCopied(false), 2e3);
+		} catch {
+			notify.error(t.copyFailed);
+		}
+	};
+	return /* @__PURE__ */ jsxs("div", {
+		style: { height },
+		className: "flex w-full flex-col gap-2",
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: cx("flex min-h-0 flex-1 flex-col overflow-hidden rounded-md border", jsonHasErrors ? "border-red-500" : "border-(--theme-border)"),
+			children: [/* @__PURE__ */ jsxs("div", {
+				className: "bg-(--theme-muted-panel-bg) text-(--theme-muted-panel-color) flex shrink-0 items-center gap-3 border-b border-(--theme-border) px-3 py-2",
+				children: [hasHiddenFields && /* @__PURE__ */ jsxs("label", {
+					htmlFor: `${uid}-show-hidden`,
+					title: t.showHiddenFieldsHint,
+					className: "flex cursor-pointer select-none items-center gap-2 text-sm text-(--theme-app)",
+					children: [/* @__PURE__ */ jsx(SwitchToggleSmall, {
+						id: `${uid}-show-hidden`,
+						value: showHidden,
+						"aria-label": t.showHiddenFields,
+						onClick: () => setShowHidden((prev) => !prev)
+					}), /* @__PURE__ */ jsxs("span", {
+						className: "flex items-center gap-1.5",
+						children: [showHidden ? /* @__PURE__ */ jsx(EyeIcon, {}) : /* @__PURE__ */ jsx(EyeOffIcon, {}), t.showHiddenFields]
+					})]
+				}), /* @__PURE__ */ jsxs("button", {
+					type: "button",
+					onClick: handleCopy,
+					"aria-label": copied ? t.copied : t.copy,
+					className: "ml-auto flex shrink-0 items-center gap-1.5 rounded-md border border-(--theme-border) px-2.5 py-1.5 text-sm text-(--theme-app) transition-colors duration-150 hover:bg-(--theme-hover) focus:outline-none focus-visible:ring-2 focus-visible:ring-(--theme-link)",
+					children: [copied ? /* @__PURE__ */ jsx(CheckIcon, { className: "text-green-500" }) : /* @__PURE__ */ jsx(CopyIcon, { className: "text-(--theme-muted-text-color)" }), copied ? t.copied : t.copy]
+				})]
+			}), /* @__PURE__ */ jsx("div", {
+				className: "min-h-0 flex-1",
+				children: /* @__PURE__ */ jsx(Editor, {
+					height: "100%",
+					value: json,
+					onValidate: isValidJson,
+					className: "!rounded-none !border-0",
+					minimap: { enabled: false },
+					scrollBeyondLastLine: false,
+					overviewRulerLanes: 0,
+					overviewRulerBorder: false,
+					lineNumbersMinChars: 3,
+					lineDecorationsWidth: 8,
+					renderLineHighlight: "none",
+					padding: {
+						top: 12,
+						bottom: 12
+					},
+					fontSize: 13,
+					scrollbar: {
+						verticalScrollbarSize: 10,
+						horizontalScrollbarSize: 10
+					},
+					onChange: (e) => {
+						try {
+							const parsed = JSON.parse(e);
+							if (!isObject(parsed)) return;
+							mutate(showHiddenRef.current ? parsed : populateFiltered(filteredFieldsRef.current, parsed));
+						} catch {
+							console.log("JSON.parse error in form code editor");
+						}
+					},
+					language: "json",
+					disabled
+				})
+			})]
+		}), jsonHasErrors && /* @__PURE__ */ jsx("p", {
+			className: "shrink-0 text-sm text-red-500",
+			children: t.jsonHasErrors
+		})]
+	});
+}
+//#endregion
+export { FormCodePanel as default };

package/dist/editor/Monaco.d.ts

@@ -1,20 +1,4 @@
 import * as monaco from 'monaco-editor';
-export interface EditorMarketplaceItem {
-    readonly slug?: string;
-    readonly name?: string | null;
-    readonly description?: string | null;
-    readonly type?: string | null;
-    readonly subtype?: string | null;
-    readonly versions?: readonly string[] | null;
-}
-export interface EditorWorkflowItem {
-    readonly name?: string;
-    readonly displayName?: string | null;
-    readonly description?: string | null;
-    readonly type?: string | null;
-}
-type MarketplaceItem = EditorMarketplaceItem;
-type WorkflowItem = EditorWorkflowItem;
 export type ISchemaError = monaco.editor.IMarker;
 export interface IEditorProps extends monaco.editor.IStandaloneEditorConstructionOptions {
     className?: string;
@@ -24,8 +8,5 @@ export interface IEditorProps extends monaco.editor.IStandaloneEditorConstructio
     width?: string | number;
     height?: string | number;
     path?: 'file:///workflow.yaml' | string;
-    marketplaceItems?: MarketplaceItem[];
-    workflows?: WorkflowItem[];
 }
-export default function MonacoEditor({ className, disabled, onChange, onValidate, width, height, path, marketplaceItems, workflows, ...options }: IEditorProps): import("react").JSX.Element;
-export {};
+export default function MonacoEditor({ className, disabled, onChange, onValidate, width, height, path, ...options }: IEditorProps): import("react").JSX.Element;

package/dist/editor/Monaco.js

@@ -0,0 +1,112 @@
+import { useCssIsDark } from "../components/useCssIsDark.js";
+import { defineEditorThemes, getThemeName } from "./themes.js";
+import { setupMonacoWorkers } from "./workers.js";
+import { onYamlSchemas } from "./yaml.js";
+import cx from "classnames";
+import { useEffect, useLayoutEffect, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+import * as monaco from "monaco-editor";
+import { configureMonacoYaml } from "monaco-yaml";
+//#region src/editor/Monaco.tsx
+setupMonacoWorkers();
+var monacoWithWorkerBridge = {
+	...monaco,
+	editor: {
+		...monaco.editor,
+		createWebWorker: (opts) => "worker" in opts ? monaco.editor.createWebWorker(opts) : monaco.createWebWorker(opts)
+	}
+};
+var monacoYamlConfigured = false;
+function ensureMonacoYamlConfigured() {
+	if (monacoYamlConfigured) return;
+	monacoYamlConfigured = true;
+	const options = (schemas) => ({
+		enableSchemaRequest: true,
+		completion: true,
+		validate: true,
+		hover: true,
+		format: { enable: true },
+		schemas
+	});
+	const monacoYaml = configureMonacoYaml(monacoWithWorkerBridge, options([]));
+	onYamlSchemas((schemas) => monacoYaml.update(options(schemas)));
+}
+function editorText(value) {
+	return value.replace(/\r/g, "");
+}
+var noop = () => {};
+function MonacoEditor({ className, disabled, onChange = noop, onValidate = noop, width = "100%", height = "100%", path = "file:///default", ...options }) {
+	const isDark = useCssIsDark();
+	const readOnly = disabled || options.readOnly;
+	const monacoRef = useRef(null);
+	const isSyncingValueRef = useRef(false);
+	useEffect(() => {
+		if (!monacoRef.current) return;
+		defineEditorThemes(monaco.editor);
+		monaco.editor.setTheme(getThemeName(isDark, disabled));
+		monacoRef.current.updateOptions(readOnly === void 0 ? {} : { readOnly });
+	}, [
+		disabled,
+		isDark,
+		readOnly
+	]);
+	useLayoutEffect(() => {
+		const model = monacoRef.current?.getModel();
+		if (!model || options.value === void 0 || editorText(model.getValue()) === editorText(options.value)) return;
+		isSyncingValueRef.current = true;
+		try {
+			model.setValue(options.value);
+		} finally {
+			isSyncingValueRef.current = false;
+		}
+	}, [options.value]);
+	useEffect(() => {
+		return () => {
+			monacoRef.current?.dispose();
+			monacoRef.current = null;
+		};
+	}, []);
+	/** Strips CR (\r) — Windows line endings break bash scripts. */
+	const onChangeWrapper = (value) => {
+		value = editorText(value);
+		onChange(value);
+	};
+	return /* @__PURE__ */ jsx("div", {
+		style: {
+			width,
+			height
+		},
+		className: cx("relative border rounded", className),
+		ref: (ref) => {
+			if (ref && !monacoRef.current) {
+				monaco.editor.getModel(monaco.Uri.parse(path))?.dispose();
+				defineEditorThemes(monaco.editor);
+				monaco.editor.setTheme(getThemeName(isDark, disabled));
+				const model = monaco.editor.createModel(options.value ?? "", options.language, monaco.Uri.parse(path));
+				const editor = monaco.editor.create(ref, {
+					automaticLayout: true,
+					model,
+					...options,
+					...readOnly === void 0 ? {} : { readOnly },
+					fixedOverflowWidgets: true,
+					suggest: {
+						preview: true,
+						showWords: false,
+						showInlineDetails: true
+					}
+				});
+				model.onDidChangeContent(() => {
+					if (isSyncingValueRef.current) return;
+					onChangeWrapper(editor.getValue());
+				});
+				model.onDidChangeDecorations(() => {
+					onValidate(monaco.editor.getModelMarkers({ resource: model.uri }));
+				});
+				ensureMonacoYamlConfigured();
+				monacoRef.current = editor;
+			}
+		}
+	});
+}
+//#endregion
+export { MonacoEditor as default };

package/dist/editor/index.d.ts

@@ -1,6 +1,7 @@
 export { default as Editor } from './Editor.js';
 export { default as EditorField, type IEditorField } from './EditorField.js';
 export { default as FormCodePanel } from './FormCodePanel.js';
-export type { EditorMarketplaceItem, EditorWorkflowItem, IEditorProps, ISchemaError, } from './Monaco.js';
+export type { IEditorProps, ISchemaError } from './Monaco.js';
 export { defineEditorThemes, getThemeName } from './themes.js';
 export { setupMonacoWorkers } from './workers.js';
+export { configureEditorYaml } from './yaml.js';

package/dist/editor/index.js

@@ -1,2 +1,7 @@
-import { a as EditorField, i as FormCodePanel, n as defineEditorThemes, o as Editor, r as getThemeName, t as setupMonacoWorkers } from "../chunks/editor-9_uVtUyy.js";
-export { Editor, EditorField, FormCodePanel, defineEditorThemes, getThemeName, setupMonacoWorkers };
+import Editor from "./Editor.js";
+import EditorField from "./EditorField.js";
+import FormCodePanel from "./FormCodePanel.js";
+import { defineEditorThemes, getThemeName } from "./themes.js";
+import { setupMonacoWorkers } from "./workers.js";
+import { configureEditorYaml } from "./yaml.js";
+export { Editor, EditorField, FormCodePanel, configureEditorYaml, defineEditorThemes, getThemeName, setupMonacoWorkers };

package/dist/editor/themes.js

@@ -0,0 +1,91 @@
+//#region src/editor/themes.ts
+function expandShorthandHex(color) {
+	return /^#([0-9a-fA-F]{3,4})$/.test(color) ? "#" + color.slice(1).split("").map((c) => c + c).join("") : color;
+}
+function normalizeThemeColors(colors) {
+	return Object.fromEntries(Object.entries(colors).map(([key, value]) => [key, expandShorthandHex(value)]));
+}
+function themeVar(name, fallback) {
+	if (typeof window === "undefined") return fallback;
+	return getComputedStyle(document.documentElement).getPropertyValue(name).trim() || fallback;
+}
+function createEditorThemes() {
+	const dark = {
+		foreground: themeVar("--theme-app", "#e6edf3"),
+		background: themeVar("--theme-panel-bg", "#161b22"),
+		border: themeVar("--theme-border", "#30363d"),
+		lineHighlight: themeVar("--theme-muted-panel-bg", "#21262d"),
+		lineNumber: themeVar("--theme-muted-text-color", "#8b949e"),
+		selection: themeVar("--theme-element", "#2f81f7"),
+		selectionFg: themeVar("--theme-element-text", "#ffffff"),
+		disabledBg: themeVar("--theme-input-disabled-bg", "#1c2128"),
+		disabledFg: themeVar("--theme-muted-text-color", "#8b949e")
+	};
+	const light = {
+		disabledBg: themeVar("--theme-input-disabled-bg", "#f3f4f6"),
+		disabledFg: themeVar("--theme-muted-text-color", "#5f6b76"),
+		border: themeVar("--theme-border", "#d1d5db"),
+		selection: themeVar("--theme-element", "#2f81f7"),
+		selectionFg: themeVar("--theme-element-text", "#ffffff")
+	};
+	return {
+		"app-dark": {
+			base: "vs-dark",
+			inherit: true,
+			rules: [],
+			colors: {
+				"editor.foreground": dark.foreground,
+				"editor.background": dark.background,
+				"editor.border": dark.border,
+				"editorCursor.foreground": dark.foreground,
+				"editor.lineHighlightBackground": dark.lineHighlight,
+				"editorLineNumber.foreground": dark.lineNumber,
+				"editor.selectionBackground": dark.selection,
+				"editor.selectionForeground": dark.selectionFg
+			}
+		},
+		"app-dark-disabled": {
+			base: "vs-dark",
+			inherit: true,
+			rules: [],
+			colors: {
+				"editor.foreground": dark.disabledFg,
+				"editor.background": dark.disabledBg,
+				"editor.border": dark.border,
+				"editorCursor.foreground": "transparent",
+				"editor.lineHighlightBackground": dark.disabledBg,
+				"editorLineNumber.foreground": dark.disabledFg,
+				"editor.selectionBackground": dark.selection,
+				"editor.selectionForeground": dark.selectionFg
+			}
+		},
+		"app-light-disabled": {
+			base: "vs",
+			inherit: true,
+			rules: [],
+			colors: {
+				"editor.foreground": light.disabledFg,
+				"editor.background": light.disabledBg,
+				"editor.border": light.border,
+				"editorCursor.foreground": "transparent",
+				"editor.lineHighlightBackground": light.disabledBg,
+				"editorLineNumber.foreground": light.disabledFg,
+				"editor.selectionBackground": light.selection,
+				"editor.selectionForeground": light.selectionFg
+			}
+		}
+	};
+}
+function defineEditorThemes(monacoEditor) {
+	const themes = createEditorThemes();
+	for (const [name, themeData] of Object.entries(themes)) monacoEditor.defineTheme(name, {
+		...themeData,
+		colors: normalizeThemeColors(themeData.colors)
+	});
+}
+function getThemeName(isDark, disabled) {
+	if (isDark) return disabled ? "app-dark-disabled" : "app-dark";
+	return disabled ? "app-light-disabled" : "vs";
+}
+//#endregion
+export { defineEditorThemes, expandShorthandHex, getThemeName };

package/dist/editor/workers.js

@@ -0,0 +1,29 @@
+//#region src/editor/workers.ts
+var monacoEnvironment = { getWorker(_moduleId, label) {
+	if (label === "json") return new Worker(new URL(
+		/* @vite-ignore */
+		"/assets/json.worker-D8bJ92nw.js",
+		"" + import.meta.url
+	), { type: "module" });
+	if (label === "yaml") return new Worker(new URL(
+		/* @vite-ignore */
+		"/assets/yaml.worker-C4gyGAko.js",
+		"" + import.meta.url
+	), { type: "module" });
+	return new Worker(new URL(
+		/* @vite-ignore */
+		"/assets/editor.worker-BmHUIVG4.js",
+		"" + import.meta.url
+	), { type: "module" });
+} };
+/**
+* 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.
+*/
+function setupMonacoWorkers() {
+	if (window.MonacoEnvironment) return;
+	window.MonacoEnvironment = monacoEnvironment;
+}
+//#endregion
+export { setupMonacoWorkers };

package/dist/editor/yaml.d.ts

@@ -0,0 +1,5 @@
+import type { SchemasSettings } from 'monaco-yaml';
+/** Adds JSON schemas that validate and complete YAML models whose URI matches. */
+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

@@ -0,0 +1,15 @@
+//#region src/editor/yaml.ts
+var schemas = [];
+var apply;
+/** Adds JSON schemas that validate and complete YAML models whose URI matches. */
+function configureEditorYaml(added) {
+	schemas = [...schemas, ...added];
+	apply?.(schemas);
+}
+/** Lets the loaded editor pick up schemas added before or after it loads. */
+function onYamlSchemas(listener) {
+	apply = listener;
+	listener(schemas);
+}
+//#endregion
+export { configureEditorYaml, onYamlSchemas };

package/dist/engine.d.ts

@@ -0,0 +1,98 @@
+export type RunStatus = 'started' | 'running' | 'completed' | 'error' | 'failed' | 'canceled' | 'skipped' | 'faulted' | 'canceling' | 'skipped-failed' | '' | undefined;
+export interface MatrixGroup {
+    originaljob: string;
+    members: string[];
+}
+export interface LogSegment {
+    content: string;
+    className: string;
+    highlighted?: boolean;
+}
+export interface LogCommand {
+    type: 'error' | 'warning' | 'notice' | 'debug' | 'group' | 'endgroup';
+    message: string;
+    params?: Record<string, string>;
+}
+export interface ProcessedLogLine {
+    index: number;
+    segments: LogSegment[];
+    command?: LogCommand;
+    groupDepth: number;
+    groupId?: number;
+}
+export interface WorkflowVariable {
+    key?: string;
+    value?: string | null;
+    secret?: boolean;
+}
+export type WorkflowVariables = Record<string, WorkflowVariable>;
+export interface EvaluateOptions<T> {
+    inputs: unknown;
+    obj: T;
+    path?: string[];
+    schema?: unknown;
+    orgVars?: WorkflowVariables | undefined;
+    userVars?: Record<string, string>;
+    remoteVars?: Record<string, string | undefined> | undefined;
+    secretKeys?: string[];
+    appInfo?: Record<string, unknown>;
+    sessionInfo?: Record<string, string>;
+    index?: number | undefined;
+}
+export interface ExpansionKeys {
+    subworkflowKeys: string[];
+    jobKeys: string[];
+    matrixKeys: string[];
+}
+export interface EngineJob {
+    status?: RunStatus;
+    needs?: string[];
+    if?: boolean | string;
+    steps?: unknown[];
+    _matrix?: {
+        originaljob?: string;
+        index?: number;
+    };
+    _matrixGroup?: MatrixGroup;
+}
+export interface EngineStep {
+    name?: string | undefined;
+    run?: string;
+    uses?: string;
+    subworkflow?: unknown;
+}
+/** The workflow semantics the form, graph, editor and log viewer defer to. */
+export interface WorkflowEngine {
+    /** Starts loading the expression runtime; safe to call repeatedly. */
+    init(): void;
+    isReady(): boolean;
+    /** Calls back when readiness changes; returns an unsubscribe function. */
+    onReady(listener: (ready: boolean) => void): () => void;
+    /** Resolves every `${{ }}` expression in `obj`. */
+    evaluate<T>(options: EvaluateOptions<T>): T;
+    /** Turns a workflow's input definitions into the form's field tree. */
+    convertInputs(inputs: Record<string, unknown>): Record<string, unknown>;
+    inputDependencies(obj: unknown): {
+        inputDeps: Set<string>;
+        hasExpressions: boolean;
+    };
+    jobDependencies(jobName: string, jobs: Record<string, {
+        needs?: string[];
+    }>, memo?: Record<string, Set<string>>): Set<string>;
+    matrixGroups(jobs: Record<string, EngineJob> | undefined): Record<string, MatrixGroup>;
+    /** Rewrites `visibleJobs` in place so each matrix group lays out as one node. */
+    collapseMatrixGroups(groups: Record<string, MatrixGroup>, visibleJobs: Record<string, EngineJob>): void;
+    expansionKeys(jobs: Record<string, EngineJob> | undefined, pathPrefix?: string): ExpansionKeys;
+    matrixStatus(statuses: RunStatus[]): {
+        aggStatus: RunStatus;
+        statusLabel: string;
+    };
+    stepLabel(step: EngineStep, index?: number): string;
+    stepLogPath(subworkflowPrefix: string, jobName: string, stepIndex: number | string): string;
+    isRunActive(status: string | null | undefined): boolean;
+    processLogLines(lines: {
+        index: number;
+        segments: LogSegment[];
+    }[], rawLines: string[]): ProcessedLogLine[];
+    toYaml(value: unknown): string;
+}

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

@@ -1,5 +1,5 @@
 import type { IFileExplorerClient, IFileExplorerProvider } from './lib/fileExplorer.js';
-import type { TreeNode, TStorage } from './lib/types.js';
+import type { ExplorerObject, TreeNode, TStorage } from './lib/types.js';
 interface IFileExplorerProps {
     storages: TStorage[];
     /** Resolves the storage's injected provider pair; the host owns caching. */
@@ -33,6 +33,15 @@ interface IFileExplorerProps {
     initialExpandedPaths?: readonly string[];
     /** Fires whenever the expanded folders change, for the host to persist. */
     onExpandedPathsChange?: (paths: string[]) => void;
+    /** URIs that name an object, shown on its details and offered under Copy;
+     * the first is what Copy URI copies. None hides them. */
+    objectUris?: ((storage: TStorage, key: string) => string[]) | undefined;
+    /** A shell command that downloads files, offered beside the browser
+     * download. An empty command hides it for that selection. */
+    downloadCommand?: {
+        label: string;
+        build: (objects: ExplorerObject[]) => string;
+    } | undefined;
 }
-export default function FileExplorer({ storages, onRefresh, refreshKey, onOpenFile, showUserHierarchy, groups, groupsLoading, selectedPath, onPathChange, getProviderAndClient, treeOnly, initialExpandedPaths, onExpandedPathsChange, }: IFileExplorerProps): import("react").JSX.Element;
+export default function FileExplorer({ storages, onRefresh, refreshKey, onOpenFile, showUserHierarchy, groups, groupsLoading, selectedPath, onPathChange, getProviderAndClient, treeOnly, initialExpandedPaths, onExpandedPathsChange, objectUris, downloadCommand, }: IFileExplorerProps): import("react").JSX.Element;
 export {};