mirror of
https://github.com/invoke-ai/InvokeAI.git
synced 2026-02-19 07:44:49 -05:00
69ec14c7bb
- Add and use more performant `deepClone` method for deep copying throughout the UI. Benchmarks indicate the Really Fast Deep Clone library (`rfdc`) is the best all-around way to deep-clone large objects. This is particularly relevant in canvas. When drawing or otherwise manipulating canvas objects, we need to do a lot of deep cloning of the canvas layer state objects. Previously, we were using lodash's `cloneDeep`. I did some fairly realistic benchmarks with a handful of deep-cloning algorithms/libraries (including the native `structuredClone`). I used a snapshot of the canvas state as the data to be copied: On Chromium, `rfdc` is by far the fastest, over an order of magnitude faster than `cloneDeep`. On FF, `fastest-json-copy` and `recursiveDeepCopy` are even faster, but are rather limited in data types. `rfdc`, while only half as fast as the former 2, is still nearly an order of magnitude faster than `cloneDeep`. On Safari, `structuredClone` is the fastest, about 2x as fast as `cloneDeep`. `rfdc` is only 30% faster than `cloneDeep`. `rfdc`'s peak memory usage is about 10% more than `cloneDeep` on Chrome. I couldn't get memory measurements from FF and Safari, but let's just assume the memory usage is similar relative to the other algos. Overall, `rfdc` is the best choice for a single algo for all browsers. It's definitely the best for Chromium, by far the most popular desktop browser and thus our primary target. A future enhancement might be to detect the browser and use that to determine which algorithm to use.
62 lines
2.5 KiB
TypeScript
62 lines
2.5 KiB
TypeScript
import { deepClone } from 'common/util/deepClone';
|
|
import { satisfies } from 'compare-versions';
|
|
import { NodeUpdateError } from 'features/nodes/types/error';
|
|
import type { InvocationNode, InvocationTemplate } from 'features/nodes/types/invocation';
|
|
import { zParsedSemver } from 'features/nodes/types/semver';
|
|
import { defaultsDeep, keys, pick } from 'lodash-es';
|
|
|
|
import { buildInvocationNode } from './buildInvocationNode';
|
|
|
|
export const getNeedsUpdate = (node: InvocationNode, template: InvocationTemplate): boolean => {
|
|
if (node.data.type !== template.type) {
|
|
return true;
|
|
}
|
|
return node.data.version !== template.version;
|
|
};
|
|
|
|
/**
|
|
* Checks if a node may be updated by comparing its major version with the template's major version.
|
|
* @param node The node to check.
|
|
* @param template The invocation template to check against.
|
|
*/
|
|
const getMayUpdateNode = (node: InvocationNode, template: InvocationTemplate): boolean => {
|
|
const needsUpdate = getNeedsUpdate(node, template);
|
|
if (!needsUpdate || node.data.type !== template.type) {
|
|
return false;
|
|
}
|
|
const templateMajor = zParsedSemver.parse(template.version).major;
|
|
|
|
return satisfies(node.data.version, `^${templateMajor}`);
|
|
};
|
|
|
|
/**
|
|
* Updates a node to the latest version of its template:
|
|
* - Create a new node data object with the latest version of the template.
|
|
* - Recursively merge new node data object into the node to be updated.
|
|
*
|
|
* @param node The node to updated.
|
|
* @param template The invocation template to update to.
|
|
* @throws {NodeUpdateError} If the node is not an invocation node.
|
|
*/
|
|
export const updateNode = (node: InvocationNode, template: InvocationTemplate): InvocationNode => {
|
|
const mayUpdate = getMayUpdateNode(node, template);
|
|
|
|
if (!mayUpdate || node.data.type !== template.type) {
|
|
throw new NodeUpdateError(`Unable to update node ${node.id}`);
|
|
}
|
|
|
|
// Start with a "fresh" node - just as if the user created a new node of this type
|
|
const defaults = buildInvocationNode(node.position, template);
|
|
|
|
// The updateability of a node, via semver comparison, relies on the this kind of recursive merge
|
|
// being valid. We rely on the template's major version to be majorly incremented if this kind of
|
|
// merge would result in an invalid node.
|
|
const clone = deepClone(node);
|
|
clone.data.version = template.version;
|
|
defaultsDeep(clone, defaults); // mutates!
|
|
|
|
// Remove any fields that are not in the template
|
|
clone.data.inputs = pick(clone.data.inputs, keys(defaults.data.inputs));
|
|
return clone;
|
|
};
|