@powerhousedao/powerhouse-vetra-packages 6.2.2-dev.83 → 6.2.2-dev.85

package/dist/browser/{dist-Bw_lDsJV.js → dist-C1pi89al.js}

@@ -1,7 +1,7 @@
-import { A as __toESM, D as __commonJSMin, t as capitalCase } from "./dist-B4FWbuEM.js";
-import { C as baseLoadFromInputVersioned, O as createPresignedHeader, Q as setName, S as baseLoadFromInput, T as buildSignedAction, U as replayDocumentVersioned, a as handleTargetNameCollisions, ct as validateStateSchemaName, f as logger, h as UnsupportedDocumentModelVersionError, i as generateNodesCopy, j as createZip, l as moveNode, lt as generateId, n as copyNode, o as isFileNode, ot as validateInitialState, s as isFolderNode, st as validateModules, t as addFolder, u as updateNode, w as baseSaveToFileHandle, y as assertAuthPreservedOnDuplicate } from "./document-drive-BVYCdu_5.js";
+import { A as __toESM, D as __commonJSMin, r as pascalCase, t as capitalCase } from "./dist-B4FWbuEM.js";
+import { A as createPresignedHeader, D as buildSignedAction, E as baseSaveToFileHandle, G as replayDocumentVersioned, N as createZip, T as baseLoadFromInputVersioned, _ as UnsupportedDocumentModelVersionError, a as getDescendants, c as isFileNode, ct as validateInitialState, d as moveNode, dt as zipEntries, et as setName, f as updateNode, ft as generateId, i as generateNodesCopy, l as isFolderNode, lt as validateModules, m as logger, n as copyNode, o as getNextCopyNumber, s as handleTargetNameCollisions, t as addFolder, ut as validateStateSchemaName, w as baseLoadFromInput, x as assertAuthPreservedOnDuplicate } from "./document-drive-ZQzPQfEL.js";
 import { a as SyncStatus, o as DriveCollectionId, s as ModuleNotFoundError, t as gql } from "./lib-ewnRj2dJ.js";
-import "./parser-CkF6Qt8V.js";
+import { c as Kind, t as parse } from "./parser-CkF6Qt8V.js";
 import "./printer-CEYr4JOg.js";
 import { createContext, use, useCallback, useContext, useEffect, useMemo, useState, useSyncExternalStore } from "react";
 import "react/jsx-runtime";
@@ -1029,7 +1029,7 @@ slug.setLocale = function(locale) {
 	defaultLocale = locales[locale] || {};
 };
 //#endregion
-//#region ../reactor-browser/dist/document-model-modules-DMIR-uSD.js
+//#region ../reactor-browser/dist/document-model-modules-DfQBNGc-.js
 var UnsupportedDocumentTypeError = class extends Error {
 	constructor(documentType) {
 		super(`Document type ${documentType} is not supported`);
@@ -1249,10 +1249,18 @@ function useSelectedNode() {
 }
 const vetraPackageManagerFunctions = makePHEventFunctions("vetraPackageManager");
 const useVetraPackageManager = vetraPackageManagerFunctions.useValue;
-/** Returns all of the Vetra packages loaded by the Connect instance */
+const EMPTY_VETRA_PACKAGES = [];
+const noPackageManagerUnsubscribe = () => {};
+/**
+* Returns all of the Vetra packages loaded by the Connect instance.
+*
+* The snapshot and subscription must keep stable identity while no package
+* manager is registered: `useSyncExternalStore` loops when the snapshot
+* changes on every read, which a fresh `[]` does.
+*/
 const useVetraPackages = () => {
 	const packageManager = useVetraPackageManager();
-	return useSyncExternalStore((cb) => packageManager ? packageManager.subscribe(cb) : () => {}, () => packageManager?.packages ?? []);
+	return useSyncExternalStore((cb) => packageManager ? packageManager.subscribe(cb) : noPackageManagerUnsubscribe, () => packageManager?.packages ?? EMPTY_VETRA_PACKAGES);
 };
 vetraPackageManagerFunctions.addEventHandler;
 function useDocumentModelModules() {
@@ -2057,7 +2065,7 @@ var MessageType = /* @__PURE__ */ ((MessageType2) => {
 })(MessageType || {});
 Error;
 //#endregion
-//#region ../reactor-browser/dist/document-operations-BAJGXn6w.js
+//#region ../reactor-browser/dist/document-operations-CBExT76y.js
 const modalEventFunctions = makePHEventFunctions("modal");
 modalEventFunctions.useValue;
 /** Sets the current modal */
@@ -3131,7 +3139,7 @@ const usePHToast = toastEventFunctions.useValue;
 toastEventFunctions.setValue;
 toastEventFunctions.addEventHandler;
 //#endregion
-//#region ../reactor-browser/dist/selected-document-xFBNPc9Q.js
+//#region ../reactor-browser/dist/switchboard-D4-_jwk-.js
 /** Returns a document of a specific type, throws an error if the found document has a different type */
 function useDocumentOfType(documentId, documentType) {
 	const [document, dispatch] = useDocumentById(documentId);
@@ -3846,6 +3854,117 @@ var import_lz_string = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((
 		return LZString;
 	});
 })))(), 1);
+const sanitize = (segment) => segment.replace(/\//g, "-");
+/**
+* Name segments from the exported folder (exclusive) down to `node`
+* (inclusive), in top-down order. `root === undefined` means the drive root:
+* all ancestors. A node that IS the exported folder yields no segments.
+*/
+function segmentsBelow(root, node, allNodes) {
+	const segments = [];
+	let current = node;
+	while (current && current.id !== root?.id) {
+		segments.push(sanitize(current.name));
+		const parentId = current.parentFolder;
+		current = parentId ? allNodes.find((n) => n.id === parentId) : void 0;
+	}
+	return segments.reverse();
+}
+/**
+* Assemble the archive zip for a folder (or the whole drive when
+* `folderNode` is undefined). Every folder in the subtree becomes a
+* directory entry (empty folders survive); every file becomes a standard
+* single-document zip named after the node (drive naming convention:
+* `${name}.${extension}.phd`, ` (copy) N` on a same-folder collision).
+*
+* `fetchDocument` must return the document WITH its full operations and
+* initialState (see downloadFolderZip).
+*/
+async function buildFolderZip(drive, folderNode, fetchDocument, onProgress) {
+	const allNodes = drive.state.global.nodes;
+	const topName = sanitize(folderNode?.name ?? (drive.state.global.name || drive.header.name));
+	const subtree = folderNode ? [folderNode, ...getDescendants(folderNode, allNodes)] : allNodes;
+	const entries = { [topName + "/"]: new Uint8Array(0) };
+	for (const node of subtree) {
+		if (!isFolderNode(node)) continue;
+		const dir = [topName, ...segmentsBelow(folderNode, node, allNodes)].join("/");
+		entries[dir + "/"] = new Uint8Array(0);
+	}
+	const files = subtree.filter(isFileNode);
+	const failed = [];
+	const usedNamesByDir = /* @__PURE__ */ new Map();
+	let done = 0;
+	for (const node of files) try {
+		const doc = await fetchDocument(node.id);
+		const extension = await getDocumentExtension(doc);
+		const parent = node.parentFolder ? allNodes.find((n) => n.id === node.parentFolder) : void 0;
+		const dir = [topName, ...parent ? segmentsBelow(folderNode, parent, allNodes) : []].join("/");
+		let usedNames = usedNamesByDir.get(dir);
+		if (!usedNames) {
+			usedNames = /* @__PURE__ */ new Set();
+			usedNamesByDir.set(dir, usedNames);
+		}
+		const base = sanitize(node.name);
+		let candidate = base;
+		let count = getNextCopyNumber([...usedNames], base);
+		while (usedNames.has(candidate)) {
+			candidate = `${base} (copy) ${count}`;
+			count += 1;
+		}
+		usedNames.add(candidate);
+		const leaf = extension ? `${candidate}.${extension}.phd` : `${candidate}.phd`;
+		entries[`${dir}/${leaf}`] = await createZip(doc);
+	} catch {
+		failed.push(node.name);
+	} finally {
+		done += 1;
+		onProgress?.(done, files.length);
+	}
+	return {
+		zip: await zipEntries(entries),
+		archiveName: `${topName}.zip`,
+		entryCount: files.length - failed.length,
+		failed
+	};
+}
+/**
+* Export a folder (or whole drive) to disk: fetches every document with its
+* full operation history, builds the archive, and saves it via
+* showSaveFilePicker (fallback: blob download), mirroring exportFile.
+*/
+async function downloadFolderZip(drive, folderNode, onProgress) {
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	const result = await buildFolderZip(drive, folderNode, async (id) => {
+		const doc = await reactorClient.get(id);
+		const operations = await fetchDocumentOperations(reactorClient, doc);
+		const initialState = extractInitialState(operations["document"] ?? []);
+		return {
+			...doc,
+			operations,
+			initialState
+		};
+	}, onProgress);
+	if (!window.showSaveFilePicker) {
+		const blob = new Blob([new Uint8Array(result.zip)], { type: "application/zip" });
+		const link = window.document.createElement("a");
+		link.style.display = "none";
+		link.href = URL.createObjectURL(blob);
+		link.download = result.archiveName;
+		window.document.body.appendChild(link);
+		link.click();
+		window.document.body.removeChild(link);
+		return result;
+	}
+	try {
+		const writable = await (await window.showSaveFilePicker({ suggestedName: result.archiveName })).createWritable();
+		await writable.write(new Uint8Array(result.zip));
+		await writable.close();
+	} catch (e) {
+		if (!(e instanceof DOMException && e.name === "AbortError")) throw e;
+	}
+	return result;
+}
 /** Document types that represent a "drive": a container of nodes. */
 const DRIVE_DOCUMENT_TYPES = ["powerhouse/document-drive", "powerhouse/reactor-drive"];
 function useAllowedDocumentModelModules() {
@@ -4023,6 +4142,25 @@ function useDownloadDocument(id) {
 		}
 	};
 }
+/**
+* Downloads the selected drive's folder (or the whole drive when no folder
+* is given) as a single zip archive mirroring the folder tree.
+*/
+function useDownloadFolder(folderNode) {
+	const [selectedDrive] = useSelectedDriveSafe();
+	const toast = usePHToast();
+	return async () => {
+		if (!selectedDrive) return;
+		const name = folderNode?.name ?? selectedDrive.header.name;
+		toast?.(`Downloading "${name}"…`);
+		try {
+			const { entryCount, failed } = await downloadFolderZip(selectedDrive, folderNode);
+			toast?.(failed.length ? `Downloaded ${entryCount} files (${failed.length} failed)` : `Downloaded ${entryCount} files`);
+		} catch (error) {
+			toast?.(`Failed to download "${name}": ${error.message}`);
+		}
+	};
+}
 /** An editor is a drive "app" if it targets any supported drive document type. */
 function isDriveEditor(module) {
 	const driveTypes = DRIVE_DOCUMENT_TYPES;
@@ -4245,8 +4383,134 @@ function getDocumentGraphqlQuery() {
 	if (!loc) throw new Error("GetDocumentWithOperationsDocument is misconfigured, loc is missing.");
 	return loc.source.body;
 }
-function buildDocumentSubgraphQuery(identifier, authToken) {
-	const query = getDocumentGraphqlQuery();
+/**
+* The base URL of the switchboard that serves a drive's GraphQL channel.
+*
+* The channel URL is `<origin>[<proxy-prefix>]/graphql/r`, so stripping the
+* suffix preserves any proxy prefix (e.g. `/api/reactor`). A URL that does
+* not end with the suffix is unexpected — fall back to its origin.
+*/
+function getSwitchboardBaseFromChannelUrl(channelUrl) {
+	if (channelUrl.endsWith("/graphql/r")) return channelUrl.slice(0, -10);
+	return new URL(channelUrl).origin;
+}
+/**
+* The GraphQL name the switchboard exposes a document model under. Mirrors
+* `getDocumentModelSchemaName` on the server (`create-schema.ts`): the root
+* query field and the state type names are all derived from the model's
+* `global.name`.
+*/
+function getDocumentModelSchemaName(model) {
+	return pascalCase(model.documentModel.global.name.replaceAll("/", " "));
+}
+function buildStateTypeMap(definitions) {
+	const typeMap = /* @__PURE__ */ new Map();
+	for (const def of definitions) if (def.kind === Kind.OBJECT_TYPE_DEFINITION) typeMap.set(def.name.value, def);
+	return typeMap;
+}
+/**
+* Recursively expands the fields of a state object type into a GraphQL
+* selection. Objects expand their sub-selection (lists expand their item
+* type); enums, scalars, and built-ins are leaves.
+*/
+function expandStateFields(typeDef, typeMap) {
+	return (typeDef.fields ?? []).map((field) => {
+		const fieldName = field.name.value;
+		let typeNode = field.type;
+		if (typeNode.kind === Kind.NON_NULL_TYPE) typeNode = typeNode.type;
+		if (typeNode.kind === Kind.LIST_TYPE) {
+			let itemType = typeNode.type;
+			if (itemType.kind === Kind.NON_NULL_TYPE) itemType = itemType.type;
+			if (itemType.kind === Kind.LIST_TYPE) throw new Error(`Nested lists are not supported in state selections: ${fieldName}`);
+			if (itemType.kind !== Kind.NAMED_TYPE) return fieldName;
+			const itemTypeDef = typeMap.get(itemType.name.value);
+			if (!itemTypeDef) return fieldName;
+			return `${fieldName} { ${expandStateFields(itemTypeDef, typeMap)} }`;
+		}
+		if (typeNode.kind !== Kind.NAMED_TYPE) return fieldName;
+		const typeDef = typeMap.get(typeNode.name.value);
+		if (!typeDef) return fieldName;
+		return `${fieldName} { ${expandStateFields(typeDef, typeMap)} }`;
+	}).join(" ");
+}
+/**
+* Finds the root state object type in a state SDL. Root state types follow
+* the `<Name>State` / `<Name>GlobalState` conventions, and are defined last
+* by convention — the same resolution order the server uses
+* (`extractRootTypeName` in `create-schema.ts`).
+*/
+function findRootStateType(definitions, candidates) {
+	let lastObjectType = null;
+	for (const def of definitions) {
+		if (def.kind !== Kind.OBJECT_TYPE_DEFINITION) continue;
+		if (candidates.includes(def.name.value)) return def;
+		lastObjectType = def;
+	}
+	if (!lastObjectType) throw new Error("No root state type found in the document model schema");
+	return lastObjectType;
+}
+/**
+* Derives the subselection for the document's `global` state scope from the
+* model's state SDL (e.g. `name total`), expanding object fields
+* recursively. Throws when the schema is missing, unparseable, or has no
+* root object type — the caller falls back to the generic document query.
+*/
+function getDocumentStateSelection(model) {
+	const schema = model.documentModel.global.specifications.at(-1)?.state.global.schema;
+	if (!schema || !schema.trim()) throw new Error("Document model has no global state schema");
+	const ast = parse(schema);
+	const typeMap = buildStateTypeMap(ast.definitions);
+	const documentName = getDocumentModelSchemaName(model);
+	return expandStateFields(findRootStateType(ast.definitions, [`${documentName}State`, `${documentName}GlobalState`]), typeMap);
+}
+function getLocalStateSelection(localSchema, documentName) {
+	const ast = parse(localSchema);
+	const typeMap = buildStateTypeMap(ast.definitions);
+	return expandStateFields(findRootStateType(ast.definitions, [`${documentName}LocalState`]), typeMap);
+}
+/**
+* Builds a query scoped to a document type's own subgraph root field,
+* selecting the document and its full typed state. The shape mirrors what
+* the switchboard generates per model (`generateNewApiSchema` in
+* `create-schema.ts`): `<Name> { document(identifier:) { document { ...
+* state { auth document global local } } } childIds }`.
+*/
+function buildModelScopedQuery(model) {
+	const globalState = model.documentModel.global;
+	const documentName = getDocumentModelSchemaName(model);
+	const globalSelection = getDocumentStateSelection(model);
+	const localSchema = globalState.specifications.at(-1)?.state.local.schema ?? "";
+	const localSelection = localSchema.includes(`type ${documentName}LocalState`) ? getLocalStateSelection(localSchema, documentName) : null;
+	return [
+		"query GetDocument($identifier: String!) {",
+		`  ${documentName} {`,
+		"    document(identifier: $identifier) {",
+		"      document {",
+		"        id",
+		"        name",
+		"        documentType",
+		"        state {",
+		"          auth",
+		"          document { version hash { algorithm encoding } isDeleted deletedAtUtcIso deletedBy deletionReason }",
+		`          global { ${globalSelection} }`,
+		`          ${localSelection ? `local { ${localSelection} }` : "local"}`,
+		"        }",
+		"      }",
+		"      childIds",
+		"    }",
+		"  }",
+		"}"
+	].join("\n");
+}
+function buildDocumentSubgraphQuery(documentType, identifier, model, authToken) {
+	let query;
+	if (model && model.documentModel.global.id === documentType) try {
+		query = buildModelScopedQuery(model);
+	} catch (error) {
+		console.warn("Could not derive a document-scoped query from the document model, falling back to the generic document query:", error);
+		query = getDocumentGraphqlQuery();
+	}
+	else query = getDocumentGraphqlQuery();
 	const variables = { identifier };
 	const headers = authToken ? { Authorization: `Bearer ${authToken}` } : void 0;
 	const payload = {
@@ -4254,10 +4518,11 @@ function buildDocumentSubgraphQuery(identifier, authToken) {
 		variables: JSON.stringify(variables, null, 2)
 	};
 	if (headers) payload.headers = JSON.stringify(headers);
-	return import_lz_string.compressToEncodedURIComponent(JSON.stringify(payload));
+	return import_lz_string.default.compressToEncodedURIComponent(JSON.stringify(payload));
 }
-function buildDocumentSubgraphUrl(driveUrl, identifier, authToken) {
-	return `${driveUrl}?explorerURLState=${buildDocumentSubgraphQuery(identifier, authToken)}`;
+function buildDocumentSubgraphUrl(channelUrl, documentType, identifier, model, authToken) {
+	const encodedQuery = buildDocumentSubgraphQuery(documentType, identifier, model, authToken);
+	return `${getSwitchboardBaseFromChannelUrl(channelUrl)}/explorer?explorerURLState=${encodedQuery}`;
 }
 /**
 * Hook that returns a function to generate a document's switchboard URL.
@@ -4273,6 +4538,7 @@ function buildDocumentSubgraphUrl(driveUrl, identifier, authToken) {
 function useGetSwitchboardLink(document) {
 	const [drive] = useSelectedDriveSafe();
 	const remotes = useSyncList();
+	const documentModelModule = useDocumentModelModuleById(document?.header.documentType);
 	const isRemoteDrive = useMemo(() => {
 		if (!e$4(drive)) return false;
 		return remotes.some((remote) => remote.meta.collectionId.equals(DriveCollectionId.forDrive(drive.header.id)));
@@ -4297,12 +4563,13 @@ function useGetSwitchboardLink(document) {
 				expiresIn: 600,
 				aud: remoteUrl
 			}) : void 0;
-			return buildDocumentSubgraphUrl(remoteUrl, document.header.id, token);
+			return buildDocumentSubgraphUrl(remoteUrl, document.header.documentType, document.header.id, documentModelModule, token);
 		};
 	}, [
 		isRemoteDrive,
 		remoteUrl,
 		document,
+		documentModelModule,
 		user,
 		renown
 	]);
@@ -4369,6 +4636,6 @@ function createDebouncedRefreshReactorDataClient(debounceDelayMs = DEFAULT_DEBOU
 createDebouncedRefreshReactorData();
 createDebouncedRefreshReactorDataClient();
 //#endregion
-export { usePHToast as A, useSelectedDriveId as B, addFolder$1 as C, useDisabledEditors as D, showRevisionHistory as E, t$5 as F, useDocumentById as H, isFileNodeKind as I, isFolderNodeKind as L, e$1 as M, e$4 as N, useDragNode as O, t$2 as P, setSelectedDrive as R, addDocument as S, showPHModal as T, useSelectedDriveSafe as V, useSetPHDocumentEditorConfig as _, useDownloadDocument as a, useSelectedDocumentOfType as b, useGetSwitchboardLink as c, useNodeParentFolderById as d, useNodesInSelectedDriveOrFolder as f, useSetPHAppConfig as g, useSelectedNodePath as h, useDocumentVersionStatus as i, useStudioMode as j, useDropNode as k, useNodeActions as l, useSelectedFolder as m, preloadEditorModule as n, useEditorModules as o, useParentFolderForSelectedNode as p, useAllowedDocumentModelModules as r, useEditorModulesForDocumentType as s, getSyncStatusSync as t, useNodeById as u, useTheme as v, showDeleteNodeModal as w, useSelectedDocumentSafe as x, useUserPermissions as y, setSelectedNode as z };
+export { useDropNode as A, setSelectedNode as B, addDocument as C, showRevisionHistory as D, showPHModal as E, t$2 as F, useSelectedDriveSafe as H, t$5 as I, isFileNodeKind as L, useStudioMode as M, e$1 as N, useDisabledEditors as O, e$4 as P, isFolderNodeKind as R, useSelectedDocumentSafe as S, showDeleteNodeModal as T, useDocumentById as U, useSelectedDriveId as V, useSetPHAppConfig as _, useDownloadDocument as a, useUserPermissions as b, useEditorModulesForDocumentType as c, useNodeById as d, useNodeParentFolderById as f, useSelectedNodePath as g, useSelectedFolder as h, useDocumentVersionStatus as i, usePHToast as j, useDragNode as k, useGetSwitchboardLink as l, useParentFolderForSelectedNode as m, preloadEditorModule as n, useDownloadFolder as o, useNodesInSelectedDriveOrFolder as p, useAllowedDocumentModelModules as r, useEditorModules as s, getSyncStatusSync as t, useNodeActions as u, useSetPHDocumentEditorConfig as v, addFolder$1 as w, useSelectedDocumentOfType as x, useTheme as y, setSelectedDrive as z };
 
-//# sourceMappingURL=dist-Bw_lDsJV.js.map
+//# sourceMappingURL=dist-C1pi89al.js.map