kennel-plugins 0.0.0-stage → 0.1.0

package/dist/chunk-AX4A4GYF.js

@@ -0,0 +1,11 @@
+// src/server.ts
+var FolderPluginFailure = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FolderPluginFailure";
+  }
+};
+
+export {
+  FolderPluginFailure
+};

package/dist/chunk-MLKGABMK.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};

package/dist/chunk-STR4VH4C.js

@@ -0,0 +1,11 @@
+// src/client.ts
+function folderPathId(path) {
+  const bytes = new TextEncoder().encode(path);
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+
+export {
+  folderPathId
+};

package/dist/chunk-TCV5SJIW.js

@@ -0,0 +1,171 @@
+// src/endpoint.ts
+var statusByCode = {
+  aborted: 400,
+  "bad-request": 400,
+  conflict: 409,
+  failed: 500,
+  forbidden: 403,
+  internal: 500,
+  "method-not-allowed": 405,
+  "not-found": 404,
+  "payload-too-large": 413,
+  timeout: 504
+};
+var ApiError = class extends Error {
+  code;
+  status;
+  constructor(code, message) {
+    super(message);
+    this.name = "ApiError";
+    this.code = code;
+    this.status = statusByCode[code];
+  }
+};
+function apiError(code, message) {
+  return new ApiError(code, message);
+}
+function jsonResponse(response, status, body, extraHeaders = {}) {
+  if (response.writableEnded || response.headersSent || response.destroyed) {
+    return;
+  }
+  response.writeHead(status, {
+    "Cache-Control": "no-store",
+    "Content-Type": "application/json; charset=utf-8",
+    ...extraHeaders
+  });
+  response.end(JSON.stringify(body));
+}
+function jsonError(response, status, code, message, extraHeaders = {}) {
+  jsonResponse(response, status, { error: { code, message } }, extraHeaders);
+}
+function sameOrigin(request) {
+  const host = request.headers.host;
+  if (!host) return false;
+  const origin = request.headers.origin;
+  if (origin) {
+    try {
+      return new URL(origin).host === host;
+    } catch {
+      return false;
+    }
+  }
+  const referer = request.headers.referer;
+  if (referer) {
+    try {
+      return new URL(referer).host === host;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+async function readBoundedBody(request, maxBytes, signal) {
+  const iterable = request;
+  if (typeof iterable[Symbol.asyncIterator] !== "function") return "";
+  let total = 0;
+  const chunks = [];
+  for await (const chunk of iterable) {
+    if (signal.aborted) throw apiError("aborted", "Request aborted");
+    total += chunk.length;
+    if (total > maxBytes) {
+      throw apiError("payload-too-large", "Request body too large");
+    }
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function parseJsonBody(body) {
+  if (!body.trim()) throw apiError("bad-request", "Request body required");
+  let value;
+  try {
+    value = JSON.parse(body);
+  } catch {
+    throw apiError("bad-request", "Request body is not valid JSON");
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw apiError("bad-request", "Request body must be a JSON object");
+  }
+  return value;
+}
+var methodAllowHeader = (method) => ({ Allow: method });
+async function runApiRoute(request, response, url, spec, context) {
+  const method = (request.method ?? "GET").toUpperCase();
+  if (method !== spec.method) {
+    jsonError(
+      response,
+      405,
+      "method-not-allowed",
+      `Method ${method} not allowed`,
+      methodAllowHeader(spec.method)
+    );
+    return;
+  }
+  const controller = new AbortController();
+  const disconnect = () => controller.abort();
+  request.on?.("aborted", disconnect);
+  response.on?.("close", disconnect);
+  let timer;
+  const timeoutPromise = spec.timeoutMs ? new Promise((_resolve, reject) => {
+    timer = setTimeout(() => {
+      controller.abort();
+      reject(apiError("timeout", "Request timed out"));
+    }, spec.timeoutMs);
+  }) : null;
+  try {
+    if (method !== "GET" && !sameOrigin(request)) {
+      throw apiError("forbidden", "Cross-origin mutations are not allowed");
+    }
+    const maxBody = spec.maxBodyBytes ?? (method === "GET" ? 0 : 1024 * 1024);
+    const body = method === "GET" ? "" : await readBoundedBody(request, maxBody, controller.signal);
+    const ctx = {
+      body,
+      context,
+      query: url.searchParams,
+      request,
+      response,
+      signal: controller.signal,
+      url
+    };
+    let handlerError;
+    const handlerPromise = (async () => {
+      await spec.handle(ctx);
+    })().catch((error) => {
+      handlerError = error;
+    });
+    if (timeoutPromise) await Promise.race([handlerPromise, timeoutPromise]);
+    else await handlerPromise;
+    if (handlerError !== void 0) throw handlerError;
+  } catch (error) {
+    if (error instanceof ApiError && error.code === "timeout") {
+      jsonError(response, 504, "timeout", error.message);
+      return;
+    }
+    if (controller.signal.aborted) {
+      return;
+    }
+    if (error instanceof ApiError) {
+      jsonError(response, error.status, error.code, error.message);
+      return;
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+      jsonError(response, 400, "aborted", "Request aborted");
+      return;
+    }
+    jsonError(response, 500, "internal", "Internal server error");
+  } finally {
+    if (timer) clearTimeout(timer);
+    request.removeListener?.("aborted", disconnect);
+    response.removeListener?.("close", disconnect);
+  }
+}
+
+export {
+  ApiError,
+  apiError,
+  jsonResponse,
+  jsonError,
+  sameOrigin,
+  readBoundedBody,
+  parseJsonBody,
+  runApiRoute
+};

package/dist/chunk-YLSYYX2L.js

@@ -0,0 +1,8 @@
+// src/types.ts
+function isPluginPayloadError(data) {
+  return typeof data === "object" && data !== null && "status" in data && data.status === "error";
+}
+
+export {
+  isPluginPayloadError
+};

package/dist/client.d.ts

@@ -0,0 +1,65 @@
+import { ComponentType } from 'react';
+import { FolderPluginManifest } from './types.js';
+export { isPluginPayloadError } from './types.js';
+
+/**
+ * Host actions a plugin view may call while rendering. These are injected by
+ * the host (never imported by the plugin) and are absent when the server does
+ * not provide them — e.g. a phone on `--lan` must never see server-side
+ * "open in default app" actions. Plugins gate UI on presence, not on path
+ * heuristics.
+ */
+type FolderPluginHostActions = {
+    /** Open a physical file in the host's default app (local hosts only). */
+    openPath: (path: string) => Promise<void>;
+    /**
+     * Create an empty AGENTS.md in a folder and open it in the default
+     * Markdown app (local hosts only). Resolves with the created file path.
+     */
+    createAgentFile: (folder: string) => Promise<{
+        path: string;
+    }>;
+};
+/**
+ * Context the host injects into a plugin's client view. The host owns folder
+ * resolution, navigation/link helpers, and a scoped request function. Plugins
+ * never import `apps/web` helpers or alter the shell directly.
+ */
+type FolderPluginViewProps = {
+    /** Absolute folder path shown by the host. */
+    folder: string;
+    /** Folder route id used as the shared query-key prefix for cache invalidation. */
+    folderId: string;
+    /** Plugin-relative subpath: `""` for the list view, an id for a detail view. */
+    subpath: string;
+    /** Absolute href to this plugin's list view, for back navigation. */
+    listHref: string;
+    /** Absolute href to folder home (Notes), for shell back navigation. */
+    homeHref: string;
+    /** Builds an absolute href for any plugin-relative subpath. */
+    href: (subpath: string) => string;
+    /**
+     * Builds an absolute href for a document inside a folder, for hosts that
+     * serve documents. Undefined on hosts without a document route; content
+     * that references documents then renders as plain labels instead of links.
+     */
+    documentHref?: (folder: string, relativePath: string) => string | undefined;
+    /**
+     * Fetches plugin data for an authorized folder and plugin-relative subpath.
+     * Resolves to the decoded JSON payload (throwing on an error response).
+     */
+    request: (subpath: string, init?: RequestInit) => Promise<unknown>;
+    /**
+     * Host actions available to this view, when the server provides them (see
+     * `FolderPluginHostActions`). Undefined on remote/unavailable hosts.
+     */
+    hostActions?: FolderPluginHostActions;
+};
+
+/** Stable UTF-8 folder id shared by host routes and plugin query keys. */
+declare function folderPathId(path: string): string;
+type FolderPluginClient = FolderPluginManifest & {
+    component: ComponentType<FolderPluginViewProps>;
+};
+
+export { type FolderPluginClient, type FolderPluginHostActions, type FolderPluginViewProps, folderPathId };

package/dist/client.js

@@ -0,0 +1,11 @@
+import {
+  folderPathId
+} from "./chunk-STR4VH4C.js";
+import {
+  isPluginPayloadError
+} from "./chunk-YLSYYX2L.js";
+import "./chunk-MLKGABMK.js";
+export {
+  folderPathId,
+  isPluginPayloadError
+};

package/dist/endpoint.d.ts

@@ -0,0 +1,61 @@
+import { ServerResponse, IncomingMessage } from 'node:http';
+
+type ApiErrorCode = "aborted" | "bad-request" | "conflict" | "failed" | "forbidden" | "internal" | "method-not-allowed" | "not-found" | "payload-too-large" | "timeout";
+declare class ApiError extends Error {
+    readonly code: ApiErrorCode;
+    readonly status: number;
+    constructor(code: ApiErrorCode, message: string);
+}
+declare function apiError(code: ApiErrorCode, message: string): ApiError;
+declare function jsonResponse(response: ServerResponse, status: number, body: unknown, extraHeaders?: Record<string, string>): void;
+declare function jsonError(response: ServerResponse, status: number, code: ApiErrorCode, message: string, extraHeaders?: Record<string, string>): void;
+/**
+ * Same-origin guard for mutating requests (POST/DELETE). A browser sends
+ * `Origin` (or `Referer`) on cross-site requests; require the header, when
+ * present, to match the requested host and reject mutations without any
+ * origin signal. GET requests never mutate and are exempt.
+ */
+declare function sameOrigin(request: IncomingMessage): boolean;
+/**
+ * Read a request body bounded to `maxBytes` bytes. Real Node requests are
+ * async-iterable; the caller must set `Content-Length` expectations too. An
+ * oversized body or a cancellation aborts with a structured ApiError.
+ */
+declare function readBoundedBody(request: IncomingMessage, maxBytes: number, signal: AbortSignal): Promise<string>;
+/**
+ * JSON body helper for mutations. Returns the parsed object or throws a
+ * structured bad-request error; non-Object payloads are rejected.
+ */
+declare function parseJsonBody(body: string): Record<string, unknown>;
+type ApiRouteHandle<Context> = (ctx: {
+    body: string;
+    context: Context;
+    query: URLSearchParams;
+    request: IncomingMessage;
+    response: ServerResponse;
+    signal: AbortSignal;
+    url: URL;
+}) => Promise<void> | void;
+type ApiRouteSpec<Context> = {
+    /** Only this HTTP method is accepted; anything else gets a 405. */
+    method: "GET" | "POST" | "DELETE";
+    /** Bounded request body in bytes; mutations without a body may set 0. */
+    maxBodyBytes?: number;
+    /** Hard cap on handler execution; the child/request is cancelled after. */
+    timeoutMs?: number;
+    /**
+     * Height of `ctx.body` before validation. Sizes over `maxBodyBytes` are
+     * rejected as 413, non-mutating methods never read a body.
+     */
+    handle: ApiRouteHandle<Context>;
+};
+/**
+ * Run one declarative API route. Handles explicit method restriction,
+ * same-origin protection for mutations, bounded bodies, abort on client
+ * disconnect, timeouts, and structured JSON errors. Handlers never see raw
+ * internals; unexpected errors become a generic 500 that cannot leak
+ * command output or credentials.
+ */
+declare function runApiRoute<Context>(request: IncomingMessage, response: ServerResponse, url: URL, spec: ApiRouteSpec<Context>, context: Context): Promise<void>;
+
+export { ApiError, type ApiErrorCode, type ApiRouteHandle, type ApiRouteSpec, apiError, jsonError, jsonResponse, parseJsonBody, readBoundedBody, runApiRoute, sameOrigin };

package/dist/endpoint.js

@@ -0,0 +1,21 @@
+import {
+  ApiError,
+  apiError,
+  jsonError,
+  jsonResponse,
+  parseJsonBody,
+  readBoundedBody,
+  runApiRoute,
+  sameOrigin
+} from "./chunk-TCV5SJIW.js";
+import "./chunk-MLKGABMK.js";
+export {
+  ApiError,
+  apiError,
+  jsonError,
+  jsonResponse,
+  parseJsonBody,
+  readBoundedBody,
+  runApiRoute,
+  sameOrigin
+};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { CopyContextButton, FilePreview, FilePreviewList, FolderFilterBar, FolderFilterChoice, FolderFilterMode, FolderSelection, PluginPage, PluginPageError, PluginPageStatus, useFolderFilter } from './page.js';
+export { FolderPluginClient, FolderPluginHostActions, FolderPluginViewProps, folderPathId } from './client.js';
+export { ApiError, ApiErrorCode, ApiRouteHandle, ApiRouteSpec, apiError, jsonError, jsonResponse, parseJsonBody, readBoundedBody, runApiRoute, sameOrigin } from './endpoint.js';
+export { FolderPluginContext, FolderPluginData, FolderPluginFailure, FolderPluginInitFile, FolderPluginInitResult, FolderPluginServer } from './server.js';
+export { FolderPluginDataset, FolderPluginDetection, FolderPluginId, FolderPluginManifest, FolderPluginPayload, FolderPluginPayloadError, isPluginPayloadError } from './types.js';
+import 'react';
+import 'class-variance-authority/types';
+import 'class-variance-authority';
+import 'node:http';

package/dist/index.js

@@ -0,0 +1,51 @@
+import {
+  ApiError,
+  apiError,
+  jsonError,
+  jsonResponse,
+  parseJsonBody,
+  readBoundedBody,
+  runApiRoute,
+  sameOrigin
+} from "./chunk-TCV5SJIW.js";
+import {
+  CopyContextButton,
+  EntityError,
+  EntityPage,
+  EntityStatus,
+  FilePreview,
+  FilePreviewList,
+  FolderFilterBar,
+  useFolderFilter
+} from "./chunk-454D7WI6.js";
+import {
+  folderPathId
+} from "./chunk-STR4VH4C.js";
+import {
+  FolderPluginFailure
+} from "./chunk-AX4A4GYF.js";
+import {
+  isPluginPayloadError
+} from "./chunk-YLSYYX2L.js";
+import "./chunk-MLKGABMK.js";
+export {
+  ApiError,
+  CopyContextButton,
+  FilePreview,
+  FilePreviewList,
+  FolderFilterBar,
+  FolderPluginFailure,
+  EntityPage as PluginPage,
+  EntityError as PluginPageError,
+  EntityStatus as PluginPageStatus,
+  apiError,
+  folderPathId,
+  isPluginPayloadError,
+  jsonError,
+  jsonResponse,
+  parseJsonBody,
+  readBoundedBody,
+  runApiRoute,
+  sameOrigin,
+  useFolderFilter
+};

package/dist/page.d.ts

@@ -0,0 +1,204 @@
+import * as react from 'react';
+import { ReactNode, ComponentProps } from 'react';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+
+/**
+ * Page shell for entity list and detail pages: a centered single-column
+ * grid with a header slot (back link, linked-source status), an extra slot
+ * (filters, warnings), and the page body. Keeps every plugin page on the
+ * same width and rhythm.
+ */
+declare function EntityPage({ header, extra, children, }: {
+    header?: ReactNode;
+    extra?: ReactNode;
+    children?: ReactNode;
+}): react.JSX.Element;
+/**
+ * A status line: plain strings render in the shared muted style, richer
+ * nodes (issue panels, error details) pass through untouched.
+ */
+declare function EntityStatus({ children }: {
+    children: ReactNode;
+}): number | bigint | boolean | react.JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | null | undefined;
+/**
+ * An error block: plain strings render as a destructive line with an
+ * optional retry button; richer nodes pass through untouched.
+ */
+declare function EntityError({ error, onRetry, }: {
+    error: ReactNode;
+    onRetry?: () => void;
+}): number | bigint | boolean | react.JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | null | undefined;
+
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined;
+    size?: "default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function Button({ className, variant, size, asChild, ...props }: react.ComponentProps<"button"> & VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+}): react.JSX.Element;
+
+/**
+ * The context to copy: either a ready string or a builder function. Builders
+ * may be async, so a plugin can assemble its prompt inside a wait function
+ * (fetch a detail, append a body read from disk, …) before the clipboard
+ * write happens.
+ */
+type CopyContextSource = string | (() => string | Promise<string>);
+/**
+ * Ready-made icon button for copying an item's context (tasks rows, mail
+ * detail headers, …): Copy icon, swaps to a green check on success. Callers
+ * pass the item's context — or a builder that resolves it on click.
+ */
+type CopyContextButtonProps = {
+    context: CopyContextSource;
+    className?: string;
+    /** Accessible name and tooltip; defaults to "Copy context". */
+    label?: string;
+    variant?: ComponentProps<typeof Button>["variant"];
+    size?: ComponentProps<typeof Button>["size"];
+    /** Toast confirmation after the copy attempt (default: true). */
+    notify?: boolean;
+    onCopied?: () => void;
+    onFailed?: () => void;
+};
+declare function CopyContextButton({ className, context, label, notify, onCopied, onFailed, size, variant, }: CopyContextButtonProps): react.JSX.Element;
+
+/**
+ * Card preview for one file attachment. Shows an inline thumbnail for
+ * image and PDF files (the icon of the well-known type otherwise) plus the
+ * file name. The thumbnail links to the raw file in a new browser tab and
+ * the Open button opens it in the host's default application without
+ * navigating the viewer, so the sender can check exactly what will go out
+ * with the draft.
+ */
+declare function FilePreview({ path }: {
+    path: string;
+}): react.JSX.Element;
+/** Row of attachment preview cards, one card per absolute file path. */
+declare function FilePreviewList({ paths }: {
+    paths: string[];
+}): react.JSX.Element;
+
+/**
+ * Generalized folder filtering for lists of items that carry an owning
+ * folder path.
+ *
+ * Pure string/array logic — no React, no DOM, no `node:` builtins — so the
+ * exact same helpers power web chips, folder-plugin views, and CLI
+ * filtering. The model mirrors the mail plugin's draft selector but is
+ * accessor-driven: you hand over your items, a function that reads each
+ * item's owning folder, and the viewed root folder; you get back the
+ * distinct folder choices (root first, then descendants by relative path,
+ * each with a count) and a predicate that decides which items a selection
+ * keeps.
+ *
+ * CLI example (no React):
+ *
+ * ```ts
+ * import {
+ *   folderFilterChoices,
+ *   folderFilterMatches,
+ * } from "@raggle-ai/ui/lib/folder-filter"
+ *
+ * const choices = folderFilterChoices(items, root, (item) => item.folder)
+ * const visible = items.filter((item) =>
+ *   folderFilterMatches(item.folder, flags.folder, "subtree"),
+ * )
+ * ```
+ */
+/** How a selected folder applies to an item's owning folder. */
+type FolderFilterMode = "exact" | "subtree";
+/**
+ * One clickable chip: a distinct owning folder in the item list. `folder`
+ * is the full owning path and the exact filter key (duplicate leaf names
+ * stay distinct); `label` is the short display text (basename for the
+ * root, relative path for descendants).
+ */
+type FolderFilterChoice = {
+    /** Exact owning folder path — the filter key. */
+    folder: string;
+    /** Number of items owned by this folder. */
+    count: number;
+    /** Short display label: basename for the root, relative path for descendants. */
+    label: string;
+    /** Path relative to the viewed root; "" for the root itself. */
+    relativePath: string;
+};
+/**
+ * A selection for folder filtering: a single owning folder, several
+ * (multi-select — an item passes when any of them matches), or null/
+ * empty for "all items". Single-string callers keep working unchanged.
+ */
+type FolderSelection = string | readonly string[] | null;
+
+/**
+ * Multi-select folder filter as a single "Folder (count)" button. The
+ * count badge shows how many folders are selected, or the total when
+ * nothing is filtered. The popover holds a searchable command list with
+ * an "All folders" row that clears back to everything; every folder row
+ * toggles into the selection in real time.
+ *
+ * Rows are portal-mounted on open (like this repo's Select), so closed
+ * dropdown content is not in the SSR/tree — the trigger carries the
+ * accessible count instead.
+ */
+declare function FolderFilterBar({ allLabel, ariaLabel, choices, onSelect, selected, total, }: {
+    /** Label of the row that clears the selection. */
+    allLabel?: string;
+    /** Accessible name for the filter trigger. */
+    ariaLabel?: string;
+    choices: FolderFilterChoice[];
+    /** All currently selected owning folders; pass [] to show everything. */
+    onSelect: (folders: readonly string[]) => void;
+    /** Currently selected owning folders; empty means "all". */
+    selected: readonly string[];
+    /** Count shown on the trigger while nothing is selected. */
+    total: number;
+}): react.JSX.Element;
+
+type UseFolderFilterOptions<T> = {
+    /** Owning folder of each item; null when the item has none. */
+    getFolder: (item: T) => string | null;
+    /** "exact" keeps the selected folder's items only; "subtree" also keeps descendant items. */
+    mode?: FolderFilterMode;
+    /** Include ancestor/outside folders as chips (see `folderFilterChoices`). */
+    allowOutside?: boolean;
+    /** Folder everything is shown relative to (the viewed root). */
+    rootFolder: string;
+    /** Initial selection (owning folder paths); a selection with no items falls back to all. */
+    initialFolder?: FolderSelection;
+};
+type UseFolderFilterResult<T> = {
+    /** Distinct owning-folder choices with counts, root first. */
+    choices: FolderFilterChoice[];
+    /**
+     * Selection entries that still match items. Empty means "all items" —
+     * either nothing is selected or every selected folder lost its items.
+     */
+    effectiveSelected: readonly string[];
+    /** Raw selection state; entries whose folder has no items left may be stale. */
+    selected: readonly string[];
+    /**
+     * Replace the selection. Pass a single folder, an array of folders (an
+     * item passes when any of them matches), or null/[] to show everything.
+     */
+    setSelected: (folder: FolderSelection) => void;
+    /** Toggle one owning folder in/out of the selection. */
+    toggle: (folder: string) => void;
+    /** Clear the selection back to "all items". */
+    reset: () => void;
+    /** Number of items before filtering — shown on the "All" chip. */
+    total: number;
+    /** Items after applying the effective selection. */
+    visibleItems: T[];
+};
+/**
+ * Folder-filter state for a plugin view: pass the items and a folder
+ * accessor, get the choices, the reconciled (multi-)selection, and the
+ * filtered `visibleItems` in one place. Recomputes only when the items,
+ * accessor, root, mode, or selection change.
+ */
+declare function useFolderFilter<T>(items: readonly T[], options: UseFolderFilterOptions<T>): UseFolderFilterResult<T>;
+
+export { CopyContextButton, FilePreview, FilePreviewList, FolderFilterBar, type FolderFilterChoice, type FolderFilterMode, type FolderSelection, EntityPage as PluginPage, EntityError as PluginPageError, EntityStatus as PluginPageStatus, useFolderFilter };

package/dist/page.js

@@ -0,0 +1,23 @@
+import {
+  CopyContextButton,
+  EntityError,
+  EntityPage,
+  EntityStatus,
+  FilePreview,
+  FilePreviewList,
+  FolderFilterBar,
+  useFolderFilter
+} from "./chunk-454D7WI6.js";
+import "./chunk-STR4VH4C.js";
+import "./chunk-YLSYYX2L.js";
+import "./chunk-MLKGABMK.js";
+export {
+  CopyContextButton,
+  FilePreview,
+  FilePreviewList,
+  FolderFilterBar,
+  EntityPage as PluginPage,
+  EntityError as PluginPageError,
+  EntityStatus as PluginPageStatus,
+  useFolderFilter
+};