@statewalker/file-panels.core 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) {{year}} Mikhail Kotelnikov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,207 @@
-# Temporary Holding Version
+# @statewalker/file-panels.core
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+## What it is
+
+The logic behind a file panel, without any rendering: a `PanelModel` that lists one folder of the
+mounted storages into `@statewalker/explorer.core`'s `FilesListModel`, a safe copy and move across
+storages with byte progress, file operations (create folder, rename, delete, transfer) that report
+what they changed, a breadcrumb, desktop-drop import, and the interfaces a search provider
+implements. React-free.
+
+## Why it exists
+
+`FilesListModel` holds entries, sort, filter, cursor and selection, but does no I/O and knows
+nothing about storages that can be locked or unreachable. A panel manager needs more: the reason a
+folder cannot be read, the nearest folder that still exists when one disappears, refreshes when
+another panel changes the same folder, and copies between a local folder and an S3 bucket that
+never leave a half-written target behind. This package is that layer, so the views stay thin.
+
+## How to use
+
+```ts
+import { newFileChanges } from "@statewalker/file-mounts.core";
+import { FileOperations, PanelModel } from "@statewalker/file-panels.core";
+
+const changes = newFileChanges();            // the one stream of changes
+const ops = new FileOperations(files, changes); // files: the mounted storages (a FilesApi)
+const panel = new PanelModel({
+  id: "left",
+  files,
+  changes,
+  mountNames: () => ({ docs: "Documents" }),  // display names for the first path segment
+});
+
+await panel.navigate("/docs/clients");
+panel.list.getVisibleEntries();               // what the view shows
+panel.problem;                                // set when the folder cannot be read
+panel.breadcrumb();                           // [{ name: "Documents", path: "/docs", isMount: true }, ...]
+```
+
+## Examples
+
+### A panel shows why a folder cannot be read
+
+```ts
+await panel.navigate("/archive");
+panel.problem;  // { cause: "locked", message: "Locked: unlock to use the S3 storages." }
+panel.list.entries; // [] : a locked storage is a problem, not an empty folder
+```
+
+### A folder that vanished moves the panel up, with a notice
+
+```ts
+await panel.navigate("/docs/clients/gone/deeper");
+panel.state.path; // "/docs/clients"
+panel.notice;     // "deeper no longer exists."
+```
+
+### Copy and move with progress and cancel
+
+```ts
+import { planTransfer } from "@statewalker/file-panels.core"; // only for the clash dialog
+
+const controller = new AbortController();
+const { plan, result } = await ops.transfer(
+  { op: "move", sources: ["/docs/a.pdf"], targetDir: "/archive/2026", clash: "keep-both" },
+  { signal: controller.signal, onProgress: (p) => console.log(p.bytesDone, "/", p.bytesTotal) },
+);
+result.failed; // [{ path, problem: { message } }]: one entry per step that did not complete
+```
+
+`transfer` throws `plan.invalid` (for example "A folder can't be copied or moved into itself.")
+before touching anything, and throws when the target can't be listed for planning (a locked or
+unreachable storage). Once steps run it does not throw: a storage that goes away mid-run fails the
+remaining steps in `result.failed`, and the steps already done stay in `result.done`. To show the clash dialog first, call `planTransfer(files, request)`
+yourself: `plan.clashes` names the taken names.
+
+### Folder operations
+
+```ts
+await ops.mkdir("/docs", "reports");      // returns the new path; refuses a taken name
+await ops.rename("/docs/a.pdf", "b.pdf"); // returns the new path
+await ops.remove(["/docs/b.pdf"]);
+```
+
+### A desktop drop becomes a source
+
+```ts
+import { importDropped } from "@statewalker/file-panels.core";
+
+element.addEventListener("drop", async (event) => {
+  event.preventDefault();
+  const dropped = await importDropped(event.dataTransfer);   // { files, paths }
+  await ops.transfer(
+    { op: "copy", sources: dropped.paths, targetDir: panel.state.path, clash: "keep-both" },
+    { source: dropped.files },
+  );
+});
+```
+
+`sources` are paths in `source`, the target is in the operations' own files. For the run,
+`FileOperations` mounts `source` at `/.drop` beside its files, so the returned `plan` and `result`
+name the dropped items as `/.drop/drop/...`. Passing the drop's `MemFilesApi` as the operations'
+files instead would copy inside that throwaway storage and write nothing to the workspace.
+
+### Persisting the layout
+
+`panel.state` is `{ id, path, sort: { field, descending } }`: what a dock layout saves and restores.
+
+## Internals
+
+### The transfer never leaves a partial or silently replaced target
+
+Each step is written under a hidden sibling name (`.<name>.part-<random>`) and swapped into place
+only when complete. This is the reason a cancel or a failure leaves nothing partial under the real
+name, and why an overwritten folder is replaced rather than merged: the old one is set aside
+(`.<name>.old-<random>`), the new one moved in, then the old one removed. Copying straight into the
+target would merge folders and leave half a file behind on cancel; neither is acceptable when the
+target is the only copy of someone's data.
+
+What the person sees when something goes differently than planned:
+
+| Situation | Message |
+| --- | --- |
+| The name was free when planned and taken since, without overwrite | "`name` appeared there meanwhile; nothing was replaced." |
+| A move copied everything, but the source changed or grew while it ran | "It changed during the move: the copy is done, and `from` keeps what changed." |
+| The source is gone when the step starts or ends | "It no longer exists." |
+| The item is the target or contains it | "An item can't be copied or moved into itself." |
+| Swapping in failed and the old target could not be put back | the cause, then "The old version is kept as `.name.old-xxxx`." |
+| Rename or create onto a taken name | "`name` already exists here." |
+
+A move deletes only what it copied unchanged: each source file is removed only if its size and
+modification time still match what was copied, and folders only once empty. A failed step does not
+stop the others; `result.failed` has one entry per failed step and `result.done` the rest. Cancel
+returns `result.cancelled: true` and removes the temporary sibling of the file in flight.
+
+The hidden names matter when they surface: a crash, or a failed rollback, can leave a `.name.part-*`
+or `.name.old-*` folder next to the target. The latter holds the previous version and the failed
+rollback message names its path.
+
+### Overwriting a folder on S3 costs a server-side copy and delete per object
+
+S3 has no rename. The final move of the temporary sibling into place is a server-side copy followed
+by a delete for every object under it, so replacing a large folder on a bucket takes time
+proportional to its object count, even though no bytes are downloaded. Within one storage a copy
+is delegated to the backend (`files.copy` / `files.move`) and overwrites go through the same
+temporary-sibling swap.
+
+### The remaining window
+
+Whether a target exists is checked just before the write or the swap, not atomically with it. Two
+writers racing for the same name inside that gap can still replace each other. Closing it needs
+conditional writes (`If-None-Match`) from the storage itself, which `FilesApi` does not expose.
+
+### The change stream and who listens
+
+`FileOperations` emits `FileChange` events (`added`, `updated`, `deleted`) on the hub it is given,
+reporting what is really on disk: a failed transfer step still reports a target that was written
+and a source that was partly cleaned. When the storage can't be asked any more (it became
+unavailable mid-run), the target and source of a failed step are reported as `updated`, so a panel
+refreshes and shows either the files or the storage's problem. With `opts.source` (a drop) no
+source-side events are emitted, since those paths mean nothing to listeners.
+
+After an unlock or a reconnect, the mount table's `apply` returns the changed mount roots; pass them
+on with `changes.emit(await table.apply(configs))`. Without that, a panel showing
+"Locked: unlock to use the S3 storages." keeps showing it until it is navigated again. `PanelModel` subscribes to the optional `changes` and
+refreshes when a change is inside the folder it was last asked to show, is that folder itself, or
+is one of its ancestors; any other change is ignored. The asked-for folder counts even while its
+listing is still loading, so a change in the previous folder never cancels the navigation; after a
+fallback to an ancestor, the folder shown becomes the one that is tracked. Call `dispose()` to
+unsubscribe; it also makes any listing still in flight be ignored, so a disposed panel never writes
+to its list or notifies. A later indexer is meant to follow the same stream.
+
+### Newest navigation wins
+
+`navigate` lists the whole folder before touching the `FilesListModel`, and each call carries a
+sequence number. A slow listing that finishes after a newer `navigate` returns without writing, so
+the newer folder's entries are never replaced. Listing first also means the list is not blanked
+for a folder that turns out to be unreadable until the result is known.
+
+### Why `importDropped` reads entries before the first `await`
+
+Browsers empty a `DataTransfer` once the drop handler returns synchronously. `importDropped` takes
+`webkitGetAsEntry()` for every item first, then reads the files asynchronously into a `MemFilesApi`
+under `/drop/...`. If it awaited first, the drop would look empty. Where the browser has no
+entries API only the plain files are taken, so dropped folders are lost there.
+
+### Search is an interface only
+
+`SearchProvider` (`id`, `search(query, { scope, signal })` yielding `SearchHit`) and `SearchHit`
+(`path`, `title`, `snippet?`, `score`) are types; nothing in this package implements them. They are
+the seam where a full-text index over the mounts plugs in later.
+
+### Constraints and dependencies
+
+- `runTransfer` decides whether a step crosses storages by the first path segment (a cross-storage
+  step is streamed through a temporary sibling, an in-storage one delegated to the backend); its
+  `mountOf` option overrides that when the mount table differs.
+- The target folder must be inside a storage: `/` is refused ("Choose a folder inside a storage.").
+- Depends on `@statewalker/explorer.core` (the list model), `@statewalker/file-mounts.core`
+  (`FileChanges`, `Problem`, `problemOf`), `@statewalker/shared-baseclass` (`BaseClass`),
+  `@statewalker/webrun-files` (`FilesApi`, path helpers), `@statewalker/webrun-files-mem`
+  (the drop's in-memory storage) and `@statewalker/webrun-files-composite` (mounting a drop beside
+  the storages for a transfer).
+
+## License
+
+MIT

package/dist/file-operations.d.ts

@@ -0,0 +1,32 @@
+import { TransferPlan, TransferRequest } from "./transfer-plan.js";
+import { TransferProgress, TransferResult } from "./transfer-run.js";
+import { FilesApi } from "@statewalker/webrun-files";
+import { FileChangesHub } from "@statewalker/file-mounts.core";
+//#region src/file-operations.d.ts
+export declare class FileOperations {
+  readonly files: FilesApi;
+  readonly changes: FileChangesHub;
+  constructor(files: FilesApi, changes: FileChangesHub);
+  /**
+   * Plans and runs a copy or move. `source` is a foreign source (a desktop drop): its
+   * paths are taken from it, mounted at `/.drop` beside these files for the run.
+   */
+  transfer(request: TransferRequest, opts?: {
+    source?: FilesApi;
+    signal?: AbortSignal;
+    onProgress?(p: TransferProgress): void;
+  }): Promise<{
+    plan: TransferPlan;
+    result: TransferResult;
+  }>;
+  /** Whether `path` exists; `undefined` when its storage went away mid-run and can't say. */
+  private probe;
+  mkdir(dir: string, name: string): Promise<string>;
+  /** Never replaces: a name taken since the dialog opened is refused. */
+  rename(path: string, name: string): Promise<string>;
+  /** Reports the paths actually removed, even when a later one fails. */
+  remove(paths: string[]): Promise<void>;
+  private freePath;
+}
+//#endregion
+//# sourceMappingURL=file-operations.d.ts.map

package/dist/file-operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-operations.d.ts","names":[],"sources":["../src/file-operations.ts"],"mappings":";;;;;qBAiBa;WAEA,OAAO;WACP,SAAS;EAFpB,YACW,OAAO,UACP,SAAS;;;;;EAOd,SACJ,SAAS,iBACT;IAAQ,SAAS;IAAU,SAAS;IAAa,YAAY,GAAG;MAC/D;IAAU,MAAM;IAAc,QAAQ;;;UA0B3B;EAQR,MAAM,aAAa,eAAe;;EAQlC,OAAO,cAAc,eAAe;;EAWpC,OAAO,kBAAkB;UAWjB"}

package/dist/file-operations.js

@@ -0,0 +1,106 @@
+import { planTransfer, validateName } from "./transfer-plan.js";
+import { runTransfer } from "./transfer-run.js";
+import { dirname, joinPath } from "@statewalker/webrun-files";
+import { CompositeFilesApi } from "@statewalker/webrun-files-composite";
+//#region src/file-operations.ts
+/** Where a foreign source is mounted while a transfer runs. */
+const DROP = "/.drop";
+var FileOperations = class {
+	files;
+	changes;
+	constructor(files, changes) {
+		this.files = files;
+		this.changes = changes;
+	}
+	/**
+	* Plans and runs a copy or move. `source` is a foreign source (a desktop drop): its
+	* paths are taken from it, mounted at `/.drop` beside these files for the run.
+	*/
+	async transfer(request, opts = {}) {
+		const { source } = opts;
+		const files = source ? new CompositeFilesApi(this.files).mount(DROP, source) : this.files;
+		if (source) request = {
+			...request,
+			sources: request.sources.map((s) => joinPath(DROP, s))
+		};
+		const plan = await planTransfer(files, request);
+		if (plan.invalid) throw new Error(plan.invalid);
+		const result = await runTransfer(files, plan, opts);
+		const failed = new Set(result.failed.map((f) => f.path));
+		const changes = [];
+		for (const step of plan.steps) {
+			const done = result.done.includes(step.from);
+			const target = done || !failed.has(step.from) ? done : await this.probe(step.to);
+			if (target === false) continue;
+			const written = step.overwrite ? "updated" : "added";
+			changes.push({
+				type: target === void 0 ? "updated" : written,
+				path: step.to
+			});
+			if (step.op !== "move" || source) continue;
+			const stays = !done && await this.probe(step.from) !== false;
+			changes.push({
+				type: stays ? "updated" : "deleted",
+				path: step.from
+			});
+		}
+		this.changes.emit(changes);
+		return {
+			plan,
+			result
+		};
+	}
+	/** Whether `path` exists; `undefined` when its storage went away mid-run and can't say. */
+	async probe(path) {
+		try {
+			return await this.files.exists(path);
+		} catch {
+			return;
+		}
+	}
+	async mkdir(dir, name) {
+		const path = await this.freePath(dir, name);
+		await this.files.mkdir(path);
+		this.changes.emit([{
+			type: "added",
+			path
+		}]);
+		return path;
+	}
+	/** Never replaces: a name taken since the dialog opened is refused. */
+	async rename(path, name) {
+		const to = await this.freePath(dirname(path), name);
+		if (!await this.files.move(path, to)) throw new Error("It no longer exists.");
+		this.changes.emit([{
+			type: "deleted",
+			path
+		}, {
+			type: "added",
+			path: to
+		}]);
+		return to;
+	}
+	/** Reports the paths actually removed, even when a later one fails. */
+	async remove(paths) {
+		const removed = [];
+		try {
+			for (const path of paths) if (await this.files.remove(path)) removed.push({
+				type: "deleted",
+				path
+			});
+		} finally {
+			this.changes.emit(removed);
+		}
+	}
+	async freePath(dir, name) {
+		const invalid = validateName(name);
+		if (invalid) throw new Error(invalid);
+		const path = joinPath(dir, name);
+		if (await this.files.exists(path)) throw new Error(`${name} already exists here.`);
+		return path;
+	}
+};
+//#endregion
+export { FileOperations };
+
+//# sourceMappingURL=file-operations.js.map

package/dist/file-operations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-operations.js","names":[],"sources":["../src/file-operations.ts"],"sourcesContent":["// The operations a panel offers, each reporting what it changed on the one\n// change stream: panels refresh from it, an indexer will follow it.\nimport type { FileChange, FileChangesHub } from \"@statewalker/file-mounts.core\";\nimport type { FilesApi } from \"@statewalker/webrun-files\";\nimport { dirname, joinPath } from \"@statewalker/webrun-files\";\nimport { CompositeFilesApi } from \"@statewalker/webrun-files-composite\";\nimport {\n  planTransfer,\n  type TransferPlan,\n  type TransferRequest,\n  validateName,\n} from \"./transfer-plan.js\";\nimport { runTransfer, type TransferProgress, type TransferResult } from \"./transfer-run.js\";\n\n/** Where a foreign source is mounted while a transfer runs. */\nconst DROP = \"/.drop\";\n\nexport class FileOperations {\n  constructor(\n    readonly files: FilesApi,\n    readonly changes: FileChangesHub,\n  ) {}\n\n  /**\n   * Plans and runs a copy or move. `source` is a foreign source (a desktop drop): its\n   * paths are taken from it, mounted at `/.drop` beside these files for the run.\n   */\n  async transfer(\n    request: TransferRequest,\n    opts: { source?: FilesApi; signal?: AbortSignal; onProgress?(p: TransferProgress): void } = {},\n  ): Promise<{ plan: TransferPlan; result: TransferResult }> {\n    const { source } = opts;\n    const files = source ? new CompositeFilesApi(this.files).mount(DROP, source) : this.files;\n    if (source) request = { ...request, sources: request.sources.map((s) => joinPath(DROP, s)) };\n    const plan = await planTransfer(files, request);\n    if (plan.invalid) throw new Error(plan.invalid);\n    const result = await runTransfer(files, plan, opts);\n    const failed = new Set(result.failed.map((f) => f.path));\n    const changes: FileChange[] = [];\n    for (const step of plan.steps) {\n      const done = result.done.includes(step.from);\n      // A failed step may have written its target or cleaned part of its source: look.\n      const target = done || !failed.has(step.from) ? done : await this.probe(step.to);\n      if (target === false) continue;\n      const written = step.overwrite ? \"updated\" : \"added\";\n      changes.push({ type: target === undefined ? \"updated\" : written, path: step.to });\n      // Source-side paths of a foreign source mean nothing to listeners.\n      if (step.op !== \"move\" || source) continue;\n      const stays = !done && (await this.probe(step.from)) !== false;\n      changes.push({ type: stays ? \"updated\" : \"deleted\", path: step.from });\n    }\n    this.changes.emit(changes);\n    return { plan, result };\n  }\n\n  /** Whether `path` exists; `undefined` when its storage went away mid-run and can't say. */\n  private async probe(path: string): Promise<boolean | undefined> {\n    try {\n      return await this.files.exists(path);\n    } catch {\n      return undefined;\n    }\n  }\n\n  async mkdir(dir: string, name: string): Promise<string> {\n    const path = await this.freePath(dir, name);\n    await this.files.mkdir(path);\n    this.changes.emit([{ type: \"added\", path }]);\n    return path;\n  }\n\n  /** Never replaces: a name taken since the dialog opened is refused. */\n  async rename(path: string, name: string): Promise<string> {\n    const to = await this.freePath(dirname(path), name);\n    if (!(await this.files.move(path, to))) throw new Error(\"It no longer exists.\");\n    this.changes.emit([\n      { type: \"deleted\", path },\n      { type: \"added\", path: to },\n    ]);\n    return to;\n  }\n\n  /** Reports the paths actually removed, even when a later one fails. */\n  async remove(paths: string[]): Promise<void> {\n    const removed: FileChange[] = [];\n    try {\n      for (const path of paths) {\n        if (await this.files.remove(path)) removed.push({ type: \"deleted\", path });\n      }\n    } finally {\n      this.changes.emit(removed);\n    }\n  }\n\n  private async freePath(dir: string, name: string): Promise<string> {\n    const invalid = validateName(name);\n    if (invalid) throw new Error(invalid);\n    const path = joinPath(dir, name);\n    if (await this.files.exists(path)) throw new Error(`${name} already exists here.`);\n    return path;\n  }\n}\n"],"mappings":";;;;;;AAeA,MAAM,OAAO;AAEb,IAAa,iBAAb,MAA4B;CAEf;CACA;CAFX,YACE,OACA,SACA;EAFS,KAAA,QAAA;EACA,KAAA,UAAA;CACR;;;;;CAMH,MAAM,SACJ,SACA,OAA4F,CAAC,GACpC;EACzD,MAAM,EAAE,WAAW;EACnB,MAAM,QAAQ,SAAS,IAAI,kBAAkB,KAAK,KAAK,CAAC,CAAC,MAAM,MAAM,MAAM,IAAI,KAAK;EACpF,IAAI,QAAQ,UAAU;GAAE,GAAG;GAAS,SAAS,QAAQ,QAAQ,KAAK,MAAM,SAAS,MAAM,CAAC,CAAC;EAAE;EAC3F,MAAM,OAAO,MAAM,aAAa,OAAO,OAAO;EAC9C,IAAI,KAAK,SAAS,MAAM,IAAI,MAAM,KAAK,OAAO;EAC9C,MAAM,SAAS,MAAM,YAAY,OAAO,MAAM,IAAI;EAClD,MAAM,SAAS,IAAI,IAAI,OAAO,OAAO,KAAK,MAAM,EAAE,IAAI,CAAC;EACvD,MAAM,UAAwB,CAAC;EAC/B,KAAK,MAAM,QAAQ,KAAK,OAAO;GAC7B,MAAM,OAAO,OAAO,KAAK,SAAS,KAAK,IAAI;GAE3C,MAAM,SAAS,QAAQ,CAAC,OAAO,IAAI,KAAK,IAAI,IAAI,OAAO,MAAM,KAAK,MAAM,KAAK,EAAE;GAC/E,IAAI,WAAW,OAAO;GACtB,MAAM,UAAU,KAAK,YAAY,YAAY;GAC7C,QAAQ,KAAK;IAAE,MAAM,WAAW,KAAA,IAAY,YAAY;IAAS,MAAM,KAAK;GAAG,CAAC;GAEhF,IAAI,KAAK,OAAO,UAAU,QAAQ;GAClC,MAAM,QAAQ,CAAC,QAAS,MAAM,KAAK,MAAM,KAAK,IAAI,MAAO;GACzD,QAAQ,KAAK;IAAE,MAAM,QAAQ,YAAY;IAAW,MAAM,KAAK;GAAK,CAAC;EACvE;EACA,KAAK,QAAQ,KAAK,OAAO;EACzB,OAAO;GAAE;GAAM;EAAO;CACxB;;CAGA,MAAc,MAAM,MAA4C;EAC9D,IAAI;GACF,OAAO,MAAM,KAAK,MAAM,OAAO,IAAI;EACrC,QAAQ;GACN;EACF;CACF;CAEA,MAAM,MAAM,KAAa,MAA+B;EACtD,MAAM,OAAO,MAAM,KAAK,SAAS,KAAK,IAAI;EAC1C,MAAM,KAAK,MAAM,MAAM,IAAI;EAC3B,KAAK,QAAQ,KAAK,CAAC;GAAE,MAAM;GAAS;EAAK,CAAC,CAAC;EAC3C,OAAO;CACT;;CAGA,MAAM,OAAO,MAAc,MAA+B;EACxD,MAAM,KAAK,MAAM,KAAK,SAAS,QAAQ,IAAI,GAAG,IAAI;EAClD,IAAI,CAAE,MAAM,KAAK,MAAM,KAAK,MAAM,EAAE,GAAI,MAAM,IAAI,MAAM,sBAAsB;EAC9E,KAAK,QAAQ,KAAK,CAChB;GAAE,MAAM;GAAW;EAAK,GACxB;GAAE,MAAM;GAAS,MAAM;EAAG,CAC5B,CAAC;EACD,OAAO;CACT;;CAGA,MAAM,OAAO,OAAgC;EAC3C,MAAM,UAAwB,CAAC;EAC/B,IAAI;GACF,KAAK,MAAM,QAAQ,OACjB,IAAI,MAAM,KAAK,MAAM,OAAO,IAAI,GAAG,QAAQ,KAAK;IAAE,MAAM;IAAW;GAAK,CAAC;EAE7E,UAAU;GACR,KAAK,QAAQ,KAAK,OAAO;EAC3B;CACF;CAEA,MAAc,SAAS,KAAa,MAA+B;EACjE,MAAM,UAAU,aAAa,IAAI;EACjC,IAAI,SAAS,MAAM,IAAI,MAAM,OAAO;EACpC,MAAM,OAAO,SAAS,KAAK,IAAI;EAC/B,IAAI,MAAM,KAAK,MAAM,OAAO,IAAI,GAAG,MAAM,IAAI,MAAM,GAAG,KAAK,sBAAsB;EACjF,OAAO;CACT;AACF"}

package/dist/import-dropped.d.ts

@@ -0,0 +1,13 @@
+import { FilesApi } from "@statewalker/webrun-files";
+//#region src/import-dropped.d.ts
+/**
+ * Reads a drop into a `MemFilesApi` under `/drop/…`; `paths` are the dropped
+ * items themselves. Folders are read through `webkitGetAsEntry` when the
+ * browser offers it, otherwise only the plain `files` are taken.
+ */
+export declare function importDropped(data: DataTransfer): Promise<{
+  files: FilesApi;
+  paths: string[];
+}>;
+//#endregion
+//# sourceMappingURL=import-dropped.d.ts.map

package/dist/import-dropped.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-dropped.d.ts","names":[],"sources":["../src/import-dropped.ts"],"mappings":";;;;;;;wBAyBsB,cACpB,MAAM,eACL;EAAU,OAAO;EAAU"}

package/dist/import-dropped.js

@@ -0,0 +1,46 @@
+import { joinPath } from "@statewalker/webrun-files";
+import { MemFilesApi } from "@statewalker/webrun-files-mem";
+//#region src/import-dropped.ts
+const ROOT = "/drop";
+/**
+* Reads a drop into a `MemFilesApi` under `/drop/…`; `paths` are the dropped
+* items themselves. Folders are read through `webkitGetAsEntry` when the
+* browser offers it, otherwise only the plain `files` are taken.
+*/
+async function importDropped(data) {
+	const entries = Array.from(data.items ?? []).map((item) => item.webkitGetAsEntry?.()).filter((e) => Boolean(e));
+	const plain = Array.from(data.files ?? []);
+	const files = new MemFilesApi();
+	const write = async (path, file) => files.write(path, [new Uint8Array(await file.arrayBuffer())]);
+	if (!entries.length) {
+		for (const file of plain) await write(joinPath(ROOT, file.name), file);
+		return {
+			files,
+			paths: plain.map((f) => joinPath(ROOT, f.name))
+		};
+	}
+	const walk = async (entry) => {
+		const path = joinPath(ROOT, entry.fullPath);
+		if (entry.isFile && entry.file) {
+			const file = await new Promise((ok, fail) => entry.file?.(ok, fail));
+			await write(path, file);
+		} else if (entry.isDirectory && entry.createReader) {
+			await files.mkdir(path);
+			const reader = entry.createReader();
+			for (;;) {
+				const batch = await new Promise((ok, fail) => reader.readEntries(ok, fail));
+				if (!batch.length) break;
+				for (const child of batch) await walk(child);
+			}
+		}
+	};
+	for (const entry of entries) await walk(entry);
+	return {
+		files,
+		paths: entries.map((e) => joinPath(ROOT, e.fullPath))
+	};
+}
+//#endregion
+export { importDropped };
+
+//# sourceMappingURL=import-dropped.js.map

package/dist/import-dropped.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-dropped.js","names":[],"sources":["../src/import-dropped.ts"],"sourcesContent":["// Files and folders dropped from the desktop, read into memory so the same\n// planner and runner copy them like any other source.\nimport type { FilesApi } from \"@statewalker/webrun-files\";\nimport { joinPath } from \"@statewalker/webrun-files\";\nimport { MemFilesApi } from \"@statewalker/webrun-files-mem\";\n\n// The parts of FileSystemEntry this reads; a test passes plain objects.\ninterface Entry {\n  isFile: boolean;\n  isDirectory: boolean;\n  name: string;\n  fullPath: string;\n  file?(ok: (file: File) => void, fail?: (error: unknown) => void): void;\n  createReader?(): {\n    readEntries(ok: (entries: Entry[]) => void, fail?: (e: unknown) => void): void;\n  };\n}\n\nconst ROOT = \"/drop\";\n\n/**\n * Reads a drop into a `MemFilesApi` under `/drop/…`; `paths` are the dropped\n * items themselves. Folders are read through `webkitGetAsEntry` when the\n * browser offers it, otherwise only the plain `files` are taken.\n */\nexport async function importDropped(\n  data: DataTransfer,\n): Promise<{ files: FilesApi; paths: string[] }> {\n  // Entries must be taken before the first await: the browser empties the\n  // DataTransfer once the drop event handler returns.\n  const entries = Array.from(data.items ?? [])\n    .map((item) => item.webkitGetAsEntry?.() as Entry | null | undefined)\n    .filter((e): e is Entry => Boolean(e));\n  const plain = Array.from(data.files ?? []);\n  const files = new MemFilesApi();\n  const write = async (path: string, file: File) =>\n    files.write(path, [new Uint8Array(await file.arrayBuffer())]);\n\n  if (!entries.length) {\n    for (const file of plain) await write(joinPath(ROOT, file.name), file);\n    return { files, paths: plain.map((f) => joinPath(ROOT, f.name)) };\n  }\n\n  const walk = async (entry: Entry): Promise<void> => {\n    const path = joinPath(ROOT, entry.fullPath);\n    if (entry.isFile && entry.file) {\n      const file = await new Promise<File>((ok, fail) => entry.file?.(ok, fail));\n      await write(path, file);\n    } else if (entry.isDirectory && entry.createReader) {\n      await files.mkdir(path);\n      const reader = entry.createReader();\n      // readEntries returns a batch at a time, and an empty batch at the end.\n      for (;;) {\n        const batch = await new Promise<Entry[]>((ok, fail) => reader.readEntries(ok, fail));\n        if (!batch.length) break;\n        for (const child of batch) await walk(child);\n      }\n    }\n  };\n  for (const entry of entries) await walk(entry);\n  return { files, paths: entries.map((e) => joinPath(ROOT, e.fullPath)) };\n}\n"],"mappings":";;;AAkBA,MAAM,OAAO;;;;;;AAOb,eAAsB,cACpB,MAC+C;CAG/C,MAAM,UAAU,MAAM,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,CACzC,KAAK,SAAS,KAAK,mBAAmB,CAA6B,CAAC,CACpE,QAAQ,MAAkB,QAAQ,CAAC,CAAC;CACvC,MAAM,QAAQ,MAAM,KAAK,KAAK,SAAS,CAAC,CAAC;CACzC,MAAM,QAAQ,IAAI,YAAY;CAC9B,MAAM,QAAQ,OAAO,MAAc,SACjC,MAAM,MAAM,MAAM,CAAC,IAAI,WAAW,MAAM,KAAK,YAAY,CAAC,CAAC,CAAC;CAE9D,IAAI,CAAC,QAAQ,QAAQ;EACnB,KAAK,MAAM,QAAQ,OAAO,MAAM,MAAM,SAAS,MAAM,KAAK,IAAI,GAAG,IAAI;EACrE,OAAO;GAAE;GAAO,OAAO,MAAM,KAAK,MAAM,SAAS,MAAM,EAAE,IAAI,CAAC;EAAE;CAClE;CAEA,MAAM,OAAO,OAAO,UAAgC;EAClD,MAAM,OAAO,SAAS,MAAM,MAAM,QAAQ;EAC1C,IAAI,MAAM,UAAU,MAAM,MAAM;GAC9B,MAAM,OAAO,MAAM,IAAI,SAAe,IAAI,SAAS,MAAM,OAAO,IAAI,IAAI,CAAC;GACzE,MAAM,MAAM,MAAM,IAAI;EACxB,OAAO,IAAI,MAAM,eAAe,MAAM,cAAc;GAClD,MAAM,MAAM,MAAM,IAAI;GACtB,MAAM,SAAS,MAAM,aAAa;GAElC,SAAS;IACP,MAAM,QAAQ,MAAM,IAAI,SAAkB,IAAI,SAAS,OAAO,YAAY,IAAI,IAAI,CAAC;IACnF,IAAI,CAAC,MAAM,QAAQ;IACnB,KAAK,MAAM,SAAS,OAAO,MAAM,KAAK,KAAK;GAC7C;EACF;CACF;CACA,KAAK,MAAM,SAAS,SAAS,MAAM,KAAK,KAAK;CAC7C,OAAO;EAAE;EAAO,OAAO,QAAQ,KAAK,MAAM,SAAS,MAAM,EAAE,QAAQ,CAAC;CAAE;AACxE"}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { ClashPolicy, TransferOp, TransferPlan, TransferRequest, TransferStep, findClashes, freeName, planTransfer, validateName } from "./transfer-plan.js";
+import { TransferProgress, TransferResult, runTransfer } from "./transfer-run.js";
+import { FileOperations } from "./file-operations.js";
+import { importDropped } from "./import-dropped.js";
+import { Crumb, breadcrumb, siblings } from "./paths.js";
+import { PanelModel, PanelState } from "./panel-model.js";
+import { SearchHit, SearchProvider } from "./search.js";
+export { ClashPolicy, Crumb, FileOperations, PanelModel, PanelState, type SearchHit, type SearchProvider, TransferOp, TransferPlan, TransferProgress, TransferRequest, TransferResult, TransferStep, breadcrumb, findClashes, freeName, importDropped, planTransfer, runTransfer, siblings, validateName };

package/dist/index.js

@@ -0,0 +1,7 @@
+import { findClashes, freeName, planTransfer, validateName } from "./transfer-plan.js";
+import { runTransfer } from "./transfer-run.js";
+import { FileOperations } from "./file-operations.js";
+import { importDropped } from "./import-dropped.js";
+import { breadcrumb, siblings } from "./paths.js";
+import { PanelModel } from "./panel-model.js";
+export { FileOperations, PanelModel, breadcrumb, findClashes, freeName, importDropped, planTransfer, runTransfer, siblings, validateName };

package/dist/panel-model.d.ts

@@ -0,0 +1,46 @@
+import { Crumb } from "./paths.js";
+import { FilesApi } from "@statewalker/webrun-files";
+import { FileChanges, Problem } from "@statewalker/file-mounts.core";
+import { FilesListModel } from "@statewalker/explorer.core";
+import { BaseClass } from "@statewalker/shared-baseclass";
+//#region src/panel-model.d.ts
+export interface PanelState {
+  id: string;
+  path: string;
+  sort: {
+    field: FilesListModel["sortField"];
+    descending: boolean;
+  };
+}
+export declare class PanelModel extends BaseClass {
+  readonly id: string;
+  readonly list: FilesListModel;
+  problem?: Problem;
+  notice?: string;
+  private loads;
+  /** The folder most recently asked for; `list.path` only changes when a load completes. */
+  private target;
+  private readonly files;
+  private readonly mountNames;
+  private readonly unsubscribe?;
+  constructor(opts: {
+    id: string;
+    files: FilesApi;
+    changes?: FileChanges;
+    mountNames?: () => Record<string, string>;
+  });
+  get state(): PanelState;
+  /** Lists `path`; a newer navigation wins over a slower older one. */
+  navigate(path: string): Promise<void>;
+  up(): Promise<void>;
+  refresh(): Promise<void>;
+  setSort(field: FilesListModel["sortField"]): void;
+  breadcrumb(): Crumb[];
+  siblings(crumb: Crumb): Promise<{
+    name: string;
+    path: string;
+  }[]>;
+  dispose(): void;
+}
+//#endregion
+//# sourceMappingURL=panel-model.d.ts.map

package/dist/panel-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"panel-model.d.ts","names":[],"sources":["../src/panel-model.ts"],"mappings":";;;;;;iBAWiB;EACf;EACA;EACA;IAAQ,OAAO;IAA6B;;;qBAOjC,mBAAmB;WACrB;WACA,MAAI;EACb,UAAU;EACV;UACQ;;UAEA;mBACS;mBACA;mBACA;EAEjB,YAAY;IACV;IACA,OAAO;IACP,UAAU;IACV,mBAAmB;;MAWjB,SAAS;;EASP,SAAS,eAAe;EA2B9B,MAAM;EAIN,WAAW;EAIX,QAAQ,OAAO;EAKf,cAAc;EAId,SAAS,OAAO,QAAK;;;;EAIrB"}

package/dist/panel-model.js

@@ -0,0 +1,88 @@
+import { breadcrumb, siblings } from "./paths.js";
+import { basename, dirname, normalizePath } from "@statewalker/webrun-files";
+import { problemOf } from "@statewalker/file-mounts.core";
+import { FilesListModel } from "@statewalker/explorer.core";
+import { BaseClass } from "@statewalker/shared-baseclass";
+//#region src/panel-model.ts
+/** A change at `changed` is visible in `folder`: inside it, the folder itself, or an ancestor. */
+const touches = (changed, folder) => dirname(changed) === folder || changed === folder || folder.startsWith(`${changed}/`);
+var PanelModel = class extends BaseClass {
+	id;
+	list = new FilesListModel();
+	problem;
+	notice;
+	loads = 0;
+	/** The folder most recently asked for; `list.path` only changes when a load completes. */
+	target = "/";
+	files;
+	mountNames;
+	unsubscribe;
+	constructor(opts) {
+		super();
+		this.id = opts.id;
+		this.files = opts.files;
+		this.mountNames = opts.mountNames ?? (() => ({}));
+		this.unsubscribe = opts.changes?.subscribe((changes) => {
+			if (changes.some((c) => touches(c.path, this.target))) this.refresh();
+		});
+	}
+	get state() {
+		return {
+			id: this.id,
+			path: this.list.path,
+			sort: {
+				field: this.list.sortField,
+				descending: !this.list.sortAscending
+			}
+		};
+	}
+	/** Lists `path`; a newer navigation wins over a slower older one. */
+	async navigate(path) {
+		const load = ++this.loads;
+		const wanted = normalizePath(path);
+		this.target = wanted;
+		let notice;
+		let problem;
+		let at = wanted;
+		let entries;
+		try {
+			while (at !== "/" && (await this.files.stats(at))?.kind !== "directory") at = dirname(at);
+			if (at !== wanted) notice = `${basename(wanted)} no longer exists.`;
+			const listed = [];
+			for await (const entry of this.files.list(at)) listed.push(entry);
+			entries = listed;
+		} catch (error) {
+			problem = problemOf(error);
+		}
+		if (load !== this.loads) return;
+		this.target = at;
+		this.list.startLoading({ path: at })(problem ? { error: problem.message } : { entries });
+		this.problem = problem;
+		this.notice = notice;
+		this.notify();
+	}
+	up() {
+		return this.navigate(dirname(this.target));
+	}
+	refresh() {
+		return this.navigate(this.target);
+	}
+	setSort(field) {
+		this.list.setSort(field);
+		this.notify();
+	}
+	breadcrumb() {
+		return breadcrumb(this.list.path, this.mountNames());
+	}
+	siblings(crumb) {
+		return siblings(this.files, crumb);
+	}
+	dispose() {
+		this.loads++;
+		this.unsubscribe?.();
+	}
+};
+//#endregion
+export { PanelModel };
+
+//# sourceMappingURL=panel-model.js.map

package/dist/panel-model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"panel-model.js","names":[],"sources":["../src/panel-model.ts"],"sourcesContent":["// One file panel: a folder of the mounted storages listed into explorer.core's\n// FilesListModel (entries, sort, filter, cursor, selection), plus what a\n// multi-panel manager needs: the breadcrumb, the reason a folder can't be read,\n// and refreshes from the change stream.\nimport { FilesListModel } from \"@statewalker/explorer.core\";\nimport { type FileChanges, type Problem, problemOf } from \"@statewalker/file-mounts.core\";\nimport { BaseClass } from \"@statewalker/shared-baseclass\";\nimport type { FileInfo, FilesApi } from \"@statewalker/webrun-files\";\nimport { basename, dirname, normalizePath } from \"@statewalker/webrun-files\";\nimport { breadcrumb, type Crumb, siblings } from \"./paths.js\";\n\nexport interface PanelState {\n  id: string;\n  path: string;\n  sort: { field: FilesListModel[\"sortField\"]; descending: boolean };\n}\n\n/** A change at `changed` is visible in `folder`: inside it, the folder itself, or an ancestor. */\nconst touches = (changed: string, folder: string) =>\n  dirname(changed) === folder || changed === folder || folder.startsWith(`${changed}/`);\n\nexport class PanelModel extends BaseClass {\n  readonly id: string;\n  readonly list = new FilesListModel();\n  problem?: Problem;\n  notice?: string;\n  private loads = 0;\n  /** The folder most recently asked for; `list.path` only changes when a load completes. */\n  private target = \"/\";\n  private readonly files: FilesApi;\n  private readonly mountNames: () => Record<string, string>;\n  private readonly unsubscribe?: () => void;\n\n  constructor(opts: {\n    id: string;\n    files: FilesApi;\n    changes?: FileChanges;\n    mountNames?: () => Record<string, string>;\n  }) {\n    super();\n    this.id = opts.id;\n    this.files = opts.files;\n    this.mountNames = opts.mountNames ?? (() => ({}));\n    this.unsubscribe = opts.changes?.subscribe((changes) => {\n      if (changes.some((c) => touches(c.path, this.target))) void this.refresh();\n    });\n  }\n\n  get state(): PanelState {\n    return {\n      id: this.id,\n      path: this.list.path,\n      sort: { field: this.list.sortField, descending: !this.list.sortAscending },\n    };\n  }\n\n  /** Lists `path`; a newer navigation wins over a slower older one. */\n  async navigate(path: string): Promise<void> {\n    const load = ++this.loads;\n    const wanted = normalizePath(path);\n    this.target = wanted;\n    let notice: string | undefined;\n    let problem: Problem | undefined;\n    let at = wanted;\n    let entries: FileInfo[] | undefined;\n    try {\n      // A folder that is gone sends the panel to its nearest existing ancestor.\n      while (at !== \"/\" && (await this.files.stats(at))?.kind !== \"directory\") at = dirname(at);\n      if (at !== wanted) notice = `${basename(wanted)} no longer exists.`;\n      const listed: FileInfo[] = [];\n      for await (const entry of this.files.list(at)) listed.push(entry);\n      entries = listed;\n    } catch (error) {\n      problem = problemOf(error);\n    }\n    if (load !== this.loads) return;\n    this.target = at; // after a fallback, the folder shown is the one to refresh and go up from\n    const done = this.list.startLoading({ path: at });\n    done(problem ? { error: problem.message } : { entries });\n    this.problem = problem;\n    this.notice = notice;\n    this.notify();\n  }\n\n  up(): Promise<void> {\n    return this.navigate(dirname(this.target));\n  }\n\n  refresh(): Promise<void> {\n    return this.navigate(this.target);\n  }\n\n  setSort(field: FilesListModel[\"sortField\"]) {\n    this.list.setSort(field);\n    this.notify();\n  }\n\n  breadcrumb(): Crumb[] {\n    return breadcrumb(this.list.path, this.mountNames());\n  }\n\n  siblings(crumb: Crumb) {\n    return siblings(this.files, crumb);\n  }\n\n  dispose() {\n    this.loads++; // an in-flight navigation is ignored from now on\n    this.unsubscribe?.();\n  }\n}\n"],"mappings":";;;;;;;AAkBA,MAAM,WAAW,SAAiB,WAChC,QAAQ,OAAO,MAAM,UAAU,YAAY,UAAU,OAAO,WAAW,GAAG,QAAQ,EAAE;AAEtF,IAAa,aAAb,cAAgC,UAAU;CACxC;CACA,OAAgB,IAAI,eAAe;CACnC;CACA;CACA,QAAgB;;CAEhB,SAAiB;CACjB;CACA;CACA;CAEA,YAAY,MAKT;EACD,MAAM;EACN,KAAK,KAAK,KAAK;EACf,KAAK,QAAQ,KAAK;EAClB,KAAK,aAAa,KAAK,sBAAsB,CAAC;EAC9C,KAAK,cAAc,KAAK,SAAS,WAAW,YAAY;GACtD,IAAI,QAAQ,MAAM,MAAM,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC,GAAG,KAAU,QAAQ;EAC3E,CAAC;CACH;CAEA,IAAI,QAAoB;EACtB,OAAO;GACL,IAAI,KAAK;GACT,MAAM,KAAK,KAAK;GAChB,MAAM;IAAE,OAAO,KAAK,KAAK;IAAW,YAAY,CAAC,KAAK,KAAK;GAAc;EAC3E;CACF;;CAGA,MAAM,SAAS,MAA6B;EAC1C,MAAM,OAAO,EAAE,KAAK;EACpB,MAAM,SAAS,cAAc,IAAI;EACjC,KAAK,SAAS;EACd,IAAI;EACJ,IAAI;EACJ,IAAI,KAAK;EACT,IAAI;EACJ,IAAI;GAEF,OAAO,OAAO,QAAQ,MAAM,KAAK,MAAM,MAAM,EAAE,EAAA,EAAI,SAAS,aAAa,KAAK,QAAQ,EAAE;GACxF,IAAI,OAAO,QAAQ,SAAS,GAAG,SAAS,MAAM,EAAE;GAChD,MAAM,SAAqB,CAAC;GAC5B,WAAW,MAAM,SAAS,KAAK,MAAM,KAAK,EAAE,GAAG,OAAO,KAAK,KAAK;GAChE,UAAU;EACZ,SAAS,OAAO;GACd,UAAU,UAAU,KAAK;EAC3B;EACA,IAAI,SAAS,KAAK,OAAO;EACzB,KAAK,SAAS;EAEd,KADkB,KAAK,aAAa,EAAE,MAAM,GAAG,CAC5C,CAAC,CAAC,UAAU,EAAE,OAAO,QAAQ,QAAQ,IAAI,EAAE,QAAQ,CAAC;EACvD,KAAK,UAAU;EACf,KAAK,SAAS;EACd,KAAK,OAAO;CACd;CAEA,KAAoB;EAClB,OAAO,KAAK,SAAS,QAAQ,KAAK,MAAM,CAAC;CAC3C;CAEA,UAAyB;EACvB,OAAO,KAAK,SAAS,KAAK,MAAM;CAClC;CAEA,QAAQ,OAAoC;EAC1C,KAAK,KAAK,QAAQ,KAAK;EACvB,KAAK,OAAO;CACd;CAEA,aAAsB;EACpB,OAAO,WAAW,KAAK,KAAK,MAAM,KAAK,WAAW,CAAC;CACrD;CAEA,SAAS,OAAc;EACrB,OAAO,SAAS,KAAK,OAAO,KAAK;CACnC;CAEA,UAAU;EACR,KAAK;EACL,KAAK,cAAc;CACrB;AACF"}

package/dist/paths.d.ts

@@ -0,0 +1,15 @@
+import { FilesApi } from "@statewalker/webrun-files";
+//#region src/paths.d.ts
+export interface Crumb {
+  name: string;
+  path: string;
+  isMount: boolean;
+}
+export declare function breadcrumb(path: string, mountNames: Record<string, string>): Crumb[];
+/** The folders beside a crumb: the ▾ menu. Beside a mount are the other mounts. */
+export declare function siblings(files: FilesApi, crumb: Crumb): Promise<{
+  name: string;
+  path: string;
+}[]>;
+//#endregion
+//# sourceMappingURL=paths.d.ts.map

package/dist/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","names":[],"sources":["../src/paths.ts"],"mappings":";;iBAGiB;EACf;EACA;EACA;;wBAGc,WAAW,cAAc,YAAY,yBAAyB;;wBAYxD,SACpB,OAAO,UACP,OAAO,QACN;EAAU;EAAc"}