GroupNode

The group node is a container used to semantically group related nodes. You can think of them as a folder in the layers panel. It is different from FrameNode, which defines layout and is closer to a <div> in HTML. Groups can be created by grouping existing nodes using pixso.group.

Groups in Pixso are always positioned and sized to fit their content. As such, while you can move or resize a group, you should also expect that a group's position and size will change if you change its content.

Group node properties

`type`

Readonly: true
Type: GROUP

The type of this node, represented by the string literal GROUP.

`clone`

Type: clone(): GroupNode

Duplicates the group node. By default, the duplicate will be parented under pixso.currentPage. Nested components will be cloned as instances who master is the original component.

`children`

Readonly: true
Type: ReadonlyArray<SceneNode>
Type Declaration: SceneNode

The direct child of the current node.

`childrenCount`

Readonly: true
Type: number

Gets the number of direct children of the current node.

`appendChild`

Type: appendChild(child: SceneNode, preserveAbsolutePostion?: boolean): void

Adds the given node child as a direct child of the current node.

After appendChild, the relativeTransform of the child node is maintained by default. Due to changes in the parent layer of child, the position of the child node on the canvas may change; if you want to maintain the position of the child node, you can Set preserveAbsolutePostion to true.

`insertChild`

Type: insertChild(index: number, child: SceneNode, preserveAbsolutePostion?: boolean): void

Suppose a group has three children, A, B, and C. Now call the insertChild method to insert layer node D.

insertChild(0, D), the order of child nodes is: D, A, B, C.
insertChild(1, D), the order of child nodes is: A, D, B, C.
insertChild(2, D), the order of child nodes is: A, B, D, C.
insertChild(3, D), the order of child nodes is: A, B, C, D.

`findChildren`

Type: findChildren(callback?: (node: SceneNode) => boolean): SceneNode[]

Similar to findAll, except that findChildren will only look in the direct children of the current node (not the children of the children).

`findChild`

Type: findChild(callback: (node: SceneNode) => boolean): SceneNode | null

Similar to findOne, except that findChild will only look in the direct children of the current node (excluding children of children).

`findAll`

Type: findAll(callback?: (node: SceneNode) => boolean): SceneNode[]

Finds the entire subtree starting from the current node, calls the callback function for each node, and returns all nodes whose return value is true for the callback function.

`findOne`

Type: findOne(callback: (node: SceneNode) => boolean): SceneNode | null

Find the entire node tree starting from the current node, call the callback function for each node, and return the first node whose return value is true for the callback function.

`findAllWithCriteria`

Type: findAllWithCriteria<T extends NodeType[]>(criteria: {types: T;}): Array<{ type: T[number] } & SceneNode>
Type Declaration: NodeType

Searches the entire subtree (children of this node, children of its children, etc.). Returns all nodes that satisfy any of the types defined in the condition.

Scene node properties

`visible`

Type: boolean

Whether the node is visible or not. This property does not affect the ability of the plugin to access the node.

`locked`

Type: boolean

Whether the node is locked to prevent certain user interactions on the canvas, such as selection and dragging. This property does not affect the ability of the plugin to write these properties.

`componentPropertyReferences`

Type: { [nodeProperty in 'visible' | 'characters' | 'mainComponent']?: string} | null

All component properties that are attached on this node. The value in the key-value pair refers to the component property name as returned by componentPropertyDefinitions on the containing component, component set or main component (for instances).

A node can only have componentPropertyReferences if it is a component sublayer or an instance sublayer。

Base node properties

`id`

Readonly: true
Type: string

The ID of current node.

`parent`

Readonly: true
Type: (BaseNode & ChildrenMixin) | null

Get the parent node of the current node.

`index`

Readonly: true
Type: number

Get the sequential index of the current node at the same level.

`name`

Type: string

The name of the layer that appears in the layers panel.

`removed`

Readonly: true
Type: boolean

Returns true if the node was removed. if the plugin stays open for a while and stores references to the node, you should defensively write code and check that the node has not been removed by the user.

`toString`

Type: string

Returns a string representation of the node.

`remove`

Type: remove():void

Removes this node and all of its children from the document.

`setRelaunchData`

Type: data: {[command: string]: string}): void

Sets state on the node to show a button and description when the node is selected.

`getRelaunchData`

Type: getRelaunchData(): { [command: string]: string }

Retreives the reluanch data stored on this node using setRelaunchData

`getPluginData`

Type: getPluginData(key: string): string

Retrieves custom information that was stored on this node or style. To get a value type other than a string, decode it first via JSON.parse.

`setPluginData`

Type: setPluginData(key: string, value: string): void

Lets you store custom information on any node or style, private to your plugin. If you want to store a value type other than a string, please encode it first via JSON.stringify.

`getPluginDataKeys`

Type: getPluginDataKeys(): string[]

Retrieves a list of all keys stored on this node or style.

`getSharedPluginData`

Type: getSharedPluginData(namespace: string, key: string): string

Get the shared data stored on a specific namespace.

`setSharedPluginData`

Type: setSharedPluginData(namespace: string, key: string, value: string): void

This allows you to store custom information on any node. You can retrieve it later by calling getSharedPluginData with the same namespace and key. To find all the data on a node stored in a specific namespace, use getSharpedPluginDataKeys.

Any data you write using this API can be read by any plug-in. The purpose is to allow plugins to interoperate with each other. If you do not want other plugins to be able to read your data, use setPluginData instead.

You must also provide the namespace parameter to avoid key conflicts with other plugins. This parameter is mandatory to prevent multiple plugins from using common key names (such as data) and overwriting each other. We recommend passing a value that identifies your plugin. This namespace can be provided to the authors of other plugins so that they can read data from your plugin.

namespace is a unique string used to identify your plugin and avoid key conflicts with other plugins. The namespace must contain at least 3 alphanumeric characters.

`getSharedPluginDataKeys`

Type: getSharedPluginDataKeys(namespace: string): string[]

Retrieves a list of all keys stored on this node or style using setSharedPluginData. This enables iterating through all data stored in a given namespace.

`expanded`

Type: boolean Whether this container is shown as expanded in the layers panel.

`opacity`

Type: number

Reads or sets the transparency of the layer, the value of which must be in the [0, 1] range.

`blendMode`

Type: BlendMode
Type Declaration: BlendMode

The blend mode of the layer.

`isMask`

Type: boolean

Whether the layer is a mask or not.

`effects`

Type: ReadonlyArray<Effect>

Returns an array of effects, see Effect for details on the data structure.

`effectStyleId`

Type: string

The id of the effect style linked to the current node, i.e. the id of the EffectStyle object linked to the effects property of the current node.

`x`

Type: number

The position of the layer node, equivalent to relativeTransform[0][2].

`y`

Type: number

The position of the layer node, equivalent to relativeTransform[1][2].

`width`

Readonly: true
Type: number

The width of the layer node.

`height`

Readonly: true
Type: number

The height of the layer node.

`relativeTransform`

Type: Transform
Type Declaration: Transform

The position of the layer node relative to its parent is represented as a transformation matrix. Note: relativeTransform does not work for auto layout normal sublayers. Relativetransform still works for sublayers with absolute positioning.

`absoluteTransform`

Readonly: true
Type: Transform
Type Declaration: Transform

The position of a layer node relative to the page containing it is presented as a transformation matrix.

`absoluteBoundingBox`

Readonly: true
Type: Rect | null
Type Declaration: Rect

Node boundaries that do not include rendering attributes such as shadows or strokes.

`getNestedBoundaryBox`

Type：getNestedBoundaryBox(): NestedBoundaryBox
Type Declaration: NestedBoundaryBox

Get the boundaryBox information of the current layer and all its sublayers

`absoluteRenderBounds`

Readonly: true
Type: Rect | null
Type Declaration: Rect

The actual boundaries of the node, including shadows, bold strokes, and anything else that might fall outside the node's regular bounding box, which is defined in x, y, width, and in height. x and y inside this property represents the absolute position of the node on the page. If the node is not visible, this value will be null.

`constrainProportions`

Type: boolean

After the switch, when the user resizes the layer via the Properties panel, it makes the layer maintain its scale.

`rotation`

Type: number

The rotation angle of the layer node. The value range is [-180, 180]. The values are equivalent to.

Math.atan2(-relativeTransform[1][0], relativeTransform[0][0]);

`layoutAlign`

Type: "STRETCH" | "INHERIT"

Applies only to direct child levels of the auto layout frame, otherwise ignore. Determines if the layer should be stretched along the inverse axis of the parent. The default is INHERIT.

`layoutGrow`

Type: number

This property applies only to direct child levels of the auto layout frame, otherwise it is ignored. Determines whether the layer should be stretched along the main axis of its parent. 0 corresponds to fixed size, 1 to stretched.

`resize`

Type: resize(width: number, height: number): void

Resizes the node. If the node contains child nodes with constraints, it applies those constraints during resizing. If the parent has an automatic layout, it causes the parent to resize.

`resizeWithoutConstraints`

Type: resizeWithoutConstraints(width: number, height: number): void

Resize nodes. If the parent is not automatically laid out, the children of the node will never resize, even if those children are constrained. If the parent has automatic layout, the parent child nodes and nodes of the node are resized (this constraint cannot be ignored).

`rescale`

Type: rescale(scale: number): void

Rescales the node. This API function is the equivalent of using the Scale Tool from the toolbar.

`constraints`

Type: Constraints
Type Declaration: Constraints

Constraints of this node relative to its containing FrameNode, if any.

`reactions`

Type: ReadonlyArray<Reaction>

A list of reactions on this node, which includes the methods in the prototype that interact with this node and the behavior of that interaction.

`exportSettings`

Type: exportSettings: ReadonlyArray<ExportSettings>
Type Declaration: ExportSettings

The export settings for the node.

`exportAsync`

Type: exportAsync(settings?: ExportSettings): Promise<Uint8Array>
Type Declaration: ExportSettings

Export the node as a encoded image.

HWDC

`exportJsonAsync`

Type: exportJsonAsync(): Promise<string>

Export the JSON data of the node, which includes all the information of the node.

`exportHexAsync`

Type: exportHexAsync(hex: string): Promise<string>

Export the Hex data of the node, which includes all the information of the node.