zidane-ui 9.0.4 → 9.1.3

package/src/files/headless/entries.ts

@@ -1,172 +0,0 @@
-/**
- * The React-free half of the tree's entry actions: what a drop from outside
- * the page holds (taken while the drop lasts, walked later), how a path
- * follows a move, what a refusal says, and the clipboard of cut or copied
- * rows. `FilesTab` wires them to `FilesHost.entries`.
- */
-import type { EntryImportItem } from 'zidane/chat/pure';
-
-import type { DroppedItem, FilesEntryRefusal } from './host';
-import type { FilesLabels } from './labels';
-
-/**
- * Whether a drag carries files from outside the page (the file manager).
- *
- * @param data - The drag event's `dataTransfer`.
- */
-export function hasDroppedFiles(data: DataTransfer | null | undefined): boolean {
-  return !!data && Array.from(data.types).includes('Files');
-}
-
-/**
- * What a drop holds, taken now: a `DataTransfer`'s items are gone once the
- * drop event returns, so its files and their entries are read here.
- *
- * @param data - The drop's data.
- */
-export function droppedItems(data: DataTransfer): DroppedItem[] {
-  const items = Array.from(data.items ?? []).filter((item) => item.kind === 'file');
-  if (items.length > 0) {
-    return items.flatMap((item) => {
-      const file = item.getAsFile();
-      if (!file) return [];
-      const entry = typeof item.webkitGetAsEntry === 'function' ? item.webkitGetAsEntry() : null;
-      return [{ file, entry }];
-    });
-  }
-  return Array.from(data.files ?? []).map((file) => ({ file, entry: null }));
-}
-
-const fileOf = (entry: FileSystemFileEntry) => new Promise<File>((resolve, reject) => entry.file(resolve, reject));
-
-/** Every entry of a folder: a reader answers in batches until an empty one. */
-async function childrenOf(entry: FileSystemDirectoryEntry): Promise<FileSystemEntry[]> {
-  const reader = entry.createReader();
-  const all: FileSystemEntry[] = [];
-  for (;;) {
-    const batch = await new Promise<FileSystemEntry[]>((resolve, reject) => reader.readEntries(resolve, reject));
-    if (batch.length === 0) return all;
-    all.push(...batch);
-  }
-}
-
-const fromFile = (file: File): EntryImportItem => ({
-  name: file.name,
-  size: file.size,
-  read: async () => new Uint8Array(await file.arrayBuffer()),
-});
-
-async function fromEntry(entry: FileSystemEntry): Promise<EntryImportItem | null> {
-  if (entry.isFile) return fromFile(await fileOf(entry as FileSystemFileEntry));
-  if (!entry.isDirectory) return null;
-  const children = await Promise.all((await childrenOf(entry as FileSystemDirectoryEntry)).map(fromEntry));
-  return {
-    name: entry.name,
-    children: children.filter((c): c is EntryImportItem => c !== null).sort((a, b) => a.name.localeCompare(b.name)),
-  };
-}
-
-/**
- * A drop as import items (`importEntries`, `zidane/chat/pure`): dropped
- * folders walked through their entries, files read when their turn comes.
- *
- * @param items - What the drop held ({@link droppedItems}).
- */
-export async function droppedImportItems(items: readonly DroppedItem[]): Promise<EntryImportItem[]> {
-  const out = await Promise.all(items.map((item) => (item.entry ? fromEntry(item.entry) : fromFile(item.file))));
-  return out.filter((i): i is EntryImportItem => i !== null);
-}
-
-/**
- * Whether `path` is `root` or inside it.
- *
- * @param path - A path relative to the folder.
- * @param root - The folder to test against.
- */
-export function isUnder(path: string, root: string): boolean {
-  return path === root || path.startsWith(`${root}/`);
-}
-
-/**
- * Where `path` is once `from` moved to `to` (itself, or inside a moved
- * folder); `null` when the move does not touch it.
- *
- * @param path - A path relative to the folder.
- * @param from - The moved entry.
- * @param to - Where it went.
- */
-export function movedPath(path: string, from: string, to: string): string | null {
-  if (path === from) return to;
-  return path.startsWith(`${from}/`) ? `${to}${path.slice(from.length)}` : null;
-}
-
-/**
- * The folder holding `path` (`''`: the root).
- *
- * @param path - A path relative to the folder.
- */
-export function parentOf(path: string): string {
-  const at = path.lastIndexOf('/');
-  return at < 0 ? '' : path.slice(0, at);
-}
-
-/**
- * The last segment of `path`.
- *
- * @param path - A path relative to the folder.
- */
-export function nameOf(path: string): string {
-  return path.slice(path.lastIndexOf('/') + 1);
-}
-
-/**
- * `name` in folder `dir`.
- *
- * @param dir - The folder (`''`: the root).
- * @param name - The entry's name.
- */
-export function inFolder(dir: string, name: string): string {
-  return dir ? `${dir}/${name}` : name;
-}
-
-/**
- * The paths to act on when several are picked: a path inside another picked
- * folder goes with it, so it is left out.
- *
- * @param paths - The picked paths.
- */
-export function topLevelPaths(paths: readonly string[]): string[] {
-  const sorted = [...new Set(paths)].sort();
-  return sorted.filter((path, i) => !sorted.slice(0, i).some((other) => isUnder(path, other)));
-}
-
-/**
- * What a refusal says, in the files labels.
- *
- * @param reason - Why the host refused the action.
- * @param labels - The files labels to read the text from.
- */
-export function entryRefusalText(reason: FilesEntryRefusal, labels: FilesLabels): string {
-  switch (reason) {
-    case 'exists':
-      return labels.filesEntryExists;
-    case 'missing':
-      return labels.filesEntryMissing;
-    case 'invalid':
-      return labels.filesEntryInvalid;
-    case 'too-large':
-      return labels.filesEntryTooLarge;
-    default:
-      return labels.filesEntryDenied;
-  }
-}
-
-/** Rows cut or copied in the tree, waiting for a paste. */
-export interface EntryClipboard {
-  /** `cut`: a paste moves them; `copy`: a paste copies them. */
-  mode: 'cut' | 'copy';
-  /** The folder they come from. */
-  cwd: string;
-  /** Their paths, relative to it. */
-  paths: readonly string[];
-}

package/src/files/headless/fixture-host.ts

@@ -1,260 +0,0 @@
-/**
- * A `FilesHost` that runs in memory, for docs, demos, galleries and tests:
- * a folder of text files with versions, a git status and a working-tree
- * patch you hand it, search over the files, folder changes you fire,
- * editor preferences kept in memory, and the entry actions (the same rules
- * as every backend, `createEntryOps`, over the memory). `control` changes
- * it from outside (another editor wrote a file, the agent touched the folder).
- */
-import { createEntryOps, importEntries, type EntryPort } from 'zidane/chat/pure';
-
-import { createStorageEditorPrefs } from './editor-prefs';
-import { droppedImportItems } from './entries';
-import type {
-  ContentMatch,
-  FilesHost,
-  FilesScope,
-  FolderChange,
-  GitStatusEntry,
-  WorkspaceEntry,
-  WorkspaceFile,
-} from './host';
-import { mediaTypeOfPath } from './media';
-import { matchRanges } from './search';
-
-/** Options of {@link createFixtureFilesHost}. */
-export interface FixtureFilesHostOptions {
-  /** The folder's text files, by path relative to it. */
-  files?: Readonly<Record<string, string>>;
-  /** Its git status. Default: none. */
-  status?: readonly GitStatusEntry[];
-  /** Its working tree against HEAD, as a unified patch. Default: empty. */
-  diff?: string;
-  /** Per-file patches for `workingTreeDiff({ path })`. Default: none (an empty patch). */
-  fileDiffs?: Readonly<Record<string, string>>;
-}
-
-/** Changes the fixture from outside. */
-export interface FixtureFilesControl {
-  /** A file's text now, or `undefined`. */
-  file(path: string): string | undefined;
-  /** Another writer changed (or created) a file: its version moves. */
-  edit(path: string, text: string): void;
-  /** Sets the git status. */
-  setStatus(status: readonly GitStatusEntry[]): void;
-  /** Sets the working-tree patch. */
-  setDiff(diff: string): void;
-  /** The folder may have changed: every watcher hears `why`. */
-  touch(why?: FolderChange): void;
-  /** The empty folders now. */
-  emptyDirs(): string[];
-}
-
-/** The fixture host, with its {@link FixtureFilesControl}. */
-export type FixtureFilesHost = FilesHost & { control: FixtureFilesControl };
-
-function memoryStorage(): Pick<Storage, 'getItem' | 'setItem'> {
-  const items = new Map<string, string>();
-  return {
-    getItem: (key) => items.get(key) ?? null,
-    setItem: (key, value) => void items.set(key, value),
-  };
-}
-
-const utf8Bytes = (text: string) => new TextEncoder().encode(text).length;
-
-const under = (path: string, dir: string) => dir === '.' || path.startsWith(`${dir}/`);
-
-/** Folders with nothing in them: made ones no file or other folder sits under. */
-function emptyDirsOf(files: ReadonlyMap<string, unknown>, dirs: ReadonlySet<string>): string[] {
-  const holds = (dir: string) =>
-    [...files.keys()].some((f) => under(f, dir)) || [...dirs].some((d) => d !== dir && under(d, dir));
-  return [...dirs].filter((dir) => !holds(dir)).sort();
-}
-
-/**
- * An `EntryPort` over the fixture's memory: files by path, made folders, a version clock. Also a fake backend's (tests).
- *
- * @param files - The files, by path, with their text and version.
- * @param dirs - The folders made with no file in them yet.
- * @param tick - The next version number.
- */
-export function memoryEntryPort(
-  files: Map<string, { text: string; version: number }>,
-  dirs: Set<string>,
-  tick: () => number,
-): EntryPort {
-  const norm = (path: string) => (path === '' ? '.' : path);
-  const isDir = (path: string) =>
-    path === '.' ||
-    dirs.has(path) ||
-    [...files.keys()].some((f) => under(f, path)) ||
-    [...dirs].some((d) => under(d, path));
-  const keysUnder = (path: string) => ({
-    files: [...files.keys()].filter((f) => f === path || under(f, path)),
-    dirs: [...dirs].filter((d) => d === path || under(d, path)),
-  });
-  const rebase = (path: string, from: string, to: string) => (path === from ? to : `${to}${path.slice(from.length)}`);
-  const taken = (path: string) => {
-    if (files.has(path) || isDir(path)) throw new Error(`${path} already exists.`);
-  };
-  const addParents = (path: string) => {
-    const parts = path.split('/');
-    for (let i = 1; i < parts.length; i++) dirs.add(parts.slice(0, i).join('/'));
-  };
-  return {
-    stat: async (raw) => {
-      const path = norm(raw);
-      return files.has(path) ? 'file' : isDir(path) ? 'dir' : null;
-    },
-    list: async (raw) => {
-      const path = norm(raw);
-      const names = new Set<string>();
-      for (const key of [...files.keys(), ...dirs]) {
-        if (!under(key, path)) continue;
-        names.add((path === '.' ? key : key.slice(path.length + 1)).split('/')[0]!);
-      }
-      return [...names];
-    },
-    mkdir: async (path) => {
-      addParents(path);
-      dirs.add(path);
-    },
-    write: async (path, bytes) => {
-      taken(path);
-      addParents(path);
-      files.set(path, { text: new TextDecoder().decode(bytes), version: tick() });
-    },
-    move: async (from, to) => {
-      taken(to);
-      const { files: f, dirs: d } = keysUnder(from);
-      addParents(to);
-      for (const key of f) {
-        const entry = files.get(key)!;
-        files.delete(key);
-        files.set(rebase(key, from, to), entry);
-      }
-      for (const key of d) {
-        dirs.delete(key);
-        dirs.add(rebase(key, from, to));
-      }
-    },
-    copy: async (from, to) => {
-      taken(to);
-      const { files: f, dirs: d } = keysUnder(from);
-      addParents(to);
-      for (const key of f) files.set(rebase(key, from, to), { text: files.get(key)!.text, version: tick() });
-      for (const key of d) dirs.add(rebase(key, from, to));
-    },
-    remove: async (path) => {
-      const { files: f, dirs: d } = keysUnder(path);
-      for (const key of f) files.delete(key);
-      for (const key of d) dirs.delete(key);
-    },
-    emptyDirs: async () => emptyDirsOf(files, dirs),
-  };
-}
-
-/**
- * An in-memory {@link FilesHost}: list, read, write (version-guarded), search, git status, the working-tree diff,
- * watch and editor preferences. No diagnostics, language servers, system actions or media addresses.
- *
- * @param options - The files, the git status and the patches it starts with.
- */
-export function createFixtureFilesHost(options: FixtureFilesHostOptions = {}): FixtureFilesHost {
-  const files = new Map<string, { text: string; version: number }>();
-  let clock = 1;
-  for (const [path, text] of Object.entries(options.files ?? {})) files.set(path, { text, version: clock++ });
-  let status = [...(options.status ?? [])];
-  let diff = options.diff ?? '';
-  const fileDiffs = options.fileDiffs ?? {};
-  const watchers = new Set<(why: FolderChange) => void>();
-  /** Folders made with nothing in them yet (a folder holding a file is implied by it). */
-  const dirs = new Set<string>();
-  const port = memoryEntryPort(files, dirs, () => clock++);
-  const ops = createEntryOps(port);
-
-  const toFile = (path: string, entry: { text: string; version: number }): WorkspaceFile => {
-    const media = mediaTypeOfPath(path);
-    return {
-      path,
-      contents: media ? '' : entry.text,
-      truncated: false,
-      size: utf8Bytes(entry.text),
-      binary: media !== null,
-      mtimeMs: entry.version,
-    };
-  };
-
-  const control: FixtureFilesControl = {
-    file: (path) => files.get(path)?.text,
-    edit(path, text) {
-      files.set(path, { text, version: clock++ });
-    },
-    setStatus(next) {
-      status = [...next];
-    },
-    setDiff(next) {
-      diff = next;
-    },
-    touch(why = 'tool-result') {
-      for (const w of [...watchers]) w(why);
-    },
-    emptyDirs: () => emptyDirsOf(files, dirs),
-  };
-
-  return {
-    control,
-    async list() {
-      const entries: WorkspaceEntry[] = [
-        ...[...files.keys()].map((path): WorkspaceEntry => ({ path, kind: 'file' })),
-        ...emptyDirsOf(files, dirs).map((path): WorkspaceEntry => ({ path: `${path}/`, kind: 'dir' })),
-      ];
-      return entries.sort((a, b) => a.path.localeCompare(b.path));
-    },
-    async read(_cwd, path) {
-      const entry = files.get(path);
-      return entry ? toFile(path, entry) : null;
-    },
-    async write(_cwd, path, contents, expectedMtimeMs) {
-      const entry = files.get(path);
-      if (!entry) return { ok: false, reason: 'missing' };
-      if (entry.version !== expectedMtimeMs) return { ok: false, reason: 'changed' };
-      const next = { text: contents, version: clock++ };
-      files.set(path, next);
-      return { ok: true, mtimeMs: next.version };
-    },
-    async search(_cwd, query, opts) {
-      const matches: ContentMatch[] = [];
-      if (query)
-        for (const [path, { text }] of [...files].sort(([a], [b]) => a.localeCompare(b))) {
-          text.split('\n').forEach((line, i) => {
-            const ranges = matchRanges(line, query, opts);
-            if (ranges.length) matches.push({ path, line: i + 1, text: line, ranges });
-          });
-        }
-      return { matches, capped: false, engine: query ? 'walk' : 'none' };
-    },
-    entries: {
-      create: (_cwd, path, kind) => ops.create(path, kind),
-      move: (_cwd, from, to) => ops.move(from, to),
-      copy: (_cwd, from, toDir) => ops.copy(from, toDir),
-      remove: (_cwd, path) => ops.remove(path),
-      importFiles: async (_cwd, dir, items) => importEntries(ops.create, dir, await droppedImportItems(items)),
-      removal: () => 'permanent',
-    },
-    async gitStatus() {
-      return [...status];
-    },
-    async workingTreeDiff(_cwd, opts) {
-      return opts?.path !== undefined ? (fileDiffs[opts.path] ?? '') : diff;
-    },
-    watch(_scope: FilesScope, onChange) {
-      watchers.add(onChange);
-      return () => {
-        watchers.delete(onChange);
-      };
-    },
-    editorPrefs: createStorageEditorPrefs({ storage: memoryStorage(), watch: () => () => {} }),
-  };
-}