@powerhousedao/powerhouse-vetra-packages 6.2.3-dev.1 → 6.2.3-dev.10

package/dist/node/{document-drive-D1NMjQQc.mjs → document-drive-DuGBBYw5.mjs}

@@ -2988,6 +2988,29 @@ const makeCreator = (arg) => {
 * ```
 */
 const create = makeCreator();
+/**
+* `original(draft)` to get original state in the draft mutation function.
+*
+* ## Example
+*
+* ```ts
+* import { create, original } from '../index';
+*
+* const baseState = { foo: { bar: 'str' }, arr: [] };
+* const state = create(
+*   baseState,
+*   (draft) => {
+*     draft.foo.bar = 'str2';
+*     expect(original(draft.foo)).toEqual({ bar: 'str' });
+*   }
+* );
+* ```
+*/
+function original(target) {
+	const proxyDraft = getProxyDraft(target);
+	if (!proxyDraft) throw new Error(`original() is only used for a draft, parameter: ${target}`);
+	return proxyDraft.original;
+}
 Object.prototype.constructor.toString();
 /**
 * Cast a value to an Draft type value.
@@ -3773,6 +3796,7 @@ object({
 	editors: PowerhouseModulesSchema,
 	processors: PowerhouseModulesSchema,
 	subgraphs: PowerhouseModulesSchema,
+	pieces: PowerhouseModulesSchema,
 	config: array(ConfigEntrySchema).optional(),
 	pwa: PwaConfigSchema.optional()
 });
@@ -7345,36 +7369,36 @@ const logger = new class ConsoleLogger {
 	get #includeStack() {
 		return this.#level <= LOG_LEVELS.debug;
 	}
-	verbose(message, ...replacements) {
+	verbose = (message, ...replacements) => {
 		if (this.#level <= LOG_LEVELS.verbose) {
 			const [formattedMessage, meta] = formatMessage(this.#tagString, message, replacements, this.#includeStack);
 			console.debug(`[${meta["timestamp"]}] ${formattedMessage}`);
 		}
-	}
-	debug(message, ...replacements) {
+	};
+	debug = (message, ...replacements) => {
 		if (this.#level <= LOG_LEVELS.debug) {
 			const [formattedMessage, meta] = formatMessage(this.#tagString, message, replacements, this.#includeStack);
 			console.debug(`[${meta["timestamp"]}] ${formattedMessage}`);
 		}
-	}
-	info(message, ...replacements) {
+	};
+	info = (message, ...replacements) => {
 		if (this.#level <= LOG_LEVELS.info) {
 			const [formattedMessage, meta] = formatMessage(this.#tagString, message, replacements, this.#includeStack);
 			console.info(`[${meta["timestamp"]}] ${formattedMessage}`);
 		}
-	}
-	warn(message, ...replacements) {
+	};
+	warn = (message, ...replacements) => {
 		if (this.#level <= LOG_LEVELS.warn) {
 			const [formattedMessage, meta] = formatMessage(this.#tagString, message, replacements, this.#includeStack);
 			console.warn(`[${meta["timestamp"]}] ${formattedMessage}`);
 		}
-	}
-	error(message, ...replacements) {
+	};
+	error = (message, ...replacements) => {
 		if (this.#level <= LOG_LEVELS.error) {
 			const [formattedMessage, meta] = formatMessage(this.#tagString, message, replacements, this.#includeStack);
 			console.error(`[${meta["timestamp"]}] ${formattedMessage}`);
 		}
-	}
+	};
 }();
 //#endregion
 //#region ../shared/dist/document-drive/index.js
@@ -7976,6 +8000,65 @@ function getNextCopyNumber(files, baseFilename) {
 function escapeRegExp(string) {
 	return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+/**
+* A plain, unfrozen copy of the node list for read-only scans. Inside a
+* mutative draft the copy is taken from the untouched base list, so a find or
+* filter over it does not create a child draft per element it visits, and it is
+* a copy because the stored list is frozen and V8 scans a frozen array several
+* times slower than a normal one. Callers must read before they write: the base
+* list does not see mutations made earlier in the same action.
+*/
+function readNodes(state) {
+	return [...isDraft(state) ? original(state).nodes : state.nodes];
+}
+/**
+* The given array sorted by id and frozen, in place -- it takes ownership of
+* the array it is handed, which is why it is private to this module and only
+* ever given a list built at the call site. The freeze is what makes assigning
+* the list to a mutative draft cheap: assigning a draftable value to a draft
+* property queues a finalize pass that walks every element of the assigned
+* value, and the walk exits at its Object.isFrozen check instead. Elements must
+* be plain nodes -- an element that is still a draft would never be replaced by
+* its final value, because the walk that does that replacement is the one being
+* skipped.
+*/
+function freezeSortedById(nodes) {
+	nodes.sort((a, b) => a.id.localeCompare(b.id));
+	return Object.freeze(nodes);
+}
+/**
+* A copy of the given list, sorted by id and frozen, which is the shape the
+* node reducer assigns. Read the list with readNodes, build the new list from
+* it, and pass what this returns to assignNodes. The copy is what keeps the
+* freeze off the caller's array.
+*/
+function sortNodesById(nodes) {
+	return freezeSortedById([...nodes]);
+}
+/**
+* The node list with a node added, ordered by id and frozen, in the same shape
+* sortNodesById returns. The list is built and sorted as plain objects, so
+* inside a mutative draft the comparator never reads an element through the
+* draft proxy. Pass the list read with readNodes: the draft's own list would
+* put child drafts in the result, which the freeze then keeps mutative from
+* resolving.
+*/
+function insertNodeSorted(nodes, node) {
+	return freezeSortedById([...nodes, node]);
+}
+/**
+* Installs a node list as state.nodes. Every assignment the node reducer makes
+* goes through here, and this is the one place a frozen array crosses into
+* state: the generated DocumentDriveGlobalState types nodes as a mutable
+* Node[], so the cast below is where that gap is paid rather than spread over
+* the reducer. Consumers must treat drive.state.global.nodes as read-only --
+* mutating it in place (push, sort, splice) throws in strict mode; copy it
+* first, as readNodes does. Note that LOAD_STATE replaces a whole scope and can
+* install a list this function never saw.
+*/
+function assignNodes(state, nodes) {
+	state.nodes = nodes;
+}
 function handleTargetNameCollisions(params) {
 	const { nodes, targetParentFolder, srcName, srcKind } = params;
 	const targetNodeChildrenNames = nodes.filter((node) => targetParentFolder === "" ? node.parentFolder === null : node.parentFolder === targetParentFolder).filter((node) => node.kind === srcKind).map((node) => node.name);
@@ -7986,23 +8069,22 @@ const isValidName = (name) => {
 };
 const nodeReducer = {
 	addFileOperation(state, action, dispatch) {
-		if (state.nodes.find((node) => node.id === action.input.id)) throw new Error(`Node with id ${action.input.id} already exists!`);
+		const nodes = readNodes(state);
+		if (nodes.find((node) => node.id === action.input.id)) throw new Error(`Node with id ${action.input.id} already exists!`);
 		if (!isValidName(action.input.name)) throw new Error(`Invalid name: '${action.input.name}'. Names must not be empty or contain control characters.`);
 		const name = handleTargetNameCollisions({
-			nodes: state.nodes,
+			nodes,
 			srcName: action.input.name,
 			srcKind: "file",
 			targetParentFolder: action.input.parentFolder || null
 		});
-		const fileNode = {
+		assignNodes(state, insertNodeSorted(nodes, {
 			id: action.input.id,
 			name,
 			kind: "file",
 			parentFolder: action.input.parentFolder ?? null,
 			documentType: action.input.documentType
-		};
-		state.nodes.push(fileNode);
-		state.nodes.sort((a, b) => a.id.localeCompare(b.id));
+		}));
 		dispatch?.({
 			type: "CREATE_CHILD_DOCUMENT",
 			input: {
@@ -8012,27 +8094,28 @@ const nodeReducer = {
 		});
 	},
 	addFolderOperation(state, action) {
-		if (state.nodes.find((node) => node.id === action.input.id)) throw new Error(`Node with id ${action.input.id} already exists!`);
+		const nodes = readNodes(state);
+		if (nodes.find((node) => node.id === action.input.id)) throw new Error(`Node with id ${action.input.id} already exists!`);
 		if (!isValidName(action.input.name)) throw new Error(`Invalid name: '${action.input.name}'. Names must not be empty or contain control characters.`);
 		const name = handleTargetNameCollisions({
-			nodes: state.nodes,
+			nodes,
 			srcName: action.input.name,
 			srcKind: "folder",
 			targetParentFolder: action.input.parentFolder || null
 		});
-		state.nodes.push({
+		assignNodes(state, insertNodeSorted(nodes, {
 			...action.input,
 			name,
 			kind: "folder",
 			parentFolder: action.input.parentFolder ?? null
-		});
-		state.nodes.sort((a, b) => a.id.localeCompare(b.id));
+		}));
 	},
 	deleteNodeOperation(state, action, dispatch) {
-		const node = state.nodes.find((node) => node.id === action.input.id);
+		const nodes = readNodes(state);
+		const node = nodes.find((node) => node.id === action.input.id);
 		if (!node) throw new Error(`Node with id ${action.input.id} not found`);
-		const descendants = getDescendants(node, state.nodes);
-		state.nodes = state.nodes.filter((node) => node.id !== action.input.id && !descendants.find((descendant) => descendant.id === node.id));
+		const descendants = getDescendants(node, nodes);
+		assignNodes(state, sortNodesById(nodes.filter((node) => node.id !== action.input.id && !descendants.find((descendant) => descendant.id === node.id))));
 		[node, ...descendants].filter((node) => isFileNode(node)).forEach((node) => {
 			dispatch?.({
 				type: "DELETE_CHILD_DOCUMENT",
@@ -8042,38 +8125,39 @@ const nodeReducer = {
 	},
 	updateFileOperation(state, action) {
 		if (action.input.name && !isValidName(action.input.name)) throw new Error(`Invalid name: '${action.input.name}'. Names must not be empty or contain control characters.`);
-		state.nodes = state.nodes.map((node) => node.id === action.input.id ? {
+		const nodes = readNodes(state);
+		assignNodes(state, sortNodesById(nodes.map((node) => node.id === action.input.id ? {
 			...node,
 			name: handleTargetNameCollisions({
-				nodes: state.nodes.filter((n) => n.id !== action.input.id),
+				nodes: nodes.filter((n) => n.id !== action.input.id),
 				srcName: action.input.name ?? node.name,
 				srcKind: "file",
 				targetParentFolder: action.input.parentFolder ?? node.parentFolder
 			}),
 			documentType: action.input.documentType ?? node.documentType
-		} : node);
-		state.nodes.sort((a, b) => a.id.localeCompare(b.id));
+		} : node)));
 	},
 	updateNodeOperation(state, action) {
 		if (action.input.name && !isValidName(action.input.name)) throw new Error(`Invalid name: '${action.input.name}'. Names must not be empty or contain control characters.`);
-		state.nodes = state.nodes.map((node) => node.id === action.input.id ? {
+		const nodes = readNodes(state);
+		assignNodes(state, sortNodesById(nodes.map((node) => node.id === action.input.id ? {
 			...node,
 			name: handleTargetNameCollisions({
-				nodes: state.nodes.filter((n) => n.id !== action.input.id),
+				nodes: nodes.filter((n) => n.id !== action.input.id),
 				srcName: action.input.name ?? node.name,
 				srcKind: node.kind === "file" ? "file" : "folder",
 				targetParentFolder: action.input.parentFolder ?? node.parentFolder
 			}),
 			parentFolder: action.input.parentFolder === null ? null : node.parentFolder
-		} : node);
-		state.nodes.sort((a, b) => a.id.localeCompare(b.id));
+		} : node)));
 	},
 	copyNodeOperation(state, action, dispatch) {
-		const node = state.nodes.find((node) => node.id === action.input.srcId);
+		const nodes = readNodes(state);
+		const node = nodes.find((node) => node.id === action.input.srcId);
 		if (!node) throw new Error(`Node with id ${action.input.srcId} not found`);
-		if (state.nodes.find((node) => node.id === action.input.targetId)) throw new Error(`Node with id ${action.input.targetId} already exists`);
+		if (nodes.find((node) => node.id === action.input.targetId)) throw new Error(`Node with id ${action.input.targetId} already exists`);
 		const name = handleTargetNameCollisions({
-			nodes: state.nodes,
+			nodes,
 			srcName: action.input.targetName || node.name,
 			srcKind: node.kind === "file" ? "file" : "folder",
 			targetParentFolder: action.input.targetParentFolder || null
@@ -8085,8 +8169,7 @@ const nodeReducer = {
 			name,
 			parentFolder: action.input.targetParentFolder || null
 		};
-		state.nodes.push(newNode);
-		state.nodes.sort((a, b) => a.id.localeCompare(b.id));
+		assignNodes(state, insertNodeSorted(nodes, newNode));
 		if (isFileNode(newNode)) dispatch?.({
 			type: "COPY_CHILD_DOCUMENT",
 			input: {
@@ -8097,26 +8180,26 @@ const nodeReducer = {
 	},
 	moveNodeOperation(state, action) {
 		if (action.input.srcFolder === action.input.targetParentFolder) throw new Error("Circular Reference Error: Attempting to move a node to its current parent folder");
-		const node = state.nodes.find((node) => node.id === action.input.srcFolder);
+		const nodes = readNodes(state);
+		const node = nodes.find((node) => node.id === action.input.srcFolder);
 		if (!node) throw new Error(`Node with id ${action.input.srcFolder} not found`);
 		const name = handleTargetNameCollisions({
-			nodes: state.nodes,
+			nodes,
 			srcName: node.name,
 			srcKind: node.kind === "file" ? "file" : "folder",
 			targetParentFolder: action.input.targetParentFolder || null
 		});
 		if (isFolderNode(node)) {
-			if (getDescendants(node, state.nodes).find((descendant) => descendant.id === action.input.targetParentFolder)) throw new Error("Circular Reference Error: Cannot move a folder to one of its descendants");
+			if (getDescendants(node, nodes).find((descendant) => descendant.id === action.input.targetParentFolder)) throw new Error("Circular Reference Error: Cannot move a folder to one of its descendants");
 		}
-		state.nodes = state.nodes.map((node) => {
+		assignNodes(state, sortNodesById(nodes.map((node) => {
 			if (node.id === action.input.srcFolder) return {
 				...node,
 				name,
 				parentFolder: action.input.targetParentFolder || null
 			};
 			return node;
-		});
-		state.nodes.sort((a, b) => a.id.localeCompare(b.id));
+		})));
 	}
 };
 const driveStateReducer = (state, action, dispatch) => {
@@ -8251,4 +8334,4 @@ const driveDocumentModelModule = {
 //#endregion
 export { setModuleName as $, createPresignedHeader as A, hashDocumentStateForScope as B, baseCreateDocument as C, buildSignedAction as D, baseSaveToFileHandle as E, deleteModule as F, replayDocumentVersioned as G, normalizeDocumentModelVersion as H, deleteOperation as I, setInitialState as J, setAuthorName as K, deleteOperationError as L, createState as M, createZip as N, createAction as O, defaultBaseState as P, setModelName as Q, deserializeSignature as R, baseActions as S, baseLoadFromInputVersioned as T, redo as U, isDocumentAction as V, releaseNewVersion as W, setModelExtension as X, setModelDescription as Y, setModelId as Z, UnsupportedDocumentModelVersionError as _, getDescendants as a, setStateSchema as at, addOperationError as b, isFileNode as c, validateInitialState as ct, moveNode as d, zipEntries as dt, setName as et, updateNode as f, generateId as ft, BaseDocumentStateSchema as g, BaseDocumentHeaderSchema as h, generateNodesCopy as i, setOperationSchema as it, createReducer as j, createBaseState as k, isFolderNode as l, validateModules as lt, logger as m, copyNode as n, setOperationErrorName as nt, getNextCopyNumber as o, toTransportAction as ot, documentModelDocumentModelModule as p, setAuthorWebsite as q, driveDocumentModelModule as r, setOperationName as rt, handleTargetNameCollisions as s, undo as st, addFolder as t, setOperationDescription as tt, isValidName as u, validateStateSchemaName as ut, addModule as v, baseLoadFromInput as w, assertAuthPreservedOnDuplicate as x, addOperation as y, documentModelDocumentType as z };
 
-//# sourceMappingURL=document-drive-D1NMjQQc.mjs.map
+//# sourceMappingURL=document-drive-DuGBBYw5.mjs.map