FrameNode

The frame node is a container used to define a layout hierarchy. It is similar to <div> in HTML. It is different from GroupNode, which is closer to a folder for layers. Frames can be created using pixso.createFrame.

Frames generally have their own size, though the size can be determined by that of its children in the case of auto-layout frames.

Frame node properties

`type`

Readonly: true
Type: FRAME

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

`clone`

Type: clone(): FrameNode

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

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.

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。

`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.

`layoutMode`

Type: "NONE" | "HORIZONTAL" | "VERTICAL"

Determines whether this layer uses auto-layout to position its children. Defaults to NONE.

`layoutWrap`

Type: "NO_WRAP" | "WRAP"

Determines whether this layer uses wrap autolayout. Default is NO_WRAP.

`primaryAxisSizingMode`

Type: "FIXED" | "AUTO"

Applicable only on auto-layout frames. Determines whether the primary axis has a fixed length (determined by the user) or an automatic length (determined by the layout engine).

`counterAxisSizingMode`

Type: "FIXED" | "AUTO"

Applicable only on auto-layout frames. Determines whether the counter axis has a fixed length (determined by the user) or an automatic length (determined by the layout engine).

`primaryAxisAlignItems`

Type: "MIN" | "MAX" | "CENTER" | "SPACE_BETWEEN"

Applicable only on auto-layout frames, ignored otherwise. Determines how the auto-layout frame’s children should be aligned in the primary axis direction.

`counterAxisAlignItems`

Type: "MIN" | "MAX" | "CENTER"

Applicable only on auto-layout frames, ignored otherwise. Determines how the auto-layout frame’s children should be aligned in the counter axis direction.

`paddingLeft`

Type: number

Applicable only on auto-layout frames, ignored otherwise. Determines the left padding between the border of the frame and its children.

`paddingRight`

Type: number

Applicable only on auto-layout frames, ignored otherwise. Determines the right padding between the border of the frame and its children.

`paddingTop`

Type: number

Applicable only on auto-layout frames, ignored otherwise. Determines the top padding between the border of the frame and its children.

`paddingBottom`

Type: number

Applicable only on auto-layout frames, ignored otherwise. Determines the bottom padding between the border of the frame and its children.

`itemSpacing`

Type: number

Applicable only on auto-layout frames. Determines distance between children of the frame.

`counterAxisSpacing`

Type: number

Applies only to autolayout frameworks with layoutWrap set to WRAP. Determine the distance between line breaks.

`itemReverseZIndex`

Type: boolean

Applies only to autolayout frameworks. Determines the stacking order of layers within the container. When true, the first layer will be drawn on top.

`strokesIncludedInLayout`

Type: boolean

Applies only to autolayout frameworks. Determines whether strokes are included in layout calculations. When true, the autolayout artboard behaves like css box-sizing: border-box.

`layoutGrids`

Type: ReadonlyArray<LayoutGrid>
Type Declaration: LayoutGrid

Array of LayoutGrid objects used as layout grids on this node.

`gridStyleId`

Type: string

The id of the GridStyle object that the layoutGrids property of this node is linked to.

`clipsContent`

Type: boolean

Whether the frame clips its contents. That is, whether layers inside the frame are visible outside the bounds of the frame.

`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.

`cornerRadius`

Type: number | pixso.mixed

Rounded corners.

`cornerSmoothing`

Type: number

The degree of smoothness of the control angle with the value range [0, 1].

`topLeftRadius`

Type: number

The angle of the upper left corner. Must be non-negative and can be a decimal number.

`topRightRadius`

Type: number

The angle of the upper right corner. Must be non-negative and can be a decimal number.

`bottomLeftRadius`

Type: number

The angle of the lower left corner. Must be non-negative and can be a decimal number.

`bottomRightRadius`

Type: number

The angle of the lower right corner. Must be non-negative and can be a decimal number.

`fills`

Type: ReadonlyArray<Paint> | pixso.mixed
Type Declaration: Paint

The fill of the layer.

// set fills
node.fills = newFills;

`fillStyleId`

Type: string | pixso.mixed

The id of the fill style linked to the current node, i.e. the id of the PaintStyle object linked to the fills property of the current node.

`strokes`

Type: ReadonlyArray<Paint>
Type Declaration: Paint

Stroke of the layer.

`strokeStyleId`

Type: string

The id of the stroke style linked to the current node, i.e. the id of the PaintStyle object linked to the strokes property of the current node.

`strokeWeight`

Type: number

The thickness of the stroke in all four directions, in pixels. It must be non-negative and can be a decimal number. Note that if a single-edge stroke is set such as strokeTopWeight, the single-edge stroke will prevail; if strokeWeight is set, a single-edge stroke in all four directions will be set at the same time.

`strokeJoin`

Type: StrokeJoin | pixso.mixed
Type Declaration: StrokeJoin

Edge decoration.

'MITER'
'BEVEL'
'ROUND'

`strokeAlign`

Type: "CENTER" | "INSIDE" | "OUTSIDE"

The alignment of the stroke relative to the layer boundary.

'CENTER'
'INSIDE'
'OUTSIDE'

`dashPattern`

Type: ReadonlyArray<number>

Specifies a list of numbers in pixels for the length of alternate strokes and gaps.

`strokeCap`

Type: StrokeCap | pixso.mixed
Type Declaration: StrokeCap

The endpoints are decorated.

`strokeMiterLimit`

Type: number

The miter limit on the stroke. This is the same as the SVG miter limit.

You can set individual stroke thicknesses for each of the four sides of a rectangular or frame-like node. Similar to strokeWeight, these values must be non-negative and can be decimal. To hide one side, set the value to 0.

set strokeWeight sets the value of all four edges.

`strokeTopWeight`

Type: number

Determines the top stroke weight on a rectangle node or frame-like node. Must be non-negative and can be fractional.

`strokeBottomWeight`

Type: number

Determines the bottom stroke weight on a rectangle node or frame-like node. Must be non-negative and can be fractional.

`strokeLeftWeight`

Type: number

Determines the left stroke weight on a rectangle node or frame-like node. Must be non-negative and can be fractional.

`strokeRightWeight`

Type: number

Determines the right stroke weight on a rectangle node or frame-like node. Must be non-negative and can be fractional.

`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.

`overflowDirection`

Type: "NONE" | "HORIZONTAL" | "VERTICAL" | "BOTH"

Determines whether a frame will scroll in presentation mode when the frame contains content that exceed the frame's bounds. Reflects the value shown in "Overflow Behavior" in the Prototype tab.