@hachej/boring-ui-kit 0.1.111 → 0.2.0

package/dist/experience-region-text.js

@@ -0,0 +1,84 @@
+import { assertRegionReplacement, experienceRegion } from './experience-region-tree.js';
+function membersOfValidatedJson(text, start) {
+    const whitespace = (index) => { while (/\s/.test(text[index] ?? '') && index < text.length)
+        index++; return index; };
+    const stringEnd = (index) => {
+        for (index++; index < text.length; index++) {
+            if (text[index] === '\\')
+                index++;
+            else if (text[index] === '"')
+                return index + 1;
+        }
+        throw new TypeError('Invalid JSON string');
+    };
+    const valueEnd = (index) => {
+        if (text[index] === '"')
+            return stringEnd(index);
+        if (text[index] !== '{' && text[index] !== '[') {
+            while (index < text.length && !/[\s,}\]]/.test(text[index] ?? ''))
+                index++;
+            return index;
+        }
+        let depth = 0;
+        for (; index < text.length; index++) {
+            if (text[index] === '"') {
+                index = stringEnd(index) - 1;
+                continue;
+            }
+            if (text[index] === '{' || text[index] === '[')
+                depth++;
+            if ((text[index] === '}' || text[index] === ']') && --depth === 0)
+                return index + 1;
+        }
+        throw new TypeError('Invalid JSON container');
+    };
+    start = whitespace(start);
+    if (text[start] !== '{')
+        throw new TypeError('Expected a JSON object');
+    let index = start + 1;
+    const entries = [], keys = new Set();
+    while (text[whitespace(index)] !== '}') {
+        const memberStart = index, keyStart = whitespace(index), keyEnd = stringEnd(keyStart);
+        const key = JSON.parse(text.slice(keyStart, keyEnd));
+        if (typeof key !== 'string' || keys.has(key))
+            throw new TypeError('Ambiguous JSON member');
+        keys.add(key);
+        const colon = whitespace(keyEnd);
+        if (text[colon] !== ':')
+            throw new TypeError('Invalid JSON member');
+        const begin = whitespace(colon + 1), finish = valueEnd(begin), end = whitespace(finish);
+        entries.push({ key, start: memberStart, valueStart: begin, valueEnd: finish, end });
+        if (text[end] === '}')
+            return { entries, end: end + 1 };
+        if (text[end] !== ',')
+            throw new TypeError('Invalid JSON object');
+        index = end + 1;
+    }
+    return { entries, end: whitespace(index) + 1 };
+}
+export function replaceRegionText(text, base, next, name) {
+    assertRegionReplacement(base, next, name);
+    const oldRegion = experienceRegion(base, name), newRegion = experienceRegion(next, name);
+    const root = membersOfValidatedJson(text, 0), elementMember = root.entries.find(member => member.key === 'elements');
+    if (!elementMember)
+        throw new TypeError('Missing experience elements');
+    const elements = membersOfValidatedJson(text, elementMember.valueStart), parts = [];
+    const last = elements.entries.at(-1);
+    for (const member of elements.entries) {
+        const end = member === last ? member.valueEnd : member.end;
+        if (oldRegion.descendants.has(member.key))
+            continue;
+        if (member.key !== oldRegion.id) {
+            parts.push(text.slice(member.start, end));
+            continue;
+        }
+        const region = membersOfValidatedJson(text, member.valueStart), children = region.entries.find(item => item.key === 'children');
+        const value = JSON.stringify(newRegion.node.children);
+        parts.push(children
+            ? text.slice(member.start, children.valueStart) + value + text.slice(children.valueEnd, end)
+            : text.slice(member.start, region.end - 1) + `${region.entries.length ? ',' : ''}"children":${value}` + text.slice(region.end - 1, end));
+    }
+    for (const id of newRegion.descendants)
+        parts.push(`${JSON.stringify(id)}:${JSON.stringify(next.elements[id])}`);
+    return text.slice(0, elementMember.valueStart + 1) + parts.join(',') + text.slice(last?.valueEnd ?? elements.end - 1);
+}

package/dist/experience-region-tree.d.ts

@@ -0,0 +1,22 @@
+import type { ExperienceDescriptor } from './experience-compose.js';
+export declare function experienceRegion(descriptor: ExperienceDescriptor, name: string): {
+    id: string;
+    node: {
+        type: "boring/stack" | "boring/row" | "boring/grid" | "boring/cell" | "boring/generated";
+        props: Record<string, unknown>;
+        children: string[];
+    };
+    path: string[];
+    descendants: Set<string>;
+    props: {
+        region: string;
+        candidates: string[];
+        maxElements: number;
+        minWidth: number;
+        regenerate: ("open" | "phase" | "request")[];
+        kinds?: string[] | undefined;
+        prompt?: string | undefined;
+    };
+};
+export declare function assertRegionReplacement(base: ExperienceDescriptor, next: ExperienceDescriptor, name: string): void;
+//# sourceMappingURL=experience-region-tree.d.ts.map

package/dist/experience-region-tree.js

@@ -0,0 +1,50 @@
+import { layoutProps } from './experience-catalog.js';
+export function experienceRegion(descriptor, name) {
+    const path = [];
+    const find = (id) => {
+        const node = descriptor.elements[id];
+        if (!node)
+            return false;
+        path.push(id);
+        if (node.type === 'boring/generated' && node.props.region === name)
+            return true;
+        for (const child of node.children)
+            if (find(child))
+                return true;
+        path.pop();
+        return false;
+    };
+    if (!find(descriptor.root))
+        throw new TypeError('Unknown generated region');
+    const id = path.at(-1);
+    const node = id === undefined ? undefined : descriptor.elements[id];
+    if (!id || !node)
+        throw new TypeError('Unknown generated region');
+    const descendants = new Set();
+    const collect = (key) => {
+        descendants.add(key);
+        for (const child of descriptor.elements[key]?.children ?? [])
+            collect(child);
+    };
+    for (const child of node.children)
+        collect(child);
+    return { id, node, path, descendants, props: layoutProps['boring/generated'].parse(node.props) };
+}
+export function assertRegionReplacement(base, next, name) {
+    const region = experienceRegion(base, name), replacement = experienceRegion(next, name);
+    const header = ({ elements: _elements, ...rest }) => rest;
+    if (region.id !== replacement.id || JSON.stringify(header(base)) !== JSON.stringify(header(next)))
+        throw new TypeError('Region replacement changed the fixed layout');
+    for (const [id, node] of Object.entries(base.elements)) {
+        if (region.descendants.has(id))
+            continue;
+        const candidate = next.elements[id];
+        const before = id === region.id ? { ...node, children: [] } : node;
+        const after = id === region.id && candidate ? { ...candidate, children: [] } : candidate;
+        if (JSON.stringify(before) !== JSON.stringify(after))
+            throw new TypeError('Region replacement changed a fixed element');
+    }
+    for (const id of Object.keys(next.elements))
+        if (!replacement.descendants.has(id) && !Object.hasOwn(base.elements, id))
+            throw new TypeError('Region replacement added a fixed element');
+}

package/dist/experience-regions.d.ts

@@ -0,0 +1,9 @@
+import type { ExperienceCompositionOptions, ExperienceCompositionSnapshot } from './experience-compose.js';
+export type ExperienceRegionTrigger = 'open' | 'phase' | 'request';
+export interface ExperienceRegionCompositionOptions extends Omit<ExperienceCompositionOptions, 'fallback' | 'layouts'> {
+    readonly descriptor: unknown;
+    readonly region: string;
+    readonly trigger: ExperienceRegionTrigger;
+}
+export declare function composeExperienceRegion(options: ExperienceRegionCompositionOptions): AsyncGenerator<ExperienceCompositionSnapshot>;
+//# sourceMappingURL=experience-regions.d.ts.map

package/dist/experience-regions.js

@@ -0,0 +1,122 @@
+import { z } from 'zod';
+import { composeExperience, validateExperience } from './experience-compose.js';
+import { compositionCandidate, compositionDefinition, compositionLimits, compositionId as newCompositionId } from './experience-composition-schema.js';
+import { experienceRegion } from './experience-region-tree.js';
+import { layoutProps } from './experience-catalog.js';
+function prepareRegion(base, options, access) {
+    const region = experienceRegion(base, options.region);
+    if (!region.props.regenerate.includes(options.trigger))
+        throw new TypeError('Region trigger is not enabled');
+    const prompt = region.props.prompt;
+    if (prompt !== undefined && prompt !== options.intent && prompt !== options.definition.intents[options.intent])
+        throw new TypeError('Region prompt is not a registered intent');
+    const constraints = region.path.flatMap(id => {
+        const node = base.elements[id];
+        return node?.type === 'boring/generated' ? [experienceRegion(base, String(node.props.region))] : [];
+    });
+    const allowedKind = (kind) => Object.hasOwn(base.kinds, kind) && constraints.every(item => item.props.kinds === undefined || item.props.kinds.includes(kind));
+    const used = new Map();
+    for (const [id, node] of Object.entries(base.elements))
+        if (!region.descendants.has(id) && node.type === 'boring/cell') {
+            const { ref } = layoutProps['boring/cell'].parse(node.props);
+            used.set(ref, (used.get(ref) ?? 0) + 1);
+        }
+    const cells = access.cells.flatMap(cell => {
+        const remaining = (cell.maxUses ?? 1) - (used.get(cell.ref) ?? 0);
+        return remaining > 0 && allowedKind('boring/cell') && allowedKind(cell.kind)
+            && constraints.every(item => item.props.candidates.includes(cell.ref) || item.props.candidates.includes(cell.kind))
+            ? [{ ...cell, maxUses: remaining }] : [];
+    });
+    const candidates = options.candidates.filter(candidate => cells.some(cell => cell.ref === candidate.ref));
+    if (candidates.length === 0)
+        throw new TypeError('Region has no eligible candidates');
+    const layouts = ['boring/stack', 'boring/row', 'boring/grid'].filter(allowedKind);
+    const outside = Object.keys(base.elements).length - region.descendants.size;
+    const maxElements = Math.min(options.limits.maxElements, 200 - outside, ...constraints.map(item => item.props.maxElements - (item.descendants.size - region.descendants.size)));
+    if (maxElements < 1)
+        throw new TypeError('Region has no available element budget');
+    const maxDepth = Math.min(options.limits.maxDepth, 25 - region.path.length);
+    if (maxDepth < 1)
+        throw new TypeError('Region has no available depth');
+    const limits = { ...options.limits, maxElements, maxDepth };
+    return { region, options: { ...options, cells, candidates, layouts, limits, fallback: null } };
+}
+function mergeRegion(base, prepared, subtree, prefix, access) {
+    const elements = new Map(Object.entries(base.elements).filter(([id]) => !prepared.region.descendants.has(id)));
+    const names = new Map(Object.keys(subtree.elements).map((id, index) => [id, `${prefix}_${index}`]));
+    const renamed = (id) => {
+        const name = names.get(id);
+        if (!name || Object.hasOwn(base.elements, name))
+            throw new TypeError('Invalid region element identity');
+        return name;
+    };
+    for (const [kind, version] of Object.entries(subtree.kinds))
+        if (base.kinds[kind] !== version)
+            throw new TypeError('Undeclared region kind');
+    for (const [id, node] of Object.entries(subtree.elements))
+        elements.set(renamed(id), { ...node, children: node.children.map(renamed) });
+    elements.set(prepared.region.id, { ...prepared.region.node, children: [renamed(subtree.root)] });
+    return validateExperience({ ...base, elements: Object.fromEntries(elements) }, access);
+}
+export async function* composeExperienceRegion(options) {
+    const compositionId = newCompositionId(), prefix = `r_${compositionId}`;
+    const { canView, evaluate, signal, intent, region, trigger } = options;
+    const access = { cells: options.cells.map(cell => ({ ...cell })), canView };
+    let base, prepared;
+    let sequence = 0;
+    const captured = (() => {
+        try {
+            const parsed = compositionDefinition.parse(options.definition);
+            const definition = { name: parsed.name, intents: parsed.intents, kinds: parsed.kinds, ...(parsed.title === undefined ? {} : { title: parsed.title }) };
+            const candidates = z.array(compositionCandidate).max(128).parse(options.candidates).map(({ ref, metadata, root, resource }) => ({ ref, metadata, ...(root === undefined ? {} : { root }), ...(resource === undefined ? {} : { resource }) }));
+            return { definition, candidates, limits: compositionLimits.parse(options.limits) };
+        }
+        catch {
+            return null;
+        }
+    })();
+    try {
+        base = validateExperience(options.descriptor, access);
+        signal.throwIfAborted();
+        if (captured)
+            prepared = prepareRegion(base, { ...access, ...captured, evaluate, signal, intent, region, trigger, descriptor: base }, access);
+    }
+    catch {
+        prepared = undefined;
+    }
+    const fallback = () => {
+        try {
+            return base === undefined ? null : validateExperience(base, access);
+        }
+        catch {
+            return null;
+        }
+    };
+    const snapshot = (reason) => Object.freeze({ compositionId, sequence: sequence++, kind: 'default', descriptor: fallback(), reason });
+    yield snapshot('pending');
+    if (!base || !prepared) {
+        yield snapshot(signal.aborted ? 'cancelled' : 'unavailable');
+        return;
+    }
+    try {
+        for await (const event of composeExperience({ ...prepared.options, evaluate: request => {
+                if (!fallback())
+                    throw new TypeError('Region default is no longer available');
+                signal.throwIfAborted();
+                return evaluate(request);
+            } })) {
+            signal.throwIfAborted();
+            if (event.kind === 'default') {
+                if (event.reason !== 'pending')
+                    yield snapshot(event.reason);
+                continue;
+            }
+            const descriptor = mergeRegion(base, prepared, event.descriptor, prefix, access);
+            signal.throwIfAborted();
+            yield Object.freeze({ compositionId, sequence: sequence++, kind: event.kind, descriptor });
+        }
+    }
+    catch {
+        yield snapshot(signal.aborted ? 'cancelled' : 'unavailable');
+    }
+}

package/dist/experience-renderer.d.ts

@@ -0,0 +1,16 @@
+import type { ReactNode } from 'react';
+import type { ExperienceAccess, ExperienceCell, ExperienceDescriptor } from './experience-compose.js';
+/** A cell the host can show: its access record plus how to render it. */
+export interface RenderedExperienceCell extends ExperienceCell {
+    readonly render: () => ReactNode;
+}
+interface LiveCells {
+    readonly cells: readonly RenderedExperienceCell[];
+    readonly canView: ExperienceAccess['canView'];
+    readonly kinds: ExperienceDescriptor['kinds'];
+}
+export declare function ExperienceRenderer({ descriptor, cells, canView }: Omit<LiveCells, 'kinds'> & {
+    readonly descriptor: ExperienceDescriptor;
+}): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=experience-renderer.d.ts.map

package/dist/experience-renderer.js

@@ -0,0 +1,37 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from 'react';
+import { defineRegistry, JSONUIProvider, Renderer } from '@json-render/react';
+import { experienceCatalog } from './experience-catalog.js';
+const CellContext = createContext(null);
+const MinimumWidth = createContext(0);
+const gaps = { small: '0.5rem', medium: '1rem', large: '1.5rem' };
+const { registry } = defineRegistry(experienceCatalog, { components: {
+        'boring/stack': ({ props, children }) => _jsx("div", { "data-boring": "experience-stack", style: { display: 'flex', flexDirection: 'column', gap: gaps[props.gap] }, children: children }),
+        'boring/row': ({ props, children }) => _jsx("div", { "data-boring": "experience-row", style: { display: 'flex', flexWrap: 'wrap', gap: gaps[props.gap] }, children: children }),
+        'boring/grid': ({ props, children }) => {
+            const minimumWidth = useContext(MinimumWidth);
+            return _jsx("div", { "data-boring": "experience-grid", style: { display: 'grid', gridTemplateColumns: `repeat(${props.columns}, minmax(${minimumWidth}px, 1fr))`, gap: gaps[props.gap] }, children: children });
+        },
+        'boring/cell': ({ props }) => {
+            const live = useContext(CellContext);
+            const matches = live?.cells.filter(cell => cell.ref === props.ref) ?? [];
+            const cell = matches.length === 1 ? matches[0] : undefined;
+            let permitted = false;
+            try {
+                permitted = !!cell && live?.kinds[cell.kind] === cell.version && live.canView(cell.ref) === true;
+            }
+            catch {
+                permitted = false;
+            }
+            const minimumWidth = useContext(MinimumWidth);
+            return _jsx("div", { "data-boring": "experience-cell", style: { minWidth: minimumWidth, flexShrink: 0 }, children: permitted && cell ? _jsx(cell.render, {}) : _jsx("p", { role: "status", children: "Cell unavailable" }) });
+        },
+        'boring/generated': ({ props, children }) => {
+            const minimumWidth = Math.max(useContext(MinimumWidth), props.minWidth);
+            return _jsx("div", { "data-boring": "experience-region", "data-region": props.region, style: { overflowX: 'auto', minWidth: 0 }, children: _jsx(MinimumWidth, { value: minimumWidth, children: children }) });
+        },
+    } });
+export function ExperienceRenderer({ descriptor, cells, canView }) {
+    return _jsx(CellContext, { value: { cells, canView, kinds: descriptor.kinds }, children: _jsx(JSONUIProvider, { registry: registry, children: _jsx(Renderer, { spec: descriptor, registry: registry }) }) });
+}

package/dist/experience.d.ts

@@ -0,0 +1,12 @@
+import type { RenderedExperienceCell } from './experience-renderer.js';
+import type { ExperienceAccess } from './experience-compose.js';
+export { ExperienceRenderer } from './experience-renderer.js';
+export type { RenderedExperienceCell } from './experience-renderer.js';
+export interface ExperienceProps {
+    readonly descriptor: unknown;
+    readonly cells: readonly RenderedExperienceCell[];
+    readonly canView: ExperienceAccess['canView'];
+    readonly className?: string;
+}
+export declare function Experience(props: ExperienceProps): import("react").JSX.Element;
+//# sourceMappingURL=experience.d.ts.map

package/dist/experience.js

@@ -0,0 +1,23 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { ExperienceRenderer } from './experience-renderer.js';
+import { validateExperience } from './experience-compose.js';
+export { ExperienceRenderer } from './experience-renderer.js';
+function select(props) {
+    try {
+        return { input: props.descriptor, kind: 'ready', descriptor: validateExperience(props.descriptor, props) };
+    }
+    catch {
+        return { input: props.descriptor, kind: 'invalid' };
+    }
+}
+export function Experience(props) {
+    const [current, setCurrent] = useState(() => select(props));
+    const candidate = current.input === props.descriptor && current.kind === 'ready' ? null : select(props);
+    const offered = candidate?.kind === 'invalid' && current.kind === 'invalid' ? null : candidate;
+    return _jsxs("section", { "data-boring": "experience", className: props.className, "aria-label": current.kind === 'ready' ? current.descriptor.title ?? current.descriptor.name : 'Experience unavailable', children: [offered && (offered.kind === 'ready'
+                ? _jsx("button", { type: "button", onClick: () => setCurrent(offered), children: "Use proposed layout" })
+                : _jsx("p", { role: "alert", children: "Proposed layout unavailable. The current layout has been retained." })), current.kind === 'invalid' ? _jsx("p", { role: "alert", children: "Experience unavailable" })
+                : _jsx(ExperienceRenderer, { descriptor: current.descriptor, cells: props.cells, canView: props.canView })] });
+}

package/dist/file-tree-shadcn.d.ts

@@ -0,0 +1,8 @@
+import type { ComponentProps } from 'react';
+export declare function SidebarMenu({ className, ...props }: ComponentProps<'ul'>): import("react").JSX.Element;
+export declare function SidebarMenuItem({ className, ...props }: ComponentProps<'li'>): import("react").JSX.Element;
+export declare function SidebarMenuButton({ className, isActive, ...props }: ComponentProps<'button'> & {
+    readonly isActive?: boolean;
+}): import("react").JSX.Element;
+export declare function SidebarMenuSub({ className, ...props }: ComponentProps<'ul'>): import("react").JSX.Element;
+//# sourceMappingURL=file-tree-shadcn.d.ts.map

package/dist/file-tree-shadcn.js

@@ -0,0 +1,14 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+export function SidebarMenu({ className = '', ...props }) {
+    return _jsx("ul", { "data-slot": "sidebar-menu", "data-sidebar": "menu", className: `flex w-full min-w-0 flex-col gap-1 ${className}`, ...props });
+}
+export function SidebarMenuItem({ className = '', ...props }) {
+    return _jsx("li", { "data-slot": "sidebar-menu-item", "data-sidebar": "menu-item", className: `group/menu-item relative ${className}`, ...props });
+}
+export function SidebarMenuButton({ className = '', isActive = false, ...props }) {
+    return _jsx("button", { type: "button", "data-slot": "sidebar-menu-button", "data-sidebar": "menu-button", "data-size": "default", "data-active": isActive, className: `peer/menu-button flex h-8 w-full items-center gap-2 overflow-hidden rounded-md p-2 text-left text-sm ring-sidebar-ring outline-hidden transition-[width,height,padding] hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:ring-2 active:bg-sidebar-accent active:text-sidebar-accent-foreground disabled:pointer-events-none disabled:opacity-50 aria-disabled:pointer-events-none aria-disabled:opacity-50 data-[active=true]:bg-sidebar-accent data-[active=true]:font-medium data-[active=true]:text-sidebar-accent-foreground data-[state=open]:hover:bg-sidebar-accent data-[state=open]:hover:text-sidebar-accent-foreground [&>span:last-child]:truncate [&>svg]:size-4 [&>svg]:shrink-0 ${className}`, ...props });
+}
+export function SidebarMenuSub({ className = '', ...props }) {
+    return _jsx("ul", { "data-slot": "sidebar-menu-sub", "data-sidebar": "menu-sub", className: `mx-3.5 flex min-w-0 translate-x-px flex-col gap-1 border-l border-sidebar-border px-2.5 py-0.5 ${className}`, ...props });
+}

package/dist/file-tree-view.d.ts

@@ -0,0 +1,64 @@
+import type { RevisionProvider } from '@hachej/boring-files/revision';
+import type { FileTreeController } from './file-tree.js';
+/** Every word of the tree, so a host can translate it. Functions receive what they name. */
+export declare const defaultFileTreeLabels: {
+    region: string;
+    tree: string;
+    search: string;
+    searchPlaceholder: string;
+    refresh: string;
+    upload: string;
+    uploadFiles: string;
+    uploads: string;
+    loading: string;
+    retry: string;
+    noMatches: string;
+    empty: string;
+    loadMore: string;
+    history: string;
+    historyOf: (path: string) => string;
+    closeHistory: string;
+    loadingHistory: string;
+    noHistory: string;
+    earlierVersion: string;
+    historyUnavailable: string;
+    revisionUnavailable: string;
+    readOnlyRevision: (bytes: number) => string;
+    binaryFile: (mediaType: string) => string;
+    uploading: string;
+    saved: string;
+    unconfirmed: string;
+    checkUpload: string;
+    uploadStatusUnavailable: string;
+    uploadFailed: (name: string) => string;
+};
+export type FileTreeLabels = typeof defaultFileTreeLabels;
+/** The tree's words in French (`locale="fr"`). */
+export declare const frenchFileTreeLabels: FileTreeLabels;
+/** The languages the tree ships with; anything else is set word by word through `labels`. */
+export type FileTreeLocale = 'en' | 'fr';
+export interface FileTreeProps {
+    readonly revisionProvider: RevisionProvider;
+    readonly onOpen?: (path: string) => void;
+    readonly selectedPath?: string;
+    readonly className?: string;
+    readonly uploadDirectory?: string;
+    /** The tree's language. Default `en`. */
+    readonly locale?: FileTreeLocale;
+    /** Words over the locale's, for a language or a wording the tree does not ship with. */
+    readonly labels?: Partial<FileTreeLabels>;
+    /** Offer the Upload button. Default true. */
+    readonly upload?: boolean;
+    /** Offer each file's History button. Default true. */
+    readonly history?: boolean;
+    /** Reload the open folders and the current search whenever this value changes (for example after the agent saves a file). */
+    readonly refreshKey?: unknown;
+}
+/** One borrowed binding powers browsing, search, upload and history. Historical previews never replace an editor's draft. */
+export declare function FileTree(props: FileTreeProps): import("react").JSX.Element;
+export interface FileTreeViewProps extends Omit<FileTreeProps, 'revisionProvider'> {
+    readonly controller: FileTreeController;
+}
+/** Renders a borrowed controller, for a workspace whose chat and tree share upload state. */
+export declare function FileTreeView({ controller, onOpen, selectedPath, className, uploadDirectory, locale, labels: given, upload, history, refreshKey }: FileTreeViewProps): import("react").JSX.Element;
+//# sourceMappingURL=file-tree-view.d.ts.map