@undefineds.co/xpod 0.3.57 → 0.3.61

package/node_modules/@undefineds.co/extension-sdk/README.md

@@ -0,0 +1,299 @@
+# Applet SDK
+
+`@undefineds.co/extension-sdk` defines the boundary between an applet and the
+host that runs it. An applet declares its identity, layout structure, and
+content slots. The host owns authentication, Pod initialization, application
+navigation, native capabilities, and final composition.
+
+The first planned product consumer is Xpod. Xpod can use the same layout
+language as Linx while exposing a settings-first entry such as Models, Pod,
+Network, and Services. Linx production layout remains on its current
+composition until a later migration.
+
+## Layout responsibilities
+
+The SDK has two layout layers:
+
+- `AppLayout` is host-owned. It renders the outer application frame, including
+  product navigation, host header, and the active applet surface.
+- `SinglePaneLayout`, `TwoPaneLayout`, and `ThreePaneLayout` render applet
+  workspaces inside the host frame. They own pane geometry, responsive
+  list-to-detail navigation, separators, and scroll containment.
+
+Applets do not render product navigation, inspect viewport width, or branch on
+whether they run in Linx, Xpod, or a standalone host.
+
+## Define an applet
+
+New applets should use a descriptor-based layout module. The manifest keeps the
+legacy layout field for extension discovery, and the `layout.descriptor` gives
+hosts a portable workspace contract.
+
+```tsx
+import {
+  defineApplet,
+  defineAppletLayout,
+  type WebExtensionHost,
+} from '@undefineds.co/extension-sdk/web'
+
+type NotesController = {
+  host: WebExtensionHost
+}
+
+export const notesApplet = defineApplet({
+  manifest: {
+    appId: 'https://example.com/applets/notes',
+    name: 'Notes',
+    entry: '.',
+    commands: [],
+    layout: 'two-pane',
+  },
+  layout: {
+    descriptor: defineAppletLayout({ type: 'two-pane' }),
+    slots: {
+      listHeader: () => <input aria-label="Search notes" />,
+      list: () => <nav aria-label="Notes">Notes list</nav>,
+      mainHeader: () => <h1>Notes</h1>,
+      main: ({ controller }) => {
+        const { pod } = controller.host.solid
+        return pod.status === 'ready'
+          ? <main>{pod.current.podUrl}</main>
+          : <main>Pod unavailable</main>
+      },
+    },
+  },
+  createController: (host): NotesController => ({ host }),
+})
+```
+
+Single-pane modules provide `layout.render`. Three-pane modules provide
+`layout.slots.listHeader`, `list`, `mainHeader`, `main`, and `context`, plus
+optional descriptor context:
+
+```tsx
+defineAppletLayout({
+  type: 'three-pane',
+  context: { collapsible: true, initiallyCollapsed: false },
+})
+```
+
+## Compose from a host
+
+The host creates one `WebExtensionHost`, calls `useApplet`, and resolves the
+mounted layout variant to SDK workspace layouts. The surrounding `AppLayout`
+belongs to the host, so Xpod and Linx can share geometry while keeping different
+navigation models.
+
+```tsx
+import {
+  AppLayout,
+  SinglePaneLayout,
+  ThreePaneLayout,
+  TwoPaneLayout,
+  useApplet,
+} from '@undefineds.co/extension-sdk/react'
+import type {
+  AppletModule,
+  WebExtensionHost,
+} from '@undefineds.co/extension-sdk/web'
+
+function AppletSurface({
+  applet,
+  host,
+}: {
+  applet: AppletModule
+  host: WebExtensionHost
+}) {
+  const mounted = useApplet(applet, host)
+
+  if (!mounted) return null
+
+  if (mounted.layout === 'single-pane') {
+    return <SinglePaneLayout main={mounted.element} />
+  }
+
+  if (mounted.layout === 'three-pane') {
+    return (
+      <ThreePaneLayout
+        listHeader={mounted.slots.listHeader}
+        list={mounted.slots.list}
+        mainHeader={mounted.slots.mainHeader}
+        main={mounted.slots.main}
+        context={mounted.slots.context}
+        contextConfig={mounted.contextConfig}
+      />
+    )
+  }
+
+  return (
+    <TwoPaneLayout
+      listHeader={mounted.slots.listHeader}
+      list={mounted.slots.list}
+      mainHeader={mounted.slots.mainHeader}
+      main={mounted.slots.main}
+    />
+  )
+}
+
+export function XpodSettingsHost({
+  applet,
+  host,
+}: {
+  applet: AppletModule
+  host: WebExtensionHost
+}) {
+  return (
+    <AppLayout
+      navigation={<nav aria-label="Xpod settings">Models / Pod / Network</nav>}
+    >
+      <AppletSurface applet={applet} host={host} />
+    </AppLayout>
+  )
+}
+```
+
+`useApplet` creates one controller for a stable applet/host pair, calls
+`activate` after mounting, and balances cleanup when disabled, replaced, or
+unmounted. `mountTwoPaneApplet` remains as a low-level compatibility helper;
+new hosts should prefer `useApplet` and the mounted layout union.
+
+For stack-mode navigation, hosts may pass a `history` adapter to
+`TwoPaneLayout` or `ThreePaneLayout`. The SDK moves focus to the active pane
+and calls the adapter on user navigation, but it does not write to
+`window.history` directly. Browser hosts can map the adapter to their router or
+to `popstate` handling; embedded hosts can omit it.
+
+## Authentication boundary
+
+`AuthBoundary` and `LoginView` standardize presentation only. They do not own a
+Solid session, create an Inrupt session, start a second OIDC flow, persist
+tokens, or decide return-path behavior. The host maps its existing session
+runtime into a typed boundary state and passes the login callback.
+
+```tsx
+import {
+  AuthBoundary,
+  type AuthBoundaryState,
+} from '@undefineds.co/extension-sdk/react'
+
+function SolidGate({
+  state,
+  login,
+  children,
+}: {
+  state: AuthBoundaryState
+  login: (issuer: string) => Promise<void>
+  children: React.ReactNode
+}) {
+  return (
+    <AuthBoundary
+      state={state}
+      login={login}
+      loginView={{
+        title: 'Connect Solid Pod',
+        description: '登录后即可访问当前 Pod 的 applet 数据。',
+        defaultIssuer: 'https://solidcommunity.net',
+      }}
+    >
+      {children}
+    </AuthBoundary>
+  )
+}
+```
+
+The host remains responsible for Solid OIDC operations, session restoration,
+logout, token refresh, and return-path handling. This is the same contract when
+the applet runs in Linx, Xpod, or an isolated test host.
+
+## Solid and data rules
+
+An applet receives Solid through `host.solid`:
+
+- Use `host.solid.session.fetch` for authenticated network requests.
+- Read the already-opened database and collection state from
+  `host.solid.pod`; do not initialize Inrupt OIDC, drizzle-solid, or
+  collections inside the applet.
+- Call `host.solid.requireLogin()` when an anonymous standalone host needs
+  login. The host supplies the shared login UI and OIDC flow.
+- Import RDF schemas from `@undefineds.co/models`.
+- Perform Pod CRUD with drizzle-solid. Collections own hydration and reactive
+  query setup.
+- Never accept or persist bearer tokens, DPoP material, API keys, or refresh
+  tokens in browser storage. User AI credentials remain encrypted in the Pod
+  through the Xpod service boundary.
+
+Applet code must not branch on deployment shape such as local or cloud. Data and
+capabilities should be self-describing through the host contract.
+
+## Legacy compatibility
+
+The previous applet shape is still supported:
+
+```tsx
+defineApplet({
+  manifest: {
+    appId: 'https://example.com/applets/legacy',
+    name: 'Legacy',
+    entry: '.',
+    commands: [],
+    layout: 'two-pane',
+  },
+  createController: (host) => ({ host }),
+  slots: {
+    listHeader: () => <input aria-label="Search legacy items" />,
+    list: () => <nav>Items</nav>,
+    mainHeader: () => <h1>Legacy</h1>,
+    main: () => <main>Detail</main>,
+  },
+})
+```
+
+Keep this path for existing applets and tests. Prefer descriptors for new
+applets so hosts can resolve layout structure consistently across products.
+
+## Test independently
+
+Use the SDK mock host to test applet behavior without launching Linx or
+implementing OIDC. Tests can provide anonymous, ready, or failed Solid
+capabilities.
+
+```tsx
+import { render, screen } from '@testing-library/react'
+import { TwoPaneLayout, useApplet } from '@undefineds.co/extension-sdk/react'
+import { createMockWebExtensionHost } from '@undefineds.co/extension-sdk/testing'
+
+const host = createMockWebExtensionHost({ solid: readySolidCapability })
+
+function Harness() {
+  const mounted = useApplet(notesApplet, host)
+  return mounted?.layout === 'two-pane'
+    ? (
+      <TwoPaneLayout
+        mode="stack"
+        listHeader={mounted.slots.listHeader}
+        list={mounted.slots.list}
+        mainHeader={mounted.slots.mainHeader}
+        main={mounted.slots.main}
+      />
+    )
+    : null
+}
+
+render(<Harness />)
+screen.getByRole('heading', { name: 'Notes' })
+```
+
+See [`examples/extension-test-host`](../../examples/extension-test-host) for a
+running isolated host that composes `AppLayout`, `AuthBoundary`, SDK workspace
+layouts, and the AI Connection applet.
+
+## Public entry points
+
+- `@undefineds.co/extension-sdk`: framework-neutral manifest, layout,
+  lifecycle, testing, and React exports for package-internal consumers.
+- `@undefineds.co/extension-sdk/manifest`: manifest contracts.
+- `@undefineds.co/extension-sdk/web`: applet definitions, layout descriptors,
+  mounting, and host capabilities.
+- `@undefineds.co/extension-sdk/react`: `AppLayout`, workspace layouts,
+  `AuthBoundary`, `LoginView`, and `useApplet`.
+- `@undefineds.co/extension-sdk/testing`: deterministic host test doubles.

package/node_modules/@undefineds.co/extension-sdk/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './manifest';
+export * from './layout';
+export * from './react';
+export * from './testing';
+export * from './web';

package/node_modules/@undefineds.co/extension-sdk/dist/index.js

@@ -0,0 +1,5 @@
+export * from './manifest.js';
+export * from './layout.js';
+export * from './react.js';
+export * from './testing.js';
+export * from './web.js';

package/node_modules/@undefineds.co/extension-sdk/dist/layout.d.ts

@@ -0,0 +1,16 @@
+export type AppletLayoutType = 'single-pane' | 'two-pane' | 'three-pane';
+export type SinglePaneAppletLayoutDescriptor = {
+    readonly type: 'single-pane';
+};
+export type TwoPaneAppletLayoutDescriptor = {
+    readonly type: 'two-pane';
+};
+export type ThreePaneAppletLayoutDescriptor = {
+    readonly type: 'three-pane';
+    readonly context?: {
+        readonly collapsible?: boolean;
+        readonly initiallyCollapsed?: boolean;
+    };
+};
+export type AppletLayoutDescriptor = SinglePaneAppletLayoutDescriptor | TwoPaneAppletLayoutDescriptor | ThreePaneAppletLayoutDescriptor;
+export declare function defineAppletLayout<T extends AppletLayoutDescriptor>(descriptor: T): T;

package/node_modules/@undefineds.co/extension-sdk/dist/layout.js

@@ -0,0 +1,36 @@
+export function defineAppletLayout(descriptor) {
+    if (!isPlainDescriptorObject(descriptor)) {
+        throw new Error('Applet layout descriptor must be an object');
+    }
+    if (typeof descriptor.type !== 'string') {
+        throw new Error('Applet layout descriptor type must be a string');
+    }
+    switch (descriptor.type) {
+        case 'single-pane':
+        case 'two-pane':
+            assertValidLayoutContext(descriptor.context);
+            return descriptor;
+        case 'three-pane':
+            assertValidLayoutContext(descriptor.context);
+            return descriptor;
+        default:
+            throw new Error(`Unsupported applet layout type: ${descriptor.type}`);
+    }
+}
+function isPlainDescriptorObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function assertValidLayoutContext(context) {
+    if (context === undefined) {
+        return;
+    }
+    if (!isPlainDescriptorObject(context)) {
+        throw new Error('Applet layout descriptor context must be an object');
+    }
+    if ('collapsible' in context && typeof context.collapsible !== 'boolean') {
+        throw new Error('Applet layout descriptor context.collapsible must be a boolean');
+    }
+    if ('initiallyCollapsed' in context && typeof context.initiallyCollapsed !== 'boolean') {
+        throw new Error('Applet layout descriptor context.initiallyCollapsed must be a boolean');
+    }
+}

package/node_modules/@undefineds.co/extension-sdk/dist/manifest.d.ts

@@ -0,0 +1,27 @@
+export declare const HOST_CAPABILITY_NAMES: readonly ["navigation.openExternal", "aiClientConfiguration"];
+export type HostCapabilityName = (typeof HOST_CAPABILITY_NAMES)[number];
+export type AppletLayoutKind = 'single-pane' | 'two-pane';
+export interface AppletCommandDeclaration {
+    id: string;
+    title: string;
+}
+export interface AppletManifest {
+    appId: string;
+    name: string;
+    entry: string;
+    commands: AppletCommandDeclaration[];
+    layout: AppletLayoutKind;
+}
+export interface ExtensionManifest {
+    extensionId: string;
+    name: string;
+    version: string;
+    sdkVersion: string;
+    contributes: {
+        applets: AppletManifest[];
+    };
+    dataModels: string[];
+    hostCapabilities: HostCapabilityName[];
+}
+export declare function deriveAppletRouteId(manifest: Pick<AppletManifest, 'appId'>): string;
+export declare function validateExtensionManifest(value: unknown): ExtensionManifest;

package/node_modules/@undefineds.co/extension-sdk/dist/manifest.js

@@ -0,0 +1,79 @@
+export const HOST_CAPABILITY_NAMES = [
+    'navigation.openExternal',
+    'aiClientConfiguration',
+];
+export function deriveAppletRouteId(manifest) {
+    const segments = new URL(manifest.appId).pathname.split('/').filter(Boolean);
+    const encodedRouteId = segments[segments.length - 1];
+    const routeId = encodedRouteId ? decodeURIComponent(encodedRouteId) : undefined;
+    if (!routeId || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(routeId)) {
+        throw new Error(`Applet appId cannot produce a safe route id: ${manifest.appId}`);
+    }
+    return routeId;
+}
+export function validateExtensionManifest(value) {
+    const manifest = requireRecord(value, 'Extension manifest');
+    requireHttpsUrl(manifest.extensionId, 'extensionId');
+    requireString(manifest.name, 'name');
+    requireString(manifest.version, 'version');
+    requireString(manifest.sdkVersion, 'sdkVersion');
+    const contributes = requireRecord(manifest.contributes, 'contributes');
+    if (!Array.isArray(contributes.applets) || contributes.applets.length === 0) {
+        throw new Error('Extension manifest must contribute at least one Applet');
+    }
+    const appIds = new Set();
+    for (const value of contributes.applets) {
+        const applet = requireRecord(value, 'Applet manifest');
+        const appId = requireHttpsUrl(applet.appId, 'appId');
+        if (appIds.has(appId)) {
+            throw new Error(`Extension manifest has duplicate appId: ${appId}`);
+        }
+        appIds.add(appId);
+        requireString(applet.name, 'Applet name');
+        requireString(applet.entry, 'Applet entry');
+        if (!Array.isArray(applet.commands)) {
+            throw new Error('Applet commands must be an array');
+        }
+        if (applet.layout !== 'single-pane' && applet.layout !== 'two-pane') {
+            throw new Error('Applet layout must be single-pane or two-pane');
+        }
+    }
+    if (!Array.isArray(manifest.dataModels)) {
+        throw new Error('Extension dataModels must be an array');
+    }
+    if (!Array.isArray(manifest.hostCapabilities)) {
+        throw new Error('Extension hostCapabilities must be an array');
+    }
+    for (const capability of manifest.hostCapabilities) {
+        if (!HOST_CAPABILITY_NAMES.includes(capability)) {
+            throw new Error(`Extension manifest requested unknown Host capability: ${String(capability)}`);
+        }
+    }
+    return value;
+}
+function requireRecord(value, field) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`${field} must be an object`);
+    }
+    return value;
+}
+function requireString(value, field) {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new Error(`${field} must be a non-empty string`);
+    }
+    return value;
+}
+function requireHttpsUrl(value, field) {
+    const text = requireString(value, field);
+    let url;
+    try {
+        url = new URL(text);
+    }
+    catch {
+        throw new Error(`${field} must be a valid HTTPS URL`);
+    }
+    if (url.protocol !== 'https:') {
+        throw new Error(`${field} must be a valid HTTPS URL`);
+    }
+    return text;
+}

package/node_modules/@undefineds.co/extension-sdk/dist/react/app-layout.d.ts

@@ -0,0 +1,7 @@
+import { type ReactNode } from 'react';
+export interface AppLayoutProps {
+    navigation: ReactNode;
+    children: ReactNode;
+    className?: string;
+}
+export declare function AppLayout({ navigation, children, className, }: AppLayoutProps): import("react").JSX.Element;

package/node_modules/@undefineds.co/extension-sdk/dist/react/app-layout.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from '@undefineds.co/shared-ui';
+const appLayoutGridStyle = {
+    gridTemplateColumns: '60px minmax(0, 1fr)',
+};
+export function AppLayout({ navigation, children, className, }) {
+    return (_jsxs("section", { className: cn('grid h-screen min-h-0 bg-background', className), style: appLayoutGridStyle, "data-app-layout": "workspace", children: [_jsx("aside", { className: "min-h-0 overflow-hidden border-r border-border/50 bg-layout-sidebar", children: navigation }), _jsx("div", { className: "min-h-0 min-w-0 overflow-hidden bg-layout-content", children: children })] }));
+}

package/node_modules/@undefineds.co/extension-sdk/dist/react/auth-boundary.d.ts

@@ -0,0 +1,27 @@
+import { type ReactNode } from 'react';
+export type AuthBoundaryState = {
+    status: 'loading';
+} | {
+    status: 'anonymous';
+} | {
+    status: 'authenticated';
+} | {
+    status: 'error';
+    message: string;
+};
+export interface LoginViewProps {
+    title: ReactNode;
+    description?: ReactNode;
+    defaultIssuer?: string;
+    logo?: ReactNode;
+    error?: string;
+    onLogin: (issuer: string) => void | Promise<void>;
+}
+export interface AuthBoundaryProps {
+    state: AuthBoundaryState;
+    login: (issuer: string) => void | Promise<void>;
+    children: ReactNode;
+    loginView?: Omit<LoginViewProps, 'error' | 'onLogin'>;
+}
+export declare function LoginView({ title, description, defaultIssuer, logo, error, onLogin, }: LoginViewProps): import("react").JSX.Element;
+export declare function AuthBoundary({ state, login, children, loginView, }: AuthBoundaryProps): import("react").JSX.Element;

package/node_modules/@undefineds.co/extension-sdk/dist/react/auth-boundary.js

@@ -0,0 +1,49 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useId, useMemo, useState } from 'react';
+import { Button, Input } from '@undefineds.co/shared-ui';
+const defaultLoginTitle = 'Connect Solid Pod';
+const safeLoginErrorMessage = '登录失败，请重试。';
+function normalizeLoginError() {
+    return safeLoginErrorMessage;
+}
+function AuthSurface({ children, labelledBy, }) {
+    return (_jsx("section", { className: "flex min-h-screen items-center justify-center bg-background px-6 py-10 text-foreground", "aria-labelledby": labelledBy, "data-auth-boundary": "surface", children: _jsx("div", { className: "w-full max-w-md rounded-lg border border-border bg-layout-content px-8 py-7 shadow-sm", children: children }) }));
+}
+export function LoginView({ title, description, defaultIssuer = '', logo, error, onLogin, }) {
+    const titleId = useId();
+    const issuerId = useId();
+    const errorId = useId();
+    const [issuer, setIssuer] = useState(defaultIssuer);
+    const [pending, setPending] = useState(false);
+    const [submitError, setSubmitError] = useState();
+    const normalizedIssuer = issuer.trim();
+    const visibleError = submitError ?? error;
+    const describedBy = useMemo(() => (visibleError ? errorId : undefined), [errorId, visibleError]);
+    async function handleSubmit(event) {
+        event.preventDefault();
+        if (!normalizedIssuer || pending) {
+            return;
+        }
+        setPending(true);
+        setSubmitError(undefined);
+        try {
+            await onLogin(normalizedIssuer);
+        }
+        catch {
+            setSubmitError(normalizeLoginError());
+        }
+        finally {
+            setPending(false);
+        }
+    }
+    return (_jsx(AuthSurface, { labelledBy: titleId, children: _jsxs("div", { className: "flex flex-col gap-6", children: [_jsxs("div", { className: "flex flex-col gap-3 text-center", children: [logo ? (_jsx("div", { className: "flex justify-center", "aria-hidden": "true", children: logo })) : null, _jsxs("div", { className: "flex flex-col gap-2", children: [_jsx("h1", { id: titleId, className: "text-2xl font-semibold leading-8 tracking-normal", children: title }), description ? (_jsx("p", { className: "text-sm leading-6 text-muted-foreground", children: description })) : null] })] }), _jsxs("form", { className: "flex flex-col gap-4", onSubmit: (event) => void handleSubmit(event), children: [_jsxs("div", { className: "flex flex-col gap-2 text-left", children: [_jsx("label", { className: "text-sm font-medium leading-5 text-foreground", htmlFor: issuerId, children: "Solid issuer" }), _jsx(Input, { id: issuerId, value: issuer, disabled: pending, "aria-describedby": describedBy, placeholder: "https://solidcommunity.net", onChange: (event) => setIssuer(event.currentTarget.value) })] }), visibleError ? (_jsx("p", { id: errorId, className: "rounded-md border border-destructive/30 bg-destructive/10 px-3 py-2 text-sm leading-5 text-destructive", role: "alert", children: visibleError })) : null, _jsx(Button, { type: "submit", className: "w-full", disabled: !normalizedIssuer || pending, children: pending ? '登录中...' : '登录' })] })] }) }));
+}
+export function AuthBoundary({ state, login, children, loginView, }) {
+    if (state.status === 'authenticated') {
+        return _jsx(_Fragment, { children: children });
+    }
+    if (state.status === 'loading') {
+        return (_jsx(AuthSurface, { children: _jsxs("div", { className: "flex flex-col items-center gap-3 text-center text-sm leading-6 text-muted-foreground", role: "status", "aria-label": "\u8BA4\u8BC1\u72B6\u6001", children: [_jsx("span", { className: "h-8 w-8 rounded-full border-2 border-border border-t-primary", "aria-hidden": "true" }), _jsx("span", { children: "\u6B63\u5728\u68C0\u67E5\u767B\u5F55\u72B6\u6001" })] }) }));
+    }
+    return (_jsx(LoginView, { title: loginView?.title ?? defaultLoginTitle, description: loginView?.description, defaultIssuer: loginView?.defaultIssuer, logo: loginView?.logo, error: state.status === 'error' ? state.message : undefined, onLogin: login }));
+}

package/node_modules/@undefineds.co/extension-sdk/dist/react/layout-context.d.ts

@@ -0,0 +1,11 @@
+export type WorkspaceLayoutMode = 'split' | 'stack';
+export type WorkspaceLayoutPane = 'list' | 'main' | 'context';
+export interface WorkspaceLayoutNavigation {
+    mode: WorkspaceLayoutMode;
+    activePane: WorkspaceLayoutPane;
+    openList(): void;
+    openMain(): void;
+    openContext(): void;
+}
+export declare const WorkspaceLayoutContext: import("react").Context<WorkspaceLayoutNavigation | null>;
+export declare function useWorkspaceLayout(): WorkspaceLayoutNavigation;

package/node_modules/@undefineds.co/extension-sdk/dist/react/layout-context.js

@@ -0,0 +1,9 @@
+import { createContext, useContext } from 'react';
+export const WorkspaceLayoutContext = createContext(null);
+export function useWorkspaceLayout() {
+    const navigation = useContext(WorkspaceLayoutContext);
+    if (!navigation) {
+        throw new Error('useWorkspaceLayout must be used inside TwoPaneLayout');
+    }
+    return navigation;
+}

package/node_modules/@undefineds.co/extension-sdk/dist/react/workspace-layout.d.ts

@@ -0,0 +1,38 @@
+import { type ReactNode } from 'react';
+import { type WorkspaceLayoutMode, type WorkspaceLayoutPane } from './layout-context';
+export type TwoPaneLayoutMode = 'auto' | WorkspaceLayoutMode;
+export interface TwoPaneLayoutProps {
+    listHeader: ReactNode;
+    list: ReactNode;
+    mainHeader: ReactNode;
+    main: ReactNode;
+    mode?: TwoPaneLayoutMode;
+    history?: WorkspaceLayoutHistoryAdapter;
+    className?: string;
+}
+export interface SinglePaneLayoutProps {
+    header?: ReactNode;
+    main: ReactNode;
+    className?: string;
+}
+export interface ThreePaneLayoutContextConfig {
+    collapsible?: boolean;
+    initiallyCollapsed?: boolean;
+}
+export interface ThreePaneLayoutProps {
+    header?: ReactNode;
+    list: ReactNode;
+    main: ReactNode;
+    context: ReactNode;
+    mode?: TwoPaneLayoutMode;
+    history?: WorkspaceLayoutHistoryAdapter;
+    contextConfig?: ThreePaneLayoutContextConfig;
+    className?: string;
+}
+export interface WorkspaceLayoutHistoryAdapter {
+    push(pane: WorkspaceLayoutPane): void;
+    subscribe(listener: (pane: WorkspaceLayoutPane) => void): () => void;
+}
+export declare function TwoPaneLayout({ listHeader, list, mainHeader, main, mode, history, className, }: TwoPaneLayoutProps): import("react").JSX.Element;
+export declare function SinglePaneLayout({ header, main, className, }: SinglePaneLayoutProps): import("react").JSX.Element;
+export declare function ThreePaneLayout({ header, list, main, context, mode, history, contextConfig, className, }: ThreePaneLayoutProps): import("react").JSX.Element;