@vite-hub/ui 0.0.4 → 0.1.0

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

@@ -0,0 +1,459 @@
+import { PropType } from "vue";
+//#region ../../node_modules/.pnpm/@pierre+trees@1.0.0-beta.6_@pierre+theme@2.0.0_@shikijs+themes@4.5.0_react-dom@19.2.8_r_1bb1bb7c965cf1063203cdfd313d3b8d/node_modules/@pierre/trees/dist/iconConfig.d.ts
+//#region src/iconConfig.d.ts
+type RemappedIcon = string | {
+  name: string;
+  width?: number;
+  height?: number;
+  viewBox?: string;
+};
+type FileTreeBuiltInIconSet = 'minimal' | 'standard' | 'complete';
+interface FileTreeIconConfig {
+  /** Use one of the built-in icon sets, or `none` for custom-only icon rules. */
+  set?: FileTreeBuiltInIconSet | 'none';
+  /** Enable semantic per-file-type colors for built-in icon sets. */
+  colored?: boolean;
+  /** An SVG string with <symbol> definitions injected into the shadow DOM. */
+  spriteSheet?: string;
+  /** Remap built-in tree icon slots (file, chevron, dot, lock). */
+  remap?: Record<string, RemappedIcon>;
+  /** Remap file icons by exact basename (e.g. "package.json", ".gitignore"). */
+  byFileName?: Record<string, RemappedIcon>;
+  /** Remap file icons by extension without a leading dot (e.g. "ts", "spec.ts"). */
+  byFileExtension?: Record<string, RemappedIcon>;
+  /** Remap file icons by basename substring (e.g. "dockerfile", "license"). */
+  byFileNameContains?: Record<string, RemappedIcon>;
+}
+type FileTreeIcons = FileTreeBuiltInIconSet | FileTreeIconConfig;
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+trees@1.0.0-beta.6_@pierre+theme@2.0.0_@shikijs+themes@4.5.0_react-dom@19.2.8_r_1bb1bb7c965cf1063203cdfd313d3b8d/node_modules/@pierre/trees/dist/publicTypes.d.ts
+//#region src/publicTypes.d.ts
+type GitStatus = 'added' | 'deleted' | 'ignored' | 'modified' | 'renamed' | 'untracked';
+type GitStatusEntry = {
+  path: string;
+  status: GitStatus;
+};
+type ContextMenuAnchorRect = Readonly<{
+  top: number;
+  right: number;
+  bottom: number;
+  left: number;
+  width: number;
+  height: number;
+  x: number;
+  y: number;
+}>;
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+trees@1.0.0-beta.6_@pierre+theme@2.0.0_@shikijs+themes@4.5.0_react-dom@19.2.8_r_1bb1bb7c965cf1063203cdfd313d3b8d/node_modules/@pierre/trees/dist/model/density.d.ts
+//#region src/model/density.d.ts
+type FileTreeDensityKeyword = 'compact' | 'default' | 'relaxed';
+type FileTreeDensity = FileTreeDensityKeyword | number;
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+trees@1.0.0-beta.6_@pierre+theme@2.0.0_@shikijs+themes@4.5.0_react-dom@19.2.8_r_1bb1bb7c965cf1063203cdfd313d3b8d/node_modules/@pierre/trees/dist/preparedInput.d.ts
+//#region src/preparedInput.d.ts
+declare const FILE_TREE_PREPARED_INPUT: unique symbol;
+interface FileTreePreparedInput {
+  readonly [FILE_TREE_PREPARED_INPUT]: true;
+  readonly paths: readonly string[];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+trees@1.0.0-beta.6_@pierre+theme@2.0.0_@shikijs+themes@4.5.0_react-dom@19.2.8_r_1bb1bb7c965cf1063203cdfd313d3b8d/node_modules/@pierre/trees/dist/model/publicTypes.d.ts
+//#region src/model/publicTypes.d.ts
+/**
+ * Public tree identity is path-first so render and model callers never depend
+ * on the underlying path-store numeric IDs.
+ */
+type FileTreePublicId = string;
+interface FileTreeSortEntry {
+  basename: string;
+  depth: number;
+  isDirectory: boolean;
+  path: FileTreePublicId;
+  segments: readonly string[];
+}
+type FileTreeSortComparator = (left: FileTreeSortEntry, right: FileTreeSortEntry) => number;
+type FileTreeInitialExpansion = 'closed' | 'open' | number;
+interface FileTreeRemoveOptions {
+  recursive?: boolean;
+}
+type FileTreeCollisionStrategy = 'error' | 'replace' | 'skip';
+interface FileTreeMoveOptions {
+  collision?: FileTreeCollisionStrategy;
+}
+type FileTreeBatchOperation = {
+  path: FileTreePublicId;
+  type: 'add';
+} | ({
+  path: FileTreePublicId;
+  type: 'remove';
+} & FileTreeRemoveOptions) | ({
+  from: FileTreePublicId;
+  to: FileTreePublicId;
+  type: 'move';
+} & FileTreeMoveOptions);
+interface FileTreeGitStatusPatch {
+  remove?: readonly FileTreePublicId[];
+  set?: readonly GitStatusEntry[];
+}
+interface FileTreeStoreOptions {
+  flattenEmptyDirectories?: boolean;
+  initialExpansion?: FileTreeInitialExpansion;
+  initialExpandedPaths?: readonly FileTreePublicId[];
+  presorted?: boolean;
+  sort?: 'default' | FileTreeSortComparator;
+}
+type FileTreeInputOptions = {
+  paths: readonly FileTreePublicId[];
+  preparedInput?: FileTreePreparedInput;
+} | {
+  paths?: readonly FileTreePublicId[];
+  preparedInput: FileTreePreparedInput;
+};
+type FileTreeControllerBehaviorOptions = FileTreeStoreOptions & {
+  dragAndDrop?: boolean | FileTreeDragAndDropConfig;
+  fileTreeSearchMode?: FileTreeSearchMode;
+  initialSearchQuery?: string | null;
+  initialSelectedPaths?: readonly FileTreePublicId[];
+  onSearchChange?: FileTreeSearchChangeListener;
+  renaming?: boolean | FileTreeRenamingConfig;
+};
+type FileTreeControllerOptions = FileTreeControllerBehaviorOptions & FileTreeInputOptions;
+interface FileTreeVisibleSegment {
+  isTerminal: boolean;
+  name: string;
+  path: FileTreePublicId;
+}
+interface FileTreeVisibleRow {
+  ancestorPaths: readonly FileTreePublicId[];
+  depth: number;
+  flattenedSegments?: readonly FileTreeVisibleSegment[];
+  hasChildren: boolean;
+  index: number;
+  isFocused: boolean;
+  isSelected: boolean;
+  isExpanded: boolean;
+  isFlattened: boolean;
+  kind: 'directory' | 'file';
+  level: number;
+  name: string;
+  path: FileTreePublicId;
+  posInSet: number;
+  setSize: number;
+}
+interface FileTreeItemHandleBase {
+  deselect(): void;
+  focus(): void;
+  getPath(): FileTreePublicId;
+  isFocused(): boolean;
+  isDirectory(): boolean;
+  isSelected(): boolean;
+  select(): void;
+  toggleSelect(): void;
+}
+interface FileTreeDirectoryHandle extends FileTreeItemHandleBase {
+  collapse(): void;
+  expand(): void;
+  isDirectory(): true;
+  isExpanded(): boolean;
+  toggle(): void;
+}
+interface FileTreeFileHandle extends FileTreeItemHandleBase {
+  isDirectory(): false;
+}
+type FileTreeItemHandle = FileTreeDirectoryHandle | FileTreeFileHandle;
+interface FileTreeRenderOptions {
+  initialVisibleRowCount?: number;
+  itemHeight?: number;
+  overscan?: number;
+  stickyFolders?: boolean;
+}
+type FileTreeScrollOffset = 'top' | 'center' | 'nearest';
+interface FileTreeScrollToPathOptions {
+  focus?: boolean;
+  offset?: FileTreeScrollOffset;
+}
+type FileTreeSearchMode = 'expand-matches' | 'collapse-non-matches' | 'hide-non-matches';
+type FileTreeSearchBlurBehavior = 'close' | 'retain';
+type FileTreeSearchChangeListener = (value: string | null) => void;
+interface FileTreeSearchSessionHandle {
+  closeSearch(): void;
+  focusNextSearchMatch(): void;
+  focusPreviousSearchMatch(): void;
+  getSearchMatchingPaths(): readonly FileTreePublicId[];
+  getSearchValue(): string;
+  isSearchOpen(): boolean;
+  openSearch(initialValue?: string): void;
+  setSearch(value: string | null): void;
+}
+interface FileTreeDropTarget {
+  directoryPath: FileTreePublicId | null;
+  flattenedSegmentPath: FileTreePublicId | null;
+  hoveredPath: FileTreePublicId | null;
+  kind: 'directory' | 'root';
+}
+interface FileTreeDropContext {
+  draggedPaths: readonly FileTreePublicId[];
+  target: FileTreeDropTarget;
+}
+interface FileTreeDropResult extends FileTreeDropContext {
+  operation: 'batch' | 'move';
+}
+interface FileTreeDragAndDropConfig {
+  canDrag?: (paths: readonly FileTreePublicId[]) => boolean;
+  canDrop?: (event: FileTreeDropContext) => boolean;
+  onDropComplete?: (event: FileTreeDropResult) => void;
+  onDropError?: (error: string, event: FileTreeDropContext) => void;
+  openOnDropDelay?: number;
+}
+interface FileTreeRenamingItem {
+  isFolder: boolean;
+  path: FileTreePublicId;
+}
+interface FileTreeRenameEvent {
+  destinationPath: FileTreePublicId;
+  isFolder: boolean;
+  sourcePath: FileTreePublicId;
+}
+interface FileTreeRenamingConfig {
+  canRename?: (item: FileTreeRenamingItem) => boolean;
+  onError?: (error: string) => void;
+  onRename?: (event: FileTreeRenameEvent) => void;
+}
+type FileTreeOptionSurface = FileTreeRenderOptions & {
+  composition?: FileTreeCompositionOptions;
+  density?: FileTreeDensity;
+  gitStatus?: readonly GitStatusEntry[];
+  id?: string;
+  icons?: FileTreeIcons;
+  onSelectionChange?: FileTreeSelectionChangeListener;
+  renderRowDecoration?: FileTreeRowDecorationRenderer;
+  search?: boolean;
+  searchFakeFocus?: boolean;
+  searchBlurBehavior?: FileTreeSearchBlurBehavior;
+  unsafeCSS?: string;
+};
+type FileTreeOptions$1 = FileTreeControllerOptions & FileTreeOptionSurface;
+interface FileTreeRenderProps {
+  containerWrapper?: HTMLElement;
+  fileTreeContainer?: HTMLElement;
+}
+interface FileTreeHydrationProps {
+  fileTreeContainer: HTMLElement;
+}
+interface FileTreeMutationEventInvalidation {
+  canonicalChanged: boolean;
+  projectionChanged: boolean;
+  visibleCountDelta: number | null;
+}
+interface FileTreeAddEvent extends FileTreeMutationEventInvalidation {
+  operation: 'add';
+  path: FileTreePublicId;
+}
+interface FileTreeRemoveEvent extends FileTreeMutationEventInvalidation {
+  operation: 'remove';
+  path: FileTreePublicId;
+  recursive: boolean;
+}
+interface FileTreeMoveEvent extends FileTreeMutationEventInvalidation {
+  from: FileTreePublicId;
+  operation: 'move';
+  to: FileTreePublicId;
+}
+interface FileTreeResetEvent extends FileTreeMutationEventInvalidation {
+  operation: 'reset';
+  pathCountAfter: number;
+  pathCountBefore: number;
+  usedPreparedInput: boolean;
+}
+type FileTreeMutationSemanticEvent = FileTreeAddEvent | FileTreeRemoveEvent | FileTreeMoveEvent | FileTreeResetEvent;
+interface FileTreeBatchEvent extends FileTreeMutationEventInvalidation {
+  events: readonly FileTreeMutationSemanticEvent[];
+  operation: 'batch';
+}
+type FileTreeMutationEvent = FileTreeMutationSemanticEvent | FileTreeBatchEvent;
+type FileTreeMutationEventType = FileTreeMutationEvent['operation'];
+type FileTreeMutationEventForType<TType extends FileTreeMutationEventType | '*'> = TType extends '*' ? FileTreeMutationEvent : Extract<FileTreeMutationEvent, {
+  operation: TType;
+}>;
+interface FileTreeResetBehaviorOptions {
+  initialExpandedPaths?: readonly FileTreePublicId[];
+}
+type FileTreeResetOptions = FileTreeResetBehaviorOptions & {
+  preparedInput?: FileTreePreparedInput;
+};
+type FileTreeResetPreparedOptions = FileTreeResetBehaviorOptions & {
+  preparedInput: FileTreePreparedInput;
+};
+interface FileTreeMutationHandle {
+  add(path: FileTreePublicId): void;
+  batch(operations: readonly FileTreeBatchOperation[]): void;
+  move(fromPath: FileTreePublicId, toPath: FileTreePublicId, options?: FileTreeMoveOptions): void;
+  onMutation<TType extends FileTreeMutationEventType | '*'>(type: TType, handler: (event: FileTreeMutationEventForType<TType>) => void): () => void;
+  remove(path: FileTreePublicId, options?: FileTreeRemoveOptions): void;
+  resetPaths(paths: readonly FileTreePublicId[], options?: FileTreeResetOptions): void;
+  resetPaths(options: FileTreeResetPreparedOptions): void;
+}
+type FileTreeListener = () => void;
+type FileTreeSelectionChangeListener = (selectedPaths: readonly FileTreePublicId[]) => void;
+interface FileTreeContextMenuItem {
+  kind: 'directory' | 'file';
+  name: string;
+  path: FileTreePublicId;
+}
+interface FileTreeContextMenuOpenContext {
+  anchorElement: HTMLElement;
+  anchorRect: ContextMenuAnchorRect;
+  /**
+   * Closes the current context menu. Pass `{ restoreFocus: false }` when the
+   * caller is about to transfer focus into another owned surface, such as the
+   * inline rename input, so the menu close path does not steal focus back to
+   * the row first.
+   */
+  close: (options?: {
+    restoreFocus?: boolean;
+  }) => void;
+  restoreFocus: () => void;
+}
+interface FileTreeHeaderCompositionOptions {
+  html?: string;
+  render?: () => HTMLElement | null;
+}
+type FileTreeContextMenuTriggerMode = 'both' | 'button' | 'right-click';
+type FileTreeContextMenuButtonVisibility = 'always' | 'when-needed';
+interface FileTreeContextMenuCompositionOptions {
+  enabled?: boolean;
+  triggerMode?: FileTreeContextMenuTriggerMode;
+  buttonVisibility?: FileTreeContextMenuButtonVisibility;
+  onOpen?: (item: FileTreeContextMenuItem, context: FileTreeContextMenuOpenContext) => void;
+  onClose?: () => void;
+  /**
+   * If the interactive menu surface renders through a portal instead of inside
+   * the returned element, mark that portaled root with
+   * `data-file-tree-context-menu-root="true"` so internal clicks are not
+   * treated as outside clicks.
+   */
+  render?: (item: FileTreeContextMenuItem, context: FileTreeContextMenuOpenContext) => HTMLElement | null;
+}
+interface FileTreeCompositionOptions {
+  contextMenu?: FileTreeContextMenuCompositionOptions;
+  header?: FileTreeHeaderCompositionOptions;
+}
+interface FileTreeRowDecorationTextPart {
+  text: string;
+  color?: string;
+}
+interface FileTreeRowDecorationText {
+  text: string;
+  title?: string;
+  parts?: readonly FileTreeRowDecorationTextPart[];
+}
+interface FileTreeRowDecorationIcon {
+  icon: RemappedIcon;
+  title?: string;
+}
+type FileTreeRowDecoration = FileTreeRowDecorationText | FileTreeRowDecorationIcon;
+interface FileTreeRowDecorationContext {
+  item: FileTreeContextMenuItem;
+  row: FileTreeVisibleRow;
+}
+type FileTreeRowDecorationRenderer = (context: FileTreeRowDecorationContext) => FileTreeRowDecoration | null;
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+trees@1.0.0-beta.6_@pierre+theme@2.0.0_@shikijs+themes@4.5.0_react-dom@19.2.8_r_1bb1bb7c965cf1063203cdfd313d3b8d/node_modules/@pierre/trees/dist/render/FileTree.d.ts
+declare class FileTree$1 implements FileTreeMutationHandle, FileTreeSearchSessionHandle {
+  #private;
+  static LoadedCustomComponent: boolean;
+  constructor(options: FileTreeOptions$1);
+  unmount(): void;
+  cleanUp(): void;
+  getFileTreeContainer(): HTMLElement | undefined;
+  getItem(path: string): FileTreeItemHandle | null;
+  getFocusedItem(): FileTreeItemHandle | null;
+  getFocusedPath(): string | null;
+  getFocusedIndex(): number;
+  getVisibleCount(): number;
+  getVisibleRows(start: number, end: number): readonly FileTreeVisibleRow[];
+  getSelectedPaths(): readonly string[];
+  getComposition(): FileTreeCompositionOptions | undefined;
+  getItemHeight(): number;
+  getDensityFactor(): number;
+  subscribe(listener: FileTreeListener): () => void;
+  focusPath(path: string): void;
+  focusFirstItem(): void;
+  focusLastItem(): void;
+  focusNextItem(): void;
+  focusPreviousItem(): void;
+  focusParentItem(): void;
+  scrollToPath(path: FileTreePublicId, options?: FileTreeScrollToPathOptions): void;
+  focusNearestPath(path: string | null): string | null;
+  add(path: string): void;
+  batch(operations: readonly FileTreeBatchOperation[]): void;
+  applyGitStatusPatch(patch: FileTreeGitStatusPatch): void;
+  move(fromPath: string, toPath: string, options?: FileTreeMoveOptions): void;
+  onMutation<TType extends FileTreeMutationEventType | '*'>(type: TType, handler: (event: FileTreeMutationEventForType<TType>) => void): () => void;
+  setSearch(value: string | null): void;
+  openSearch(initialValue?: string): void;
+  closeSearch(): void;
+  isSearchOpen(): boolean;
+  getSearchValue(): string;
+  getSearchMatchingPaths(): readonly string[];
+  focusNextSearchMatch(): void;
+  focusPreviousSearchMatch(): void;
+  startRenaming(path?: string, options?: {
+    removeIfCanceled?: boolean;
+  }): boolean;
+  remove(path: string, options?: FileTreeRemoveOptions): void;
+  resetPaths(paths: readonly string[], options?: FileTreeResetOptions): void;
+  resetPaths(options: FileTreeResetPreparedOptions): void;
+  setComposition(composition?: FileTreeCompositionOptions): void;
+  setGitStatus(gitStatus?: FileTreeOptions$1['gitStatus']): void;
+  setIcons(icons?: FileTreeOptions$1['icons']): void;
+  hydrate({ fileTreeContainer }: FileTreeHydrationProps): void;
+  render({ containerWrapper, fileTreeContainer }: FileTreeRenderProps): void;
+}
+//#endregion
+//#region src/components/file-tree.d.ts
+/** The Pierre tree model that `useFileTree()` returns and `FileTree` renders. */
+type FileTreeModel = FileTree$1;
+interface FileTreeOptions extends Omit<FileTreeOptions$1, "paths"> {
+  paths: readonly string[];
+}
+declare function useFileTree(options: FileTreeOptions): FileTreeModel;
+declare function useFileTreeSelection(model: FileTreeModel): import("vue").ShallowRef<readonly string[], readonly string[]>;
+declare const FileTree: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  model: {
+    type: PropType<FileTreeModel>;
+  };
+  options: {
+    type: PropType<Omit<FileTreeOptions$1, "paths">>;
+  };
+  paths: {
+    default: () => never[];
+    type: PropType<readonly string[]>;
+  };
+  searchLabel: {
+    default: string;
+    type: StringConstructor;
+  };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  model: {
+    type: PropType<FileTreeModel>;
+  };
+  options: {
+    type: PropType<Omit<FileTreeOptions$1, "paths">>;
+  };
+  paths: {
+    default: () => never[];
+    type: PropType<readonly string[]>;
+  };
+  searchLabel: {
+    default: string;
+    type: StringConstructor;
+  };
+}>> & Readonly<{}>, {
+  paths: readonly string[];
+  searchLabel: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+export { useFileTreeSelection as a, useFileTree as i, FileTreeModel as n, FileTreeOptions as r, FileTree as t };

package/dist/file-tree.d.ts

@@ -0,0 +1,2 @@
+import { t as FileTree } from "./file-tree-Ctb8hZ_g.js";
+export { FileTree };

package/dist/file-tree.js

@@ -0,0 +1,2 @@
+import { t as FileTree } from "./file-tree-C1pv4_AI.js";
+export { FileTree };

package/dist/file-view.d.ts

@@ -0,0 +1,2 @@
+import { r as FileView } from "./code-view-vDM-hph-.js";
+export { FileView };

package/dist/file-view.js

@@ -0,0 +1,2 @@
+import { r as FileView } from "./code-view-J4OsgEdh.js";
+export { FileView };