@powerhousedao/shared 6.2.3-dev.5 → 6.2.3-dev.50

package/dist/document-drive/index.js

@@ -552,6 +552,14 @@ function createState(baseState, globalState, localState) {
 }
 //#endregion
 //#region document-drive/src/reducers/drive.ts
+/**
+* The untouched base of a mutative draft, or the value itself when it is not a
+* draft. Build replacement lists from it and freeze them before assigning, as
+* the node reducer does, so finalize skips the walk over the assigned list.
+*/
+function readBase(value) {
+	return isDraft(value) ? original(value) : value;
+}
 const driveReducer = {
 	setDriveNameOperation(state, action, dispatch) {
 		state.name = action.input.name;
@@ -588,7 +596,8 @@ const driveReducer = {
 		state.listeners.push(listener);
 	},
 	removeListenerOperation(state, action, dispatch) {
-		state.listeners = state.listeners.filter((listener) => listener.listenerId !== action.input.listenerId);
+		const listeners = readBase(state).listeners.filter((listener) => listener.listenerId !== action.input.listenerId);
+		state.listeners = Object.freeze(listeners);
 	},
 	addTriggerOperation(state, action, dispatch) {
 		const { trigger: input } = action.input;
@@ -601,7 +610,8 @@ const driveReducer = {
 		state.triggers.push(trigger);
 	},
 	removeTriggerOperation(state, action, dispatch) {
-		state.triggers = state.triggers.filter((trigger) => trigger.id !== action.input.triggerId);
+		const triggers = readBase(state).triggers.filter((trigger) => trigger.id !== action.input.triggerId);
+		state.triggers = Object.freeze(triggers);
 	}
 };
 //#endregion
@@ -675,22 +685,64 @@ function escapeRegExp(string) {
 	return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 /**
-* The node list as plain objects for read-only scans. Inside a mutative draft
-* this returns the untouched base list, so a find or filter over it does not
-* create a child draft per element it visits. Callers must read before they
-* write: the base list does not see mutations made earlier in the same action.
+* 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;
+	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);
 }
 /**
-* The node list with a node added, ordered by id. 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 to get
-* that benefit; passing the draft's own list is correct but slow.
+* 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 [...nodes, node].sort((a, b) => a.id.localeCompare(b.id));
+	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 UPGRADE_DOCUMENT's initialState and
+* imported documents replace 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;
@@ -713,13 +765,13 @@ const nodeReducer = {
 			srcKind: "file",
 			targetParentFolder: action.input.parentFolder || null
 		});
-		state.nodes = insertNodeSorted(nodes, {
+		assignNodes(state, insertNodeSorted(nodes, {
 			id: action.input.id,
 			name,
 			kind: "file",
 			parentFolder: action.input.parentFolder ?? null,
 			documentType: action.input.documentType
-		});
+		}));
 		dispatch?.({
 			type: "CREATE_CHILD_DOCUMENT",
 			input: {
@@ -738,18 +790,19 @@ const nodeReducer = {
 			srcKind: "folder",
 			targetParentFolder: action.input.parentFolder || null
 		});
-		state.nodes = insertNodeSorted(nodes, {
+		assignNodes(state, insertNodeSorted(nodes, {
 			...action.input,
 			name,
 			kind: "folder",
 			parentFolder: action.input.parentFolder ?? null
-		});
+		}));
 	},
 	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",
@@ -759,38 +812,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
@@ -802,8 +856,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: {
@@ -814,92 +867,101 @@ 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));
+		})));
 	}
 };
 //#endregion
 //#region document-drive/gen/reducer.ts
+const schemaMemo = /* @__PURE__ */ new Map();
+function memoizedSchema(makeSchema) {
+	let schema = schemaMemo.get(makeSchema);
+	if (schema === void 0) {
+		schema = makeSchema();
+		schemaMemo.set(makeSchema, schema);
+	}
+	return schema;
+}
 const driveStateReducer = (state, action, dispatch) => {
 	if (isDocumentAction(action)) return state;
 	const typedAction = action;
 	switch (typedAction.type) {
 		case "ADD_FILE":
-			AddFileInputSchema().parse(typedAction.input);
+			memoizedSchema(AddFileInputSchema).parse(typedAction.input);
 			nodeReducer.addFileOperation(state[typedAction.scope], action, dispatch);
 			break;
 		case "ADD_FOLDER":
-			AddFolderInputSchema().parse(typedAction.input);
+			memoizedSchema(AddFolderInputSchema).parse(typedAction.input);
 			nodeReducer.addFolderOperation(state[typedAction.scope], action, dispatch);
 			break;
 		case "DELETE_NODE":
-			DeleteNodeInputSchema().parse(typedAction.input);
+			memoizedSchema(DeleteNodeInputSchema).parse(typedAction.input);
 			nodeReducer.deleteNodeOperation(state[typedAction.scope], action, dispatch);
 			break;
 		case "UPDATE_FILE":
-			UpdateFileInputSchema().parse(typedAction.input);
+			memoizedSchema(UpdateFileInputSchema).parse(typedAction.input);
 			nodeReducer.updateFileOperation(state[typedAction.scope], action, dispatch);
 			break;
 		case "UPDATE_NODE":
-			UpdateNodeInputSchema().parse(typedAction.input);
+			memoizedSchema(UpdateNodeInputSchema).parse(typedAction.input);
 			nodeReducer.updateNodeOperation(state[typedAction.scope], action, dispatch);
 			break;
 		case "COPY_NODE":
-			CopyNodeInputSchema().parse(typedAction.input);
+			memoizedSchema(CopyNodeInputSchema).parse(typedAction.input);
 			nodeReducer.copyNodeOperation(state[typedAction.scope], action, dispatch);
 			break;
 		case "MOVE_NODE":
-			MoveNodeInputSchema().parse(typedAction.input);
+			memoizedSchema(MoveNodeInputSchema).parse(typedAction.input);
 			nodeReducer.moveNodeOperation(state[typedAction.scope], action, dispatch);
 			break;
 		case "SET_DRIVE_NAME":
-			SetDriveNameInputSchema().parse(typedAction.input);
+			memoizedSchema(SetDriveNameInputSchema).parse(typedAction.input);
 			driveReducer.setDriveNameOperation(state[typedAction.scope], action, dispatch);
 			break;
 		case "SET_DRIVE_ICON":
-			SetDriveIconInputSchema().parse(typedAction.input);
+			memoizedSchema(SetDriveIconInputSchema).parse(typedAction.input);
 			driveReducer.setDriveIconOperation(state[typedAction.scope], action, dispatch);
 			break;
 		case "SET_SHARING_TYPE":
-			SetSharingTypeInputSchema().parse(typedAction.input);
+			memoizedSchema(SetSharingTypeInputSchema).parse(typedAction.input);
 			driveReducer.setSharingTypeOperation(state[typedAction.scope], action, dispatch);
 			break;
 		case "SET_AVAILABLE_OFFLINE":
-			SetAvailableOfflineInputSchema().parse(typedAction.input);
+			memoizedSchema(SetAvailableOfflineInputSchema).parse(typedAction.input);
 			driveReducer.setAvailableOfflineOperation(state[typedAction.scope], action, dispatch);
 			break;
 		case "ADD_LISTENER":
-			AddListenerInputSchema().parse(typedAction.input);
+			memoizedSchema(AddListenerInputSchema).parse(typedAction.input);
 			driveReducer.addListenerOperation(state[typedAction.scope], action, dispatch);
 			break;
 		case "REMOVE_LISTENER":
-			RemoveListenerInputSchema().parse(typedAction.input);
+			memoizedSchema(RemoveListenerInputSchema).parse(typedAction.input);
 			driveReducer.removeListenerOperation(state[typedAction.scope], action, dispatch);
 			break;
 		case "ADD_TRIGGER":
-			AddTriggerInputSchema().parse(typedAction.input);
+			memoizedSchema(AddTriggerInputSchema).parse(typedAction.input);
 			driveReducer.addTriggerOperation(state[typedAction.scope], action, dispatch);
 			break;
 		case "REMOVE_TRIGGER":
-			RemoveTriggerInputSchema().parse(typedAction.input);
+			memoizedSchema(RemoveTriggerInputSchema).parse(typedAction.input);
 			driveReducer.removeTriggerOperation(state[typedAction.scope], action, dispatch);
 			break;
 		default: return state;
@@ -972,6 +1034,6 @@ const driveDocumentModelModule = {
 	}
 };
 //#endregion
-export { AddFileInputSchema, AddFolderInputSchema, AddListenerInputSchema, AddTriggerInputSchema, CopyNodeInputSchema, DeleteNodeInputSchema, DocumentDriveLocalStateSchema, DocumentDriveStateSchema, DriveDocumentHeaderSchema, DriveDocumentSchema, DrivePHStateSchema, FileNodeSchema, FolderNodeSchema, ListenerCallInfoInputSchema, ListenerCallInfoSchema, ListenerFilterInputSchema, ListenerFilterSchema, ListenerInputSchema, ListenerSchema, MoveNodeInputSchema, NodeSchema, PullResponderTriggerDataInputSchema, PullResponderTriggerDataSchema, RemoveListenerInputSchema, RemoveTriggerInputSchema, SetAvailableOfflineInputSchema, SetDriveIconInputSchema, SetDriveNameInputSchema, SetSharingTypeInputSchema, TransmitterTypeSchema, TriggerDataSchema, TriggerInputSchema, TriggerSchema, TriggerTypeSchema, UpdateFileInputSchema, UpdateNodeInputSchema, addFile, addFolder, addListener, addTrigger, assertIsDocumentOfType, assertIsDriveDocument, assertIsDriveState, assertIsStateOfType, copyNode, createGlobalState, createLocalState, createState, defaultGlobalState, defaultLocalState, defaultPHState, definedNonNullAnySchema, deleteNode, driveCreateDocument, driveCreateState, driveDocumentFileExtension, driveDocumentModel, driveDocumentModelModule, driveDocumentReducer, driveDocumentType, driveLoadFromInput, driveReducer, driveSaveToFileHandle, escapeRegExp, generateNodesCopy, getAncestors, getDescendants, getNextCopyNumber, handleTargetNameCollisions, initialGlobalState, initialLocalState, insertNodeSorted, isDefinedNonNullAny, isDocumentOfType, isDriveDocument, isDriveState, isFileNode, isFolderNode, isStateOfType, isValidName, moveNode, nodeReducer, readNodes, removeListener, removeTrigger, setAvailableOffline, setDriveIcon, setDriveName, setSharingType, updateFile, updateNode };
+export { AddFileInputSchema, AddFolderInputSchema, AddListenerInputSchema, AddTriggerInputSchema, CopyNodeInputSchema, DeleteNodeInputSchema, DocumentDriveLocalStateSchema, DocumentDriveStateSchema, DriveDocumentHeaderSchema, DriveDocumentSchema, DrivePHStateSchema, FileNodeSchema, FolderNodeSchema, ListenerCallInfoInputSchema, ListenerCallInfoSchema, ListenerFilterInputSchema, ListenerFilterSchema, ListenerInputSchema, ListenerSchema, MoveNodeInputSchema, NodeSchema, PullResponderTriggerDataInputSchema, PullResponderTriggerDataSchema, RemoveListenerInputSchema, RemoveTriggerInputSchema, SetAvailableOfflineInputSchema, SetDriveIconInputSchema, SetDriveNameInputSchema, SetSharingTypeInputSchema, TransmitterTypeSchema, TriggerDataSchema, TriggerInputSchema, TriggerSchema, TriggerTypeSchema, UpdateFileInputSchema, UpdateNodeInputSchema, addFile, addFolder, addListener, addTrigger, assertIsDocumentOfType, assertIsDriveDocument, assertIsDriveState, assertIsStateOfType, assignNodes, copyNode, createGlobalState, createLocalState, createState, defaultGlobalState, defaultLocalState, defaultPHState, definedNonNullAnySchema, deleteNode, driveCreateDocument, driveCreateState, driveDocumentFileExtension, driveDocumentModel, driveDocumentModelModule, driveDocumentReducer, driveDocumentType, driveLoadFromInput, driveReducer, driveSaveToFileHandle, escapeRegExp, generateNodesCopy, getAncestors, getDescendants, getNextCopyNumber, handleTargetNameCollisions, initialGlobalState, initialLocalState, insertNodeSorted, isDefinedNonNullAny, isDocumentOfType, isDriveDocument, isDriveState, isFileNode, isFolderNode, isStateOfType, isValidName, moveNode, nodeReducer, readNodes, removeListener, removeTrigger, setAvailableOffline, setDriveIcon, setDriveName, setSharingType, sortNodesById, updateFile, updateNode };
 
 //# sourceMappingURL=index.js.map