@efxlab/motion-canvas-2d 4.0.0

package/lib/components/Node.js

@@ -0,0 +1,1335 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var Node_1;
+import { BBox, DependencyContext, UNIFORM_DESTINATION_MATRIX, UNIFORM_SOURCE_MATRIX, UNIFORM_TIME, Vector2, all, clamp, createSignal, easeInOutCubic, isReactive, modify, threadable, transformAngle, transformScalar, unwrap, useLogger, } from '@efxlab/motion-canvas-core';
+import { cloneable, colorSignal, computed, getPropertiesOf, initial, initializeSignals, inspectable, nodeName, parser, signal, vector2Signal, wrapper, } from '../decorators';
+import { filtersSignal } from '../decorators/filtersSignal';
+import { spacingSignal } from '../decorators/spacingSignal';
+import { parseShader, } from '../partials/ShaderConfig';
+import { useScene2D } from '../scenes/useScene2D';
+import { drawLine } from '../utils';
+let Node = Node_1 = class Node {
+    get x() {
+        return this.position.x;
+    }
+    get y() {
+        return this.position.y;
+    }
+    getAbsolutePosition() {
+        return new Vector2(this.parentToWorld().transformPoint(this.position()));
+    }
+    setAbsolutePosition(value) {
+        this.position(modify(value, unwrapped => new Vector2(unwrapped).transformAsPoint(this.worldToParent())));
+    }
+    getAbsoluteRotation() {
+        const matrix = this.localToWorld();
+        return Vector2.degrees(matrix.m11, matrix.m12);
+    }
+    setAbsoluteRotation(value) {
+        this.rotation(modify(value, unwrapped => transformAngle(unwrapped, this.worldToParent())));
+    }
+    getAbsoluteScale() {
+        const matrix = this.localToWorld();
+        return new Vector2(Vector2.magnitude(matrix.m11, matrix.m12), Vector2.magnitude(matrix.m21, matrix.m22));
+    }
+    setAbsoluteScale(value) {
+        this.scale(modify(value, unwrapped => this.getRelativeScale(new Vector2(unwrapped))));
+    }
+    getRelativeScale(scale) {
+        const parentScale = this.parent()?.absoluteScale() ?? Vector2.one;
+        return scale.div(parentScale);
+    }
+    compositeOverride = createSignal(0);
+    *tweenCompositeOperation(value, time, timingFunction) {
+        const nextValue = unwrap(value);
+        if (nextValue === 'source-over') {
+            yield* this.compositeOverride(1, time, timingFunction);
+            this.compositeOverride(0);
+            this.compositeOperation(nextValue);
+        }
+        else {
+            this.compositeOperation(nextValue);
+            this.compositeOverride(1);
+            yield* this.compositeOverride(0, time, timingFunction);
+        }
+    }
+    absoluteOpacity() {
+        return (this.parent()?.absoluteOpacity() ?? 1) * this.opacity();
+    }
+    hasFilters() {
+        return !!this.filters().find(filter => filter.isActive());
+    }
+    hasShadow() {
+        return (!!this.shadowColor() &&
+            (this.shadowBlur() > 0 ||
+                this.shadowOffset.x() !== 0 ||
+                this.shadowOffset.y() !== 0));
+    }
+    filterString() {
+        let filters = '';
+        const matrix = this.compositeToWorld();
+        for (const filter of this.filters()) {
+            if (filter.isActive()) {
+                filters += ' ' + filter.serialize(matrix);
+            }
+        }
+        return filters;
+    }
+    getSpawner() {
+        return this.children();
+    }
+    setSpawner(value) {
+        this.children(value);
+    }
+    setChildren(value) {
+        if (this.children.context.raw() === value) {
+            return;
+        }
+        this.children.context.setter(value);
+        if (!isReactive(value)) {
+            this.spawnChildren(false, value);
+        }
+        else if (!this.hasSpawnedChildren) {
+            for (const oldChild of this.realChildren) {
+                oldChild.parent(null);
+            }
+        }
+    }
+    getChildren() {
+        this.children.context.getter();
+        return this.spawnedChildren();
+    }
+    spawnedChildren() {
+        const children = this.children.context.getter();
+        if (isReactive(this.children.context.raw())) {
+            this.spawnChildren(true, children);
+        }
+        return this.realChildren;
+    }
+    sortedChildren() {
+        return [...this.children()].sort((a, b) => Math.sign(a.zIndex() - b.zIndex()));
+    }
+    view2D;
+    stateStack = [];
+    realChildren = [];
+    hasSpawnedChildren = false;
+    unregister;
+    parent = createSignal(null);
+    properties = getPropertiesOf(this);
+    key;
+    creationStack;
+    constructor({ children, spawner, key, ...rest }) {
+        const scene = useScene2D();
+        [this.key, this.unregister] = scene.registerNode(this, key);
+        this.view2D = scene.getView();
+        this.creationStack = new Error().stack;
+        initializeSignals(this, rest);
+        if (spawner) {
+            useLogger().warn({
+                message: 'Node.spawner() has been deprecated.',
+                remarks: 'Use <code>Node.children()</code> instead.',
+                inspect: this.key,
+                stack: new Error().stack,
+            });
+        }
+        this.children(spawner ?? children);
+    }
+    /**
+     * Get the local-to-world matrix for this node.
+     *
+     * @remarks
+     * This matrix transforms vectors from local space of this node to world
+     * space.
+     *
+     * @example
+     * Calculate the absolute position of a point located 200 pixels to the right
+     * of the node:
+     * ```ts
+     * const local = new Vector2(0, 200);
+     * const world = local.transformAsPoint(node.localToWorld());
+     * ```
+     */
+    localToWorld() {
+        const parent = this.parent();
+        return parent
+            ? parent.localToWorld().multiply(this.localToParent())
+            : this.localToParent();
+    }
+    /**
+     * Get the world-to-local matrix for this node.
+     *
+     * @remarks
+     * This matrix transforms vectors from world space to local space of this
+     * node.
+     *
+     * @example
+     * Calculate the position relative to this node for a point located in the
+     * top-left corner of the screen:
+     * ```ts
+     * const world = new Vector2(0, 0);
+     * const local = world.transformAsPoint(node.worldToLocal());
+     * ```
+     */
+    worldToLocal() {
+        return this.localToWorld().inverse();
+    }
+    /**
+     * Get the world-to-parent matrix for this node.
+     *
+     * @remarks
+     * This matrix transforms vectors from world space to local space of this
+     * node's parent.
+     */
+    worldToParent() {
+        return this.parent()?.worldToLocal() ?? new DOMMatrix();
+    }
+    /**
+     * Get the parent-to-world matrix for this node.
+     *
+     * @remarks
+     * This matrix transforms vectors from local space of this node's parent to
+     * world space.
+     */
+    parentToWorld() {
+        return this.parent()?.localToWorld() ?? new DOMMatrix();
+    }
+    /**
+     * Get the local-to-parent matrix for this node.
+     *
+     * @remarks
+     * This matrix transforms vectors from local space of this node to local space
+     * of this node's parent.
+     */
+    localToParent() {
+        const matrix = new DOMMatrix();
+        matrix.translateSelf(this.x(), this.y());
+        matrix.rotateSelf(0, 0, this.rotation());
+        matrix.scaleSelf(this.scale.x(), this.scale.y());
+        matrix.skewXSelf(this.skew.x());
+        matrix.skewYSelf(this.skew.y());
+        return matrix;
+    }
+    /**
+     * A matrix mapping composite space to world space.
+     *
+     * @remarks
+     * Certain effects such as blur and shadows ignore the current transformation.
+     * This matrix can be used to transform their parameters so that the effect
+     * appears relative to the closest composite root.
+     */
+    compositeToWorld() {
+        return this.compositeRoot()?.localToWorld() ?? new DOMMatrix();
+    }
+    compositeRoot() {
+        if (this.composite()) {
+            return this;
+        }
+        return this.parent()?.compositeRoot() ?? null;
+    }
+    compositeToLocal() {
+        const root = this.compositeRoot();
+        if (root) {
+            const worldToLocal = this.worldToLocal();
+            worldToLocal.m44 = 1;
+            return root.localToWorld().multiply(worldToLocal);
+        }
+        return new DOMMatrix();
+    }
+    view() {
+        return this.view2D;
+    }
+    /**
+     * Add the given node(s) as the children of this node.
+     *
+     * @remarks
+     * The nodes will be appended at the end of the children list.
+     *
+     * @example
+     * ```tsx
+     * const node = <Layout />;
+     * node.add(<Rect />);
+     * node.add(<Circle />);
+     * ```
+     * Result:
+     * ```mermaid
+     * graph TD;
+     *   layout([Layout])
+     *   circle([Circle])
+     *   rect([Rect])
+     *     layout-->rect;
+     *     layout-->circle;
+     * ```
+     *
+     * @param node - A node or an array of nodes to append.
+     */
+    add(node) {
+        return this.insert(node, Infinity);
+    }
+    /**
+     * Insert the given node(s) at the specified index in the children list.
+     *
+     * @example
+     * ```tsx
+     * const node = (
+     *   <Layout>
+     *     <Rect />
+     *     <Circle />
+     *   </Layout>
+     * );
+     *
+     * node.insert(<Txt />, 1);
+     * ```
+     *
+     * Result:
+     * ```mermaid
+     * graph TD;
+     *   layout([Layout])
+     *   circle([Circle])
+     *   text([Text])
+     *   rect([Rect])
+     *     layout-->rect;
+     *     layout-->text;
+     *     layout-->circle;
+     * ```
+     *
+     * @param node - A node or an array of nodes to insert.
+     * @param index - An index at which to insert the node(s).
+     */
+    insert(node, index = 0) {
+        const array = Array.isArray(node) ? node : [node];
+        if (array.length === 0) {
+            return this;
+        }
+        const children = this.children();
+        const newChildren = children.slice(0, index);
+        for (const node of array) {
+            if (node instanceof Node_1) {
+                newChildren.push(node);
+                node.remove();
+                node.parent(this);
+            }
+        }
+        newChildren.push(...children.slice(index));
+        this.setParsedChildren(newChildren);
+        return this;
+    }
+    /**
+     * Remove this node from the tree.
+     */
+    remove() {
+        const current = this.parent();
+        if (current === null) {
+            return this;
+        }
+        current.removeChild(this);
+        this.parent(null);
+        return this;
+    }
+    /**
+     * Rearrange this node in relation to its siblings.
+     *
+     * @remarks
+     * Children are rendered starting from the beginning of the children list.
+     * We can change the rendering order by rearranging said list.
+     *
+     * A positive `by` arguments move the node up (it will be rendered on top of
+     * the elements it has passed). Negative values move it down.
+     *
+     * @param by - Number of places by which the node should be moved.
+     */
+    move(by = 1) {
+        const parent = this.parent();
+        if (by === 0 || !parent) {
+            return this;
+        }
+        const children = parent.children();
+        const newChildren = [];
+        if (by > 0) {
+            for (let i = 0; i < children.length; i++) {
+                const child = children[i];
+                if (child === this) {
+                    const target = i + by;
+                    for (; i < target && i + 1 < children.length; i++) {
+                        newChildren[i] = children[i + 1];
+                    }
+                }
+                newChildren[i] = child;
+            }
+        }
+        else {
+            for (let i = children.length - 1; i >= 0; i--) {
+                const child = children[i];
+                if (child === this) {
+                    const target = i + by;
+                    for (; i > target && i > 0; i--) {
+                        newChildren[i] = children[i - 1];
+                    }
+                }
+                newChildren[i] = child;
+            }
+        }
+        parent.setParsedChildren(newChildren);
+        return this;
+    }
+    /**
+     * Move the node up in relation to its siblings.
+     *
+     * @remarks
+     * The node will exchange places with the sibling right above it (if any) and
+     * from then on will be rendered on top of it.
+     */
+    moveUp() {
+        return this.move(1);
+    }
+    /**
+     * Move the node down in relation to its siblings.
+     *
+     * @remarks
+     * The node will exchange places with the sibling right below it (if any) and
+     * from then on will be rendered under it.
+     */
+    moveDown() {
+        return this.move(-1);
+    }
+    /**
+     * Move the node to the top in relation to its siblings.
+     *
+     * @remarks
+     * The node will be placed at the end of the children list and from then on
+     * will be rendered on top of all of its siblings.
+     */
+    moveToTop() {
+        return this.move(Infinity);
+    }
+    /**
+     * Move the node to the bottom in relation to its siblings.
+     *
+     * @remarks
+     * The node will be placed at the beginning of the children list and from then
+     * on will be rendered below all of its siblings.
+     */
+    moveToBottom() {
+        return this.move(-Infinity);
+    }
+    /**
+     * Move the node to the provided position relative to its siblings.
+     *
+     * @remarks
+     * If the node is getting moved to a lower position, it will be placed below
+     * the sibling that's currently at the provided index (if any).
+     * If the node is getting moved to a higher position, it will be placed above
+     * the sibling that's currently at the provided index (if any).
+     *
+     * @param index - The index to move the node to.
+     */
+    moveTo(index) {
+        const parent = this.parent();
+        if (!parent) {
+            return this;
+        }
+        const currentIndex = parent.children().indexOf(this);
+        const by = index - currentIndex;
+        return this.move(by);
+    }
+    /**
+     * Move the node below the provided node in the parent's layout.
+     *
+     * @remarks
+     * The node will be moved below the provided node and from then on will be
+     * rendered below it. By default, if the node is already positioned lower than
+     * the sibling node, it will not get moved.
+     *
+     * @param node - The sibling node below which to move.
+     * @param directlyBelow - Whether the node should be positioned directly below
+     *                        the sibling. When true, will move the node even if
+     *                        it is already positioned below the sibling.
+     */
+    moveBelow(node, directlyBelow = false) {
+        const parent = this.parent();
+        if (!parent) {
+            return this;
+        }
+        if (node.parent() !== parent) {
+            useLogger().error("Cannot position nodes relative to each other if they don't belong to the same parent.");
+            return this;
+        }
+        const children = parent.children();
+        const ownIndex = children.indexOf(this);
+        const otherIndex = children.indexOf(node);
+        if (!directlyBelow && ownIndex < otherIndex) {
+            // Nothing to do if the node is already positioned below the target node.
+            // We could move the node so it's directly below the sibling node, but
+            // that might suddenly move it on top of other nodes. This is likely
+            // not what the user wanted to happen when calling this method.
+            return this;
+        }
+        const by = otherIndex - ownIndex - 1;
+        return this.move(by);
+    }
+    /**
+     * Move the node above the provided node in the parent's layout.
+     *
+     * @remarks
+     * The node will be moved above the provided node and from then on will be
+     * rendered on top of it. By default, if the node is already positioned
+     * higher than the sibling node, it will not get moved.
+     *
+     * @param node - The sibling node below which to move.
+     * @param directlyAbove - Whether the node should be positioned directly above the
+     *                        sibling. When true, will move the node even if it is
+     *                        already positioned above the sibling.
+     */
+    moveAbove(node, directlyAbove = false) {
+        const parent = this.parent();
+        if (!parent) {
+            return this;
+        }
+        if (node.parent() !== parent) {
+            useLogger().error("Cannot position nodes relative to each other if they don't belong to the same parent.");
+            return this;
+        }
+        const children = parent.children();
+        const ownIndex = children.indexOf(this);
+        const otherIndex = children.indexOf(node);
+        if (!directlyAbove && ownIndex > otherIndex) {
+            // Nothing to do if the node is already positioned above the target node.
+            // We could move the node so it's directly above the sibling node, but
+            // that might suddenly move it below other nodes. This is likely not what
+            // the user wanted to happen when calling this method.
+            return this;
+        }
+        const by = otherIndex - ownIndex + 1;
+        return this.move(by);
+    }
+    /**
+     * Change the parent of this node while keeping the absolute transform.
+     *
+     * @remarks
+     * After performing this operation, the node will stay in the same place
+     * visually, but its parent will be changed.
+     *
+     * @param newParent - The new parent of this node.
+     */
+    reparent(newParent) {
+        const position = this.absolutePosition();
+        const rotation = this.absoluteRotation();
+        const scale = this.absoluteScale();
+        newParent.add(this);
+        this.absolutePosition(position);
+        this.absoluteRotation(rotation);
+        this.absoluteScale(scale);
+        return this;
+    }
+    /**
+     * Remove all children of this node.
+     */
+    removeChildren() {
+        for (const oldChild of this.realChildren) {
+            oldChild.parent(null);
+        }
+        this.setParsedChildren([]);
+        return this;
+    }
+    /**
+     * Get the current children of this node.
+     *
+     * @remarks
+     * Unlike {@link children}, this method does not have any side effects.
+     * It does not register the `children` signal as a dependency, and it does not
+     * spawn any children. It can be used to safely retrieve the current state of
+     * the scene graph for debugging purposes.
+     */
+    peekChildren() {
+        return this.realChildren;
+    }
+    findAll(predicate) {
+        const result = [];
+        const queue = this.reversedChildren();
+        while (queue.length > 0) {
+            const node = queue.pop();
+            if (predicate(node)) {
+                result.push(node);
+            }
+            const children = node.children();
+            for (let i = children.length - 1; i >= 0; i--) {
+                queue.push(children[i]);
+            }
+        }
+        return result;
+    }
+    findFirst(predicate) {
+        const queue = this.reversedChildren();
+        while (queue.length > 0) {
+            const node = queue.pop();
+            if (predicate(node)) {
+                return node;
+            }
+            const children = node.children();
+            for (let i = children.length - 1; i >= 0; i--) {
+                queue.push(children[i]);
+            }
+        }
+        return null;
+    }
+    findLast(predicate) {
+        const search = [];
+        const queue = this.reversedChildren();
+        while (queue.length > 0) {
+            const node = queue.pop();
+            search.push(node);
+            const children = node.children();
+            for (let i = children.length - 1; i >= 0; i--) {
+                queue.push(children[i]);
+            }
+        }
+        while (search.length > 0) {
+            const node = search.pop();
+            if (predicate(node)) {
+                return node;
+            }
+        }
+        return null;
+    }
+    findAncestor(predicate) {
+        let parent = this.parent();
+        while (parent) {
+            if (predicate(parent)) {
+                return parent;
+            }
+            parent = parent.parent();
+        }
+        return null;
+    }
+    /**
+     * Get the nth children cast to the specified type.
+     *
+     * @param index - The index of the child to retrieve.
+     */
+    childAs(index) {
+        return this.children()[index] ?? null;
+    }
+    /**
+     * Get the children array cast to the specified type.
+     */
+    childrenAs() {
+        return this.children();
+    }
+    /**
+     * Get the parent cast to the specified type.
+     */
+    parentAs() {
+        return this.parent() ?? null;
+    }
+    /**
+     * Prepare this node to be disposed of.
+     *
+     * @remarks
+     * This method is called automatically when a scene is refreshed. It will
+     * be called even if the node is not currently attached to the tree.
+     *
+     * The goal of this method is to clean any external references to allow the
+     * node to be garbage collected.
+     */
+    dispose() {
+        if (!this.unregister) {
+            return;
+        }
+        this.stateStack = [];
+        this.unregister();
+        this.unregister = null;
+        for (const { signal } of this) {
+            signal?.context.dispose();
+        }
+        for (const child of this.realChildren) {
+            child.dispose();
+        }
+    }
+    /**
+     * Create a copy of this node.
+     *
+     * @param customProps - Properties to override.
+     */
+    clone(customProps = {}) {
+        const props = { ...customProps };
+        if (isReactive(this.children.context.raw())) {
+            props.children ??= this.children.context.raw();
+        }
+        else if (this.children().length > 0) {
+            props.children ??= this.children().map(child => child.clone());
+        }
+        for (const { key, meta, signal } of this) {
+            if (!meta.cloneable || key in props)
+                continue;
+            if (meta.compound) {
+                for (const [key, property] of meta.compoundEntries) {
+                    if (property in props)
+                        continue;
+                    const component = signal[key];
+                    if (!component.context.isInitial()) {
+                        props[property] = component.context.raw();
+                    }
+                }
+            }
+            else if (!signal.context.isInitial()) {
+                props[key] = signal.context.raw();
+            }
+        }
+        return this.instantiate(props);
+    }
+    /**
+     * Create a copy of this node.
+     *
+     * @remarks
+     * Unlike {@link clone}, a snapshot clone calculates any reactive properties
+     * at the moment of cloning and passes the raw values to the copy.
+     *
+     * @param customProps - Properties to override.
+     */
+    snapshotClone(customProps = {}) {
+        const props = {
+            ...this.getState(),
+            ...customProps,
+        };
+        if (this.children().length > 0) {
+            props.children ??= this.children().map(child => child.snapshotClone());
+        }
+        return this.instantiate(props);
+    }
+    /**
+     * Create a reactive copy of this node.
+     *
+     * @remarks
+     * A reactive copy has all its properties dynamically updated to match the
+     * source node.
+     *
+     * @param customProps - Properties to override.
+     */
+    reactiveClone(customProps = {}) {
+        const props = { ...customProps };
+        if (this.children().length > 0) {
+            props.children ??= this.children().map(child => child.reactiveClone());
+        }
+        for (const { key, meta, signal } of this) {
+            if (!meta.cloneable || key in props)
+                continue;
+            props[key] = () => signal();
+        }
+        return this.instantiate(props);
+    }
+    /**
+     * Create an instance of this node's class.
+     *
+     * @param props - Properties to pass to the constructor.
+     */
+    instantiate(props = {}) {
+        return new this.constructor(props);
+    }
+    /**
+     * Set the children without parsing them.
+     *
+     * @remarks
+     * This method assumes that the caller took care of parsing the children and
+     * updating the hierarchy.
+     *
+     * @param value - The children to set.
+     */
+    setParsedChildren(value) {
+        this.children.context.setter(value);
+        this.realChildren = value;
+    }
+    spawnChildren(reactive, children) {
+        const parsedChildren = this.parseChildren(children);
+        const keep = new Set();
+        for (const newChild of parsedChildren) {
+            const current = newChild.parent.context.raw();
+            if (current && current !== this) {
+                current.removeChild(newChild);
+            }
+            keep.add(newChild.key);
+            newChild.parent(this);
+        }
+        for (const oldChild of this.realChildren) {
+            if (!keep.has(oldChild.key)) {
+                oldChild.parent(null);
+            }
+        }
+        this.hasSpawnedChildren = reactive;
+        this.realChildren = parsedChildren;
+    }
+    /**
+     * Parse any `ComponentChildren` into an array of nodes.
+     *
+     * @param children - The children to parse.
+     */
+    parseChildren(children) {
+        const result = [];
+        const array = Array.isArray(children) ? children : [children];
+        for (const child of array) {
+            if (child instanceof Node_1) {
+                result.push(child);
+            }
+        }
+        return result;
+    }
+    /**
+     * Remove the given child.
+     */
+    removeChild(child) {
+        this.setParsedChildren(this.children().filter(node => node !== child));
+    }
+    /**
+     * Whether this node should be cached or not.
+     */
+    requiresCache() {
+        return (this.cache() ||
+            this.opacity() < 1 ||
+            this.compositeOperation() !== 'source-over' ||
+            this.hasFilters() ||
+            this.hasShadow() ||
+            this.shaders().length > 0);
+    }
+    cacheCanvas() {
+        const canvas = document.createElement('canvas').getContext('2d');
+        if (!canvas) {
+            throw new Error('Could not create a cache canvas');
+        }
+        return canvas;
+    }
+    /**
+     * Get a cache canvas with the contents of this node rendered onto it.
+     */
+    cachedCanvas() {
+        const context = this.cacheCanvas();
+        const cache = this.worldSpaceCacheBBox();
+        const matrix = this.localToWorld();
+        context.canvas.width = cache.width;
+        context.canvas.height = cache.height;
+        context.setTransform(matrix.a, matrix.b, matrix.c, matrix.d, matrix.e - cache.x, matrix.f - cache.y);
+        this.draw(context);
+        return context;
+    }
+    /**
+     * Get a bounding box for the contents rendered by this node.
+     *
+     * @remarks
+     * The returned bounding box should be in local space.
+     */
+    getCacheBBox() {
+        return new BBox();
+    }
+    /**
+     * Get a bounding box for the contents rendered by this node as well
+     * as its children.
+     */
+    cacheBBox() {
+        const cache = this.getCacheBBox();
+        const children = this.children();
+        const padding = this.cachePadding();
+        if (children.length === 0) {
+            return cache.addSpacing(padding);
+        }
+        const points = cache.corners;
+        for (const child of children) {
+            const childCache = child.fullCacheBBox();
+            const childMatrix = child.localToParent();
+            points.push(...childCache.corners.map(r => r.transformAsPoint(childMatrix)));
+        }
+        const bbox = BBox.fromPoints(...points);
+        return bbox.addSpacing(padding);
+    }
+    /**
+     * Get a bounding box for the contents rendered by this node (including
+     * effects applied after caching).
+     *
+     * @remarks
+     * The returned bounding box should be in local space.
+     */
+    fullCacheBBox() {
+        const matrix = this.compositeToLocal();
+        const shadowOffset = this.shadowOffset().transform(matrix);
+        const shadowBlur = transformScalar(this.shadowBlur(), matrix);
+        const result = this.cacheBBox().expand(this.filters.blur() * 2 + shadowBlur);
+        if (shadowOffset.x < 0) {
+            result.x += shadowOffset.x;
+            result.width -= shadowOffset.x;
+        }
+        else {
+            result.width += shadowOffset.x;
+        }
+        if (shadowOffset.y < 0) {
+            result.y += shadowOffset.y;
+            result.height -= shadowOffset.y;
+        }
+        else {
+            result.height += shadowOffset.y;
+        }
+        return result;
+    }
+    /**
+     * Get a bounding box in world space for the contents rendered by this node as
+     * well as its children.
+     *
+     * @remarks
+     * This is the same the bounding box returned by {@link cacheBBox} only
+     * transformed to world space.
+     */
+    worldSpaceCacheBBox() {
+        const viewBBox = BBox.fromSizeCentered(this.view().size()).expand(this.view().cachePadding());
+        const canvasBBox = BBox.fromPoints(...viewBBox.transformCorners(this.view().localToWorld()));
+        const cacheBBox = BBox.fromPoints(...this.cacheBBox().transformCorners(this.localToWorld()));
+        return canvasBBox.intersection(cacheBBox).pixelPerfect.expand(2);
+    }
+    parentWorldSpaceCacheBBox() {
+        return (this.findAncestor(node => node.requiresCache())?.worldSpaceCacheBBox() ??
+            new BBox(Vector2.zero, useScene2D().getRealSize()));
+    }
+    /**
+     * Prepare the given context for drawing a cached node onto it.
+     *
+     * @remarks
+     * This method is called before the contents of the cache canvas are drawn
+     * on the screen. It can be used to apply effects to the entire node together
+     * with its children, instead of applying them individually.
+     * Effects such as transparency, shadows, and filters use this technique.
+     *
+     * Whether the node is cached is decided by the {@link requiresCache} method.
+     *
+     * @param context - The context using which the cache will be drawn.
+     */
+    setupDrawFromCache(context) {
+        context.globalCompositeOperation = this.compositeOperation();
+        context.globalAlpha *= this.opacity();
+        if (this.hasFilters()) {
+            context.filter = this.filterString();
+        }
+        if (this.hasShadow()) {
+            const matrix = this.compositeToWorld();
+            const offset = this.shadowOffset().transform(matrix);
+            const blur = transformScalar(this.shadowBlur(), matrix);
+            context.shadowColor = this.shadowColor().serialize();
+            context.shadowBlur = blur;
+            context.shadowOffsetX = offset.x;
+            context.shadowOffsetY = offset.y;
+        }
+        const matrix = this.worldToLocal();
+        context.transform(matrix.a, matrix.b, matrix.c, matrix.d, matrix.e, matrix.f);
+    }
+    renderFromSource(context, source, x, y) {
+        this.setupDrawFromCache(context);
+        const compositeOverride = this.compositeOverride();
+        context.drawImage(source, x, y);
+        if (compositeOverride > 0) {
+            context.save();
+            context.globalAlpha *= compositeOverride;
+            context.globalCompositeOperation = 'source-over';
+            context.drawImage(source, x, y);
+            context.restore();
+        }
+    }
+    shaderCanvas(destination, source) {
+        const shaders = this.shaders();
+        if (shaders.length === 0) {
+            return null;
+        }
+        const scene = useScene2D();
+        const size = scene.getRealSize();
+        const parentCacheRect = this.parentWorldSpaceCacheBBox();
+        const cameraToWorld = new DOMMatrix()
+            .scaleSelf(size.width / parentCacheRect.width, size.height / -parentCacheRect.height)
+            .translateSelf(parentCacheRect.x / -size.width, parentCacheRect.y / size.height - 1);
+        const cacheRect = this.worldSpaceCacheBBox();
+        const cameraToCache = new DOMMatrix()
+            .scaleSelf(size.width / cacheRect.width, size.height / -cacheRect.height)
+            .translateSelf(cacheRect.x / -size.width, cacheRect.y / size.height - 1)
+            .invertSelf();
+        const gl = scene.shaders.getGL();
+        scene.shaders.copyTextures(destination, source);
+        scene.shaders.clear();
+        for (const shader of shaders) {
+            const program = scene.shaders.getProgram(shader.fragment);
+            if (!program) {
+                continue;
+            }
+            if (shader.uniforms) {
+                for (const [name, uniform] of Object.entries(shader.uniforms)) {
+                    const location = gl.getUniformLocation(program, name);
+                    if (location === null) {
+                        continue;
+                    }
+                    const value = unwrap(uniform);
+                    if (typeof value === 'number') {
+                        gl.uniform1f(location, value);
+                    }
+                    else if ('toUniform' in value) {
+                        value.toUniform(gl, location);
+                    }
+                    else if (value.length === 1) {
+                        gl.uniform1f(location, value[0]);
+                    }
+                    else if (value.length === 2) {
+                        gl.uniform2f(location, value[0], value[1]);
+                    }
+                    else if (value.length === 3) {
+                        gl.uniform3f(location, value[0], value[1], value[2]);
+                    }
+                    else if (value.length === 4) {
+                        gl.uniform4f(location, value[0], value[1], value[2], value[3]);
+                    }
+                }
+            }
+            gl.uniform1f(gl.getUniformLocation(program, UNIFORM_TIME), this.view2D.globalTime());
+            gl.uniform1i(gl.getUniformLocation(program, UNIFORM_TIME), scene.playback.frame);
+            gl.uniformMatrix4fv(gl.getUniformLocation(program, UNIFORM_SOURCE_MATRIX), false, cameraToCache.toFloat32Array());
+            gl.uniformMatrix4fv(gl.getUniformLocation(program, UNIFORM_DESTINATION_MATRIX), false, cameraToWorld.toFloat32Array());
+            shader.setup?.(gl, program);
+            scene.shaders.render();
+            shader.teardown?.(gl, program);
+        }
+        return gl.canvas;
+    }
+    /**
+     * Render this node onto the given canvas.
+     *
+     * @param context - The context to draw with.
+     */
+    render(context) {
+        if (this.absoluteOpacity() <= 0) {
+            return;
+        }
+        context.save();
+        this.transformContext(context);
+        if (this.requiresCache()) {
+            const cacheRect = this.worldSpaceCacheBBox();
+            if (cacheRect.width !== 0 && cacheRect.height !== 0) {
+                const cache = this.cachedCanvas().canvas;
+                const source = this.shaderCanvas(context.canvas, cache);
+                if (source) {
+                    this.renderFromSource(context, source, 0, 0);
+                }
+                else {
+                    this.renderFromSource(context, cache, cacheRect.position.x, cacheRect.position.y);
+                }
+            }
+        }
+        else {
+            this.draw(context);
+        }
+        context.restore();
+    }
+    /**
+     * Draw this node onto the canvas.
+     *
+     * @remarks
+     * This method is used when drawing directly onto the screen as well as onto
+     * the cache canvas.
+     * It assumes that the context have already been transformed to local space.
+     *
+     * @param context - The context to draw with.
+     */
+    draw(context) {
+        this.drawChildren(context);
+    }
+    drawChildren(context) {
+        for (const child of this.sortedChildren()) {
+            child.render(context);
+        }
+    }
+    /**
+     * Draw an overlay for this node.
+     *
+     * @remarks
+     * The overlay for the currently inspected node is displayed on top of the
+     * canvas.
+     *
+     * The provided context is in screen space. The local-to-screen matrix can be
+     * used to transform all shapes that need to be displayed.
+     * This approach allows to keep the line widths and gizmo sizes consistent,
+     * no matter how zoomed-in the view is.
+     *
+     * @param context - The context to draw with.
+     * @param matrix - A local-to-screen matrix.
+     */
+    drawOverlay(context, matrix) {
+        const box = this.cacheBBox().transformCorners(matrix);
+        const cache = this.getCacheBBox().transformCorners(matrix);
+        context.strokeStyle = 'white';
+        context.lineWidth = 1;
+        context.beginPath();
+        drawLine(context, box);
+        context.closePath();
+        context.stroke();
+        context.strokeStyle = 'blue';
+        context.beginPath();
+        drawLine(context, cache);
+        context.closePath();
+        context.stroke();
+    }
+    transformContext(context) {
+        const matrix = this.localToParent();
+        context.transform(matrix.a, matrix.b, matrix.c, matrix.d, matrix.e, matrix.f);
+    }
+    /**
+     * Try to find a node intersecting the given position.
+     *
+     * @param position - The searched position.
+     */
+    hit(position) {
+        let hit = null;
+        const local = position.transformAsPoint(this.localToParent().inverse());
+        const children = this.children();
+        for (let i = children.length - 1; i >= 0; i--) {
+            hit = children[i].hit(local);
+            if (hit) {
+                break;
+            }
+        }
+        return hit;
+    }
+    /**
+     * Collect all asynchronous resources used by this node.
+     */
+    collectAsyncResources() {
+        for (const child of this.children()) {
+            child.collectAsyncResources();
+        }
+    }
+    /**
+     * Wait for any asynchronous resources that this node or its children have.
+     *
+     * @remarks
+     * Certain resources like images are always loaded asynchronously.
+     * Awaiting this method makes sure that all such resources are done loading
+     * before continuing the animation.
+     */
+    async toPromise() {
+        do {
+            await DependencyContext.consumePromises();
+            this.collectAsyncResources();
+        } while (DependencyContext.hasPromises());
+        return this;
+    }
+    /**
+     * Return a snapshot of the node's current signal values.
+     *
+     * @remarks
+     * This method will calculate the values of any reactive properties of the
+     * node at the time the method is called.
+     */
+    getState() {
+        const state = {};
+        for (const { key, meta, signal } of this) {
+            if (!meta.cloneable || key in state)
+                continue;
+            state[key] = signal();
+        }
+        return state;
+    }
+    applyState(state, duration, timing = easeInOutCubic) {
+        if (duration === undefined) {
+            for (const key in state) {
+                const signal = this.signalByKey(key);
+                if (signal) {
+                    signal(state[key]);
+                }
+            }
+        }
+        const tasks = [];
+        for (const key in state) {
+            const signal = this.signalByKey(key);
+            if (state[key] !== signal.context.raw()) {
+                tasks.push(signal(state[key], duration, timing));
+            }
+        }
+        return all(...tasks);
+    }
+    /**
+     * Push a snapshot of the node's current state onto the node's state stack.
+     *
+     * @remarks
+     * This method can be used together with the {@link restore} method to save a
+     * node's current state and later restore it. It is possible to store more
+     * than one state by calling `save` method multiple times.
+     */
+    save() {
+        this.stateStack.push(this.getState());
+    }
+    restore(duration, timing = easeInOutCubic) {
+        const state = this.stateStack.pop();
+        if (state !== undefined) {
+            return this.applyState(state, duration, timing);
+        }
+    }
+    *[Symbol.iterator]() {
+        for (const key in this.properties) {
+            const meta = this.properties[key];
+            const signal = this.signalByKey(key);
+            yield { meta, signal, key };
+        }
+    }
+    signalByKey(key) {
+        return this[key];
+    }
+    reversedChildren() {
+        const children = this.children();
+        const result = [];
+        for (let i = children.length - 1; i >= 0; i--) {
+            result.push(children[i]);
+        }
+        return result;
+    }
+};
+__decorate([
+    vector2Signal()
+], Node.prototype, "position", void 0);
+__decorate([
+    wrapper(Vector2),
+    cloneable(false),
+    signal()
+], Node.prototype, "absolutePosition", void 0);
+__decorate([
+    initial(0),
+    signal()
+], Node.prototype, "rotation", void 0);
+__decorate([
+    cloneable(false),
+    signal()
+], Node.prototype, "absoluteRotation", void 0);
+__decorate([
+    initial(Vector2.one),
+    vector2Signal('scale')
+], Node.prototype, "scale", void 0);
+__decorate([
+    initial(Vector2.zero),
+    vector2Signal('skew')
+], Node.prototype, "skew", void 0);
+__decorate([
+    wrapper(Vector2),
+    cloneable(false),
+    signal()
+], Node.prototype, "absoluteScale", void 0);
+__decorate([
+    initial(0),
+    signal()
+], Node.prototype, "zIndex", void 0);
+__decorate([
+    initial(false),
+    signal()
+], Node.prototype, "cache", void 0);
+__decorate([
+    spacingSignal('cachePadding')
+], Node.prototype, "cachePadding", void 0);
+__decorate([
+    initial(false),
+    signal()
+], Node.prototype, "composite", void 0);
+__decorate([
+    initial('source-over'),
+    signal()
+], Node.prototype, "compositeOperation", void 0);
+__decorate([
+    threadable()
+], Node.prototype, "tweenCompositeOperation", null);
+__decorate([
+    initial(1),
+    parser((value) => clamp(0, 1, value)),
+    signal()
+], Node.prototype, "opacity", void 0);
+__decorate([
+    computed()
+], Node.prototype, "absoluteOpacity", null);
+__decorate([
+    filtersSignal()
+], Node.prototype, "filters", void 0);
+__decorate([
+    initial('#0000'),
+    colorSignal()
+], Node.prototype, "shadowColor", void 0);
+__decorate([
+    initial(0),
+    signal()
+], Node.prototype, "shadowBlur", void 0);
+__decorate([
+    vector2Signal('shadowOffset')
+], Node.prototype, "shadowOffset", void 0);
+__decorate([
+    initial([]),
+    parser(parseShader),
+    signal()
+], Node.prototype, "shaders", void 0);
+__decorate([
+    computed()
+], Node.prototype, "hasFilters", null);
+__decorate([
+    computed()
+], Node.prototype, "hasShadow", null);
+__decorate([
+    computed()
+], Node.prototype, "filterString", null);
+__decorate([
+    inspectable(false),
+    cloneable(false),
+    signal()
+], Node.prototype, "spawner", void 0);
+__decorate([
+    inspectable(false),
+    cloneable(false),
+    signal()
+], Node.prototype, "children", void 0);
+__decorate([
+    computed()
+], Node.prototype, "spawnedChildren", null);
+__decorate([
+    computed()
+], Node.prototype, "sortedChildren", null);
+__decorate([
+    computed()
+], Node.prototype, "localToWorld", null);
+__decorate([
+    computed()
+], Node.prototype, "worldToLocal", null);
+__decorate([
+    computed()
+], Node.prototype, "worldToParent", null);
+__decorate([
+    computed()
+], Node.prototype, "parentToWorld", null);
+__decorate([
+    computed()
+], Node.prototype, "localToParent", null);
+__decorate([
+    computed()
+], Node.prototype, "compositeToWorld", null);
+__decorate([
+    computed()
+], Node.prototype, "compositeRoot", null);
+__decorate([
+    computed()
+], Node.prototype, "compositeToLocal", null);
+__decorate([
+    computed()
+], Node.prototype, "cacheCanvas", null);
+__decorate([
+    computed()
+], Node.prototype, "cachedCanvas", null);
+__decorate([
+    computed()
+], Node.prototype, "cacheBBox", null);
+__decorate([
+    computed()
+], Node.prototype, "fullCacheBBox", null);
+__decorate([
+    computed()
+], Node.prototype, "worldSpaceCacheBBox", null);
+__decorate([
+    computed()
+], Node.prototype, "parentWorldSpaceCacheBBox", null);
+Node = Node_1 = __decorate([
+    nodeName('Node')
+], Node);
+export { Node };
+Node.prototype.isClass = true;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Node.js","sourceRoot":"","sources":["../../src/lib/components/Node.ts"],"names":[],"mappings":"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"}