@parallelworks/ui 0.18.0 → 0.19.1

package/dist/file-explorer/lib/batch.js

@@ -0,0 +1,39 @@
+//#region src/file-explorer/lib/batch.ts
+async function* paginate(fetchPage, nextCursor) {
+	const seen = /* @__PURE__ */ new Set();
+	let cursor;
+	while (true) {
+		const page = await fetchPage(cursor);
+		yield page;
+		cursor = nextCursor(page);
+		if (!cursor || seen.has(cursor)) return;
+		seen.add(cursor);
+	}
+}
+function chunk(items, size) {
+	const chunks = [];
+	for (let i = 0; i < items.length; i += size) chunks.push(items.slice(i, i + size));
+	return chunks;
+}
+async function mapWithConcurrency(items, limit, worker) {
+	const results = new Array(items.length);
+	const queue = items.entries();
+	const run = async () => {
+		for (const [index, item] of queue) try {
+			results[index] = {
+				status: "fulfilled",
+				value: await worker(item)
+			};
+		} catch (reason) {
+			results[index] = {
+				status: "rejected",
+				reason
+			};
+		}
+	};
+	const workers = Array.from({ length: Math.min(limit, items.length) }, () => run());
+	await Promise.all(workers);
+	return results;
+}
+//#endregion
+export { chunk, mapWithConcurrency, paginate };

package/dist/file-explorer/lib/errors.js

@@ -0,0 +1,9 @@
+//#region src/file-explorer/lib/errors.ts
+var CorsError = class extends Error {
+	constructor(message) {
+		super(message || "CORS issue detected.");
+		this.name = "CorsError";
+	}
+};
+//#endregion
+export { CorsError };

package/dist/file-explorer/lib/paging.js

@@ -0,0 +1,124 @@
+import { ensureTrailingSlash, getNodeName } from "./utils.js";
+//#region src/file-explorer/lib/paging.ts
+/** Both providers already cap an unqualified list at 1,000, so stating it leaves
+*  single-page directories byte-identical. */
+var LIST_PAGE_SIZE = 1e3;
+function isListed(listings, path) {
+	return (listings.get(path)?.pagesLoaded ?? 0) > 0;
+}
+/** True even while a request is in flight, so the sentinel stays put. */
+function hasMore(listings, path) {
+	return !!listings.get(path)?.cursor;
+}
+/** A failed page needs an explicit retry, so it stops auto-loading here. */
+function canLoadMore(listings, path) {
+	const listing = listings.get(path);
+	return !!listing?.cursor && !listing.loadingMore && !listing.error;
+}
+/** Auto-load stops at the cap; past it the user asks for each page. */
+function canAutoLoadMore(listings, path) {
+	return canLoadMore(listings, path) && (listings.get(path)?.pagesLoaded ?? 0) < 5;
+}
+function isLoadingMore(listings, path) {
+	return listings.get(path)?.loadingMore === true;
+}
+function loadMoreError(listings, path) {
+	return listings.get(path)?.error;
+}
+function beginLoadingMore(listings, path) {
+	const listing = listings.get(path);
+	if (!listing) return listings;
+	return new Map(listings).set(path, {
+		...listing,
+		loadingMore: true,
+		error: void 0
+	});
+}
+function advanceListing(listings, path, page) {
+	const listing = listings.get(path);
+	return new Map(listings).set(path, {
+		cursor: page.cursor,
+		pagesLoaded: (listing?.pagesLoaded ?? 0) + 1,
+		loadingMore: false,
+		entries: [...listing?.entries ?? [], ...page.entries]
+	});
+}
+/** Subfolders the page no longer names lose their records, or a re-created folder
+*  would show old contents; the rest keep theirs, since a refresh lists them
+*  alongside this one and a parent landing later must not undo a child's page. */
+function replaceListing(listings, path, page) {
+	const prefix = ensureTrailingSlash(path);
+	const subfolders = new Set(page.entries.filter((entry) => entry.type === "directory").map(getNodeName));
+	const next = new Map(listings);
+	next.delete(path);
+	for (const key of listings.keys()) {
+		if (!key.startsWith(prefix)) continue;
+		if (!subfolders.has(key.slice(prefix.length).split("/")[0] ?? "")) next.delete(key);
+	}
+	return advanceListing(next, path, page);
+}
+/** `pagesLoaded` stays put, so a failed first page still reads as unlisted. */
+function recordListingError(listings, path, error) {
+	const listing = listings.get(path);
+	return new Map(listings).set(path, {
+		cursor: listing?.cursor,
+		pagesLoaded: listing?.pagesLoaded ?? 0,
+		loadingMore: false,
+		error,
+		entries: listing?.entries ?? []
+	});
+}
+/** Keeps the cursor and pages, so a retry resumes paging instead of starting over. */
+function clearListingError(listings, path) {
+	const listing = listings.get(path);
+	if (!listing) return listings;
+	return new Map(listings).set(path, {
+		...listing,
+		error: void 0
+	});
+}
+function clearListingsUnder(listings, path) {
+	const prefix = ensureTrailingSlash(path);
+	const next = new Map(listings);
+	for (const key of listings.keys()) if (key === path || key.startsWith(prefix)) next.delete(key);
+	return next;
+}
+/** Tree paths whose children should keep arrival order, since sorting them would
+*  reshuffle rows under the user mid-scroll. */
+function incompletePaths(listings) {
+	const paths = /* @__PURE__ */ new Set();
+	for (const [path, listing] of listings) if (listing.cursor) paths.add(path);
+	return paths;
+}
+/** What a deep link needs next. Pure so the walk is table-testable. */
+function nextHydrationStep({ targetResolved, ancestors, isListableDir, listings, inFlight, pagesPulled }) {
+	for (const path of ancestors) {
+		if (!isListableDir(path)) continue;
+		if (inFlight.has(path)) return { kind: "done" };
+		if (!listings.has(path)) return {
+			kind: "fetch",
+			path
+		};
+	}
+	if (targetResolved) return { kind: "done" };
+	const deepest = [...ancestors].reverse().find(isListableDir);
+	if (!deepest) return { kind: "done" };
+	if (!hasMore(listings, deepest)) return {
+		kind: "stuck",
+		path: deepest
+	};
+	if (loadMoreError(listings, deepest)) return {
+		kind: "stuck",
+		path: deepest
+	};
+	if (pagesPulled >= 20) return {
+		kind: "stuck",
+		path: deepest
+	};
+	return isLoadingMore(listings, deepest) ? { kind: "done" } : {
+		kind: "more",
+		path: deepest
+	};
+}
+//#endregion
+export { LIST_PAGE_SIZE, advanceListing, beginLoadingMore, canAutoLoadMore, clearListingError, clearListingsUnder, hasMore, incompletePaths, isListed, isLoadingMore, loadMoreError, nextHydrationStep, recordListingError, replaceListing };

package/dist/file-explorer/lib/types.d.ts

@@ -15,8 +15,13 @@ export type TStorage = {
     canUpload?: boolean | undefined;
     canShare?: boolean | undefined;
     canManageAccess?: boolean | undefined;
-    supportsPwUri?: boolean | undefined;
 };
+/** A file the host is asked to name or download: its storage, key and name. */
+export interface ExplorerObject {
+    storage: TStorage;
+    key: string;
+    name: string;
+}
 export type TStorageObject = {
     path: string;
     type: 'file' | 'directory';

package/dist/file-explorer/lib/utils.d.ts

@@ -1,5 +1,5 @@
 import type { IFileExplorerClient } from './fileExplorer.js';
-import type { TStorage, TStorageObject, TreeMap, TreeNode, UploadNode } from './types.js';
+import type { TreeMap, TreeNode, TStorage, TStorageObject, UploadNode } from './types.js';
 export declare function formatFileSize(bytes: number): string;
 export declare function getFileExtension(filename: string): string | null;
 export declare function getNodeName(node: TStorageObject): string;
@@ -33,8 +33,6 @@ export declare function attachmentDisposition(filename: string): string;
 export declare function getDirectoryPrefixFromNode(node: TreeNode): string;
 export declare function pruneNodesInsideSelectedDirectories(nodes: TreeNode[]): TreeNode[];
 export declare function collectObjectKeysToDelete(nodes: TreeNode[], listKeysUnderPrefix: (prefix: string) => Promise<string[]>): Promise<string[]>;
-export declare function getPwUri(username: string, pwName: string, key: string): string;
-export declare function getCspUri(csp: string, cspBucketName: string, key: string): string | null;
 export declare function getUriScheme(uri: string): string;
 export declare function removeLeadingSlash(path: string): string;
 export declare function removeLeadingAndTrailingSlashes(path: string): string;

package/dist/file-explorer/lib/utils.js

@@ -0,0 +1,322 @@
+//#region src/file-explorer/lib/utils.ts
+function formatFileSize(bytes) {
+	if (bytes === 0) return "0 B";
+	const k = 1024;
+	const sizes = [
+		"B",
+		"KB",
+		"MB",
+		"GB",
+		"TB"
+	];
+	const i = Math.floor(Math.log(bytes) / Math.log(k));
+	return Number.parseFloat((bytes / k ** i).toFixed(2)) + " " + sizes[i];
+}
+function getFileExtension(filename) {
+	return filename.match(/\.([a-zA-Z0-9]+)$/)?.[1]?.toLowerCase() ?? null;
+}
+function getNodeName(node) {
+	const parts = removeTrailingSlash(node.path || "").split("/");
+	return parts[parts.length - 1] ?? "";
+}
+function toNode(entry, storage, storagePath, storageName) {
+	const relativePath = removeLeadingSlash(entry.path);
+	const isDirectory = entry.type === "directory";
+	return {
+		name: getNodeName(entry),
+		path: isDirectory ? ensureTrailingSlash(`${storagePath}${removeTrailingSlash(relativePath)}`) : `${storagePath}${relativePath}`,
+		relativePath: entry.key || (isDirectory ? entry.path : relativePath),
+		type: entry.type,
+		size: entry.size,
+		created: entry.created,
+		modified: entry.modified,
+		contentType: entry.contentType,
+		hash: entry.hash,
+		storageClass: entry.storageClass,
+		storageId: storage.id,
+		storageName
+	};
+}
+function compareNodes(a, b) {
+	if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
+	return (a.displayName || a.name).localeCompare(b.displayName || b.name);
+}
+function extendsEntries(next, previous) {
+	return next.length >= previous.length && previous.every((entry, i) => next[i] === entry);
+}
+function childrenOf(dir, sorted) {
+	if (sorted) {
+		dir.sorted ??= [...dir.directories, ...dir.files].sort(compareNodes);
+		return dir.sorted;
+	}
+	dir.unsorted ??= [...dir.directories, ...dir.files];
+	return dir.unsorted;
+}
+/** One accumulator per listed directory, so a landed page costs the page and not
+*  the tree. One builder per explorer instance. */
+function createTreeBuilder() {
+	const directories = /* @__PURE__ */ new Map();
+	let last = null;
+	function unchanged(storages, options) {
+		if (!last || last.storages !== storages || last.options.forceUserHierarchy !== options.forceUserHierarchy || last.options.unsortedParents !== options.unsortedParents) return false;
+		const before = last.options.listings;
+		if (options.listings.size !== before.size) return false;
+		for (const [dirPath, listing] of options.listings) if (before.get(dirPath)?.entries !== listing.entries) return false;
+		return true;
+	}
+	function nodesFor(dirPath, storage, storagePath, storageName, entries) {
+		const cached = directories.get(dirPath);
+		const reusable = cached?.storageName === storageName ? cached : void 0;
+		if (reusable && reusable.entries === entries) return reusable;
+		let dir;
+		if (reusable && extendsEntries(entries, reusable.entries)) dir = reusable;
+		else {
+			dir = {
+				entries: [],
+				storageName,
+				directories: [],
+				files: []
+			};
+			directories.set(dirPath, dir);
+		}
+		for (let i = dir.entries.length; i < entries.length; i++) {
+			const node = toNode(entries[i], storage, storagePath, storageName);
+			if (node.path === dirPath) continue;
+			if (node.type === "directory") dir.directories.push(node);
+			else dir.files.push(node);
+		}
+		dir.entries = entries;
+		dir.unsorted = void 0;
+		dir.sorted = void 0;
+		return dir;
+	}
+	function addStorage(storage, storagePath, options, tree) {
+		const storageName = storage.bucketName || storage.name;
+		const root = {
+			name: storage.name,
+			displayName: storage.displayName,
+			path: storagePath,
+			relativePath: "",
+			type: "directory",
+			created: storage.created,
+			modified: storage.modified,
+			storageId: storage.id,
+			storageName,
+			storageNodeIcon: storage.type,
+			storageImageUrl: storage.imageUrl,
+			storageType: storage.type,
+			root: true
+		};
+		tree.treeMap[storagePath] = root;
+		for (const [dirPath, listing] of options.listings) {
+			if (!dirPath.startsWith(storagePath)) continue;
+			const children = childrenOf(nodesFor(dirPath, storage, storagePath, storageName, listing.entries), !options.unsortedParents?.has(dirPath));
+			if (children.length === 0) continue;
+			for (const node of children) tree.treeMap[node.path] = node;
+			tree.parentToChildrenMap[dirPath] = children;
+		}
+		return root;
+	}
+	return (storages, options) => {
+		if (last && unchanged(storages, options)) return last.tree;
+		const tree = {
+			treeMap: {},
+			parentToChildrenMap: {},
+			rootNodes: []
+		};
+		if (storages.length === 1 && !options.forceUserHierarchy) {
+			const storage = storages[0];
+			const storagePath = ensureTrailingSlash(storage.user ? `${storage.user}/${storage.name}` : storage.name);
+			tree.rootNodes.push(addStorage(storage, storagePath, options, tree));
+		} else {
+			const userGroups = {};
+			for (const storage of storages) {
+				const username = storage.user ?? "";
+				if (!userGroups[username]) userGroups[username] = [];
+				userGroups[username].push(storage);
+			}
+			for (const username of Object.keys(userGroups)) {
+				const userPath = ensureTrailingSlash(username);
+				const userNode = {
+					name: username,
+					path: userPath,
+					type: "directory",
+					displayName: username
+				};
+				tree.treeMap[userPath] = userNode;
+				tree.rootNodes.push(userNode);
+				const storageRoots = (userGroups[username] ?? []).map((storage) => addStorage(storage, ensureTrailingSlash(`${userPath}${removeLeadingAndTrailingSlashes(storage.name)}`), options, tree));
+				tree.parentToChildrenMap[userPath] = storageRoots.sort(compareNodes);
+			}
+		}
+		for (const dirPath of directories.keys()) if (!options.listings.has(dirPath)) directories.delete(dirPath);
+		last = {
+			storages,
+			options,
+			tree
+		};
+		return tree;
+	};
+}
+function getNodeChildren(parentToChildrenMap, parentPath) {
+	return parentToChildrenMap[parentPath.endsWith("/") ? parentPath : parentPath + "/"] || [];
+}
+function getParentPath(currentPath) {
+	return ensureTrailingSlash(removeLastPathSegment(currentPath));
+}
+function getDirectoryNameError(name, siblings) {
+	if (name === "." || name === "..") return "reserved";
+	if (name.includes("/") || name.includes("\\")) return "separator";
+	if (siblings.some((node) => node.name === name)) return "exists";
+	return null;
+}
+function getDirectoryObjectPath(parentNode, directoryName) {
+	const parentPath = parentNode.root ? "" : removeLeadingAndTrailingSlashes(parentNode.relativePath ?? "");
+	return parentPath ? `${parentPath}/${directoryName}/` : `${directoryName}/`;
+}
+async function getUploadNodesFromDataTransferItems(items) {
+	const uploadNodes = [];
+	let totalSize = 0;
+	async function traverse(entry, path = "") {
+		return new Promise((resolve, reject) => {
+			if (entry.isFile) entry.file((file) => {
+				uploadNodes.push({
+					name: file.name,
+					file,
+					relativePath: path ? path + file.name : file.name
+				});
+				totalSize += file.size;
+				resolve();
+			}, reject);
+			else if (entry.isDirectory) entry.createReader().readEntries(async (entries) => {
+				const newPath = path ? path + entry.name + "/" : entry.name + "/";
+				if (entries.length === 0) uploadNodes.push({
+					name: entry.name,
+					file: new Blob(),
+					relativePath: newPath
+				});
+				else for (const entry of entries) await traverse(entry, newPath);
+				resolve();
+			}, reject);
+			else resolve();
+		});
+	}
+	const entries = [];
+	for (let i = 0; i < items.length; i++) {
+		const entry = items[i]?.webkitGetAsEntry?.();
+		if (entry) entries.push(entry);
+	}
+	for (const entry of entries) await traverse(entry);
+	return {
+		uploadNodes,
+		totalSize
+	};
+}
+function calculateUploadNodesTotalSize(uploadNodes) {
+	return uploadNodes.reduce((total, node) => {
+		return total + (node.file?.size || 0);
+	}, 0);
+}
+function getObjectKeyFromNode(node) {
+	return node.relativePath || node.path.split("/").filter(Boolean).slice(1).join("/");
+}
+function attachmentDisposition(filename) {
+	return `attachment; filename="${filename.replace(/[^\x20-\x7e]|["\\]/g, "_")}"; filename*=UTF-8''${encodeURIComponent(filename).replace(/['()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`)}`;
+}
+function getDirectoryPrefixFromNode(node) {
+	const key = getObjectKeyFromNode(node);
+	if (!key) throw new Error(`Cannot resolve an object prefix for ${node.path}`);
+	return ensureTrailingSlash(key);
+}
+function pruneNodesInsideSelectedDirectories(nodes) {
+	const directoryPaths = nodes.filter((node) => node.type === "directory").map((node) => ensureTrailingSlash(node.path));
+	return nodes.filter((node) => !directoryPaths.some((directoryPath) => node.path !== directoryPath && node.path.startsWith(directoryPath)));
+}
+async function collectObjectKeysToDelete(nodes, listKeysUnderPrefix) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const node of nodes) {
+		if (node.type !== "directory") {
+			keys.add(getObjectKeyFromNode(node));
+			continue;
+		}
+		const prefix = getDirectoryPrefixFromNode(node);
+		const found = await listKeysUnderPrefix(prefix);
+		for (const key of found.filter((key) => key.startsWith(prefix))) keys.add(key);
+	}
+	return Array.from(keys);
+}
+function getUriScheme(uri) {
+	return uri.match(/^([a-z0-9+.-]+):\/\//i)?.[1] ?? "";
+}
+function removeLeadingSlash(path) {
+	return path.replace(/^\/+/, "");
+}
+function removeTrailingSlash(path) {
+	return path.replace(/\/$/, "");
+}
+function removeLeadingAndTrailingSlashes(path) {
+	return path.replace(/^\/+|\/+$/g, "");
+}
+function removeLastPathSegment(path) {
+	return path.replace(/\/[^/]+\/?$/, "");
+}
+function ensureTrailingSlash(path) {
+	return path.endsWith("/") ? path : path + "/";
+}
+function isClientValid(client) {
+	if (!client?.getExpiresAt) return false;
+	const expiresAt = client.getExpiresAt();
+	return expiresAt && expiresAt > /* @__PURE__ */ new Date();
+}
+function getUploadSessionETA(totalLoadedBytes, totalSizeBytes, lastProgressTime, lastProgressBytes) {
+	const now = Date.now();
+	const MAX_ETA_SECONDS = 86400;
+	if (!lastProgressTime || !lastProgressBytes) return {
+		lastProgressTime: now,
+		lastProgressBytes: totalLoadedBytes,
+		shouldUpdateETA: false
+	};
+	const timeDiff = now - lastProgressTime;
+	const bytesDiff = totalLoadedBytes - lastProgressBytes;
+	if (timeDiff < 1e3) return {
+		lastProgressTime,
+		lastProgressBytes,
+		shouldUpdateETA: false
+	};
+	if (bytesDiff > 0 && timeDiff > 0) {
+		const bytesPerSecond = bytesDiff / timeDiff * 1e3;
+		const remainingBytes = totalSizeBytes - totalLoadedBytes;
+		if (remainingBytes <= 0) return {
+			estimatedSecondsLeft: 0,
+			lastProgressTime: now,
+			lastProgressBytes: totalLoadedBytes,
+			shouldUpdateETA: true
+		};
+		let eta = Math.ceil(remainingBytes / bytesPerSecond);
+		eta = Math.max(1, Math.min(eta, MAX_ETA_SECONDS));
+		return {
+			estimatedSecondsLeft: eta,
+			lastProgressTime: now,
+			lastProgressBytes: totalLoadedBytes,
+			shouldUpdateETA: true
+		};
+	}
+	return {
+		lastProgressTime,
+		lastProgressBytes,
+		shouldUpdateETA: false
+	};
+}
+function formatETA(seconds) {
+	if (seconds <= 0) return "Almost done";
+	if (seconds < 5) return "Few seconds";
+	if (seconds < 60) return `~ ${seconds}s`;
+	if (seconds < 3600) {
+		const mins = Math.floor(seconds / 60);
+		const secs = seconds % 60;
+		return secs > 0 ? `~ ${mins}m ${secs}s` : `~ ${mins}m`;
+	}
+	return `~ ${Math.floor(seconds / 3600)}h ${Math.ceil(seconds % 3600 / 60)}m`;
+}
+//#endregion
+export { attachmentDisposition, calculateUploadNodesTotalSize, collectObjectKeysToDelete, createTreeBuilder, ensureTrailingSlash, formatETA, formatFileSize, getDirectoryNameError, getDirectoryObjectPath, getDirectoryPrefixFromNode, getFileExtension, getNodeChildren, getNodeName, getObjectKeyFromNode, getParentPath, getUploadNodesFromDataTransferItems, getUploadSessionETA, getUriScheme, isClientValid, pruneNodesInsideSelectedDirectories, removeLeadingAndTrailingSlashes, removeLeadingSlash };