Frame
Frame.Frame
Frame
Experimental
Frames are parent items that can group and hold together other items on a board, such as shapes, text, images, and so on.
When an item is a child of a parent frame, the child positioning reference is relative to the parent frame.
Frames help structure and organize board content:
- They enable exporting board content to PDF, or to save it as a presentation.
- They are indexed; they make it easier to search for and find board content.
- When presentation mode is enabled on a board, indexed frames define the sequence of the slides in the presentation.
When creating or updating a frame item, you can define its dimensions in the following way:
- Set or update only
width
.
Default width:100
dp - Set or update only
height
.
Default height:100
dp - Set or update
width
andheight
at the same time.
ℹ️ Note:
- If you resize a parent frame containing child items, the Web SDK throws an error if one or more children fall outside the parent frame after resizing it.
This isn't allowed, because it would break the parent/child relationship between the items.
To break the relationship, explicitly remove the child item(s) from the parent frame.
Example:
const frame = await miro.board.createFrame({
title: 'This frame ratio is 16:9',
style: {
fillColor: '#ffffff',
},
x: 0, // Default value: horizontal center of the board
y: 0, // Default value: vertical center of the board
width: 800,
height: 450,
});
// Output the created item to the developer console
console.log(frame);
Frame item:
Figure 1. A frame parent item containing a sticky note as a child item.
Table of contents
Properties
- type
- x
- y
- width
- height
- title
- showContent
- childrenIds
- style
- id
- origin
- parentId
- createdAt
- createdBy
- modifiedAt
- modifiedBy
Methods
Properties
type
• Readonly
type: "frame"
Defines the type of item.
Item type is useful to retrieve specific items from a board.
For example, you can fetch all card and shape items from the board, and then carry out an action on them.
Example:
// Get all items from the board
const items = await miro.board.get();
// Count all card and shape items on the board
let cards = 0;
let shapes = 0;
items.forEach((items) => {
switch (items.type) {
case 'card':
cards++;
case 'shape':
shapes++;
}
});
// Output to the console the total amount of card and shape items
console.log(`The current board has ${cards} cards and ${shapes} shapes.`);
Overrides
x
• x: number
The x-axis coordinate of an item is the horizontal distance in dp of the center point of the item from the center point of the board.
The center point of the board has x: 0
and y: 0
coordinates.
Default: 0
See also:
Overrides
y
• y: number
The y-axis coordinate of an item is the vertical distance in dp of the center point of the item from the center point of the board.
The center point of the board has x: 0
and y: 0
coordinates.
Default: 0
See also:
Overrides
width
• Readonly
width: number
Width of the item in dp.
See also:
height
• Readonly
height: number
Height of the item in dp.
See also:
title
• title: string
= ''
A short text header for the frame.
The text must be shorter than 6000 characters.
title
supports only plain text.
showContent
• showContent: boolean
Experimental
showContent
enables to programmatically hide or reveal the content inside a frame.
The functionality works like the show frame and hide frame options available on the item context menu when the frame is selected on the board UI.
showContent
is a boolean property:
showContent: true
: all the content inside the frame is visible.showContent: false
: all the content inside the frame is hidden.
On the board UI, an overlay is displayed over the frame to visually notify board users that they cannot view the frame content.
Default: true
ℹ️ Note:
- Hiding and revealing the content inside frames is only available to board owners and co-owners on Consultant and Enterprise plans.
If your app attempts to toggle the visibility of content inside a frame withshowContent
for users who are on different subscription plans and who aren't board owners or co-owners, the operation throws an error.
Figure 1. showContent: true
reveals the content inside the frame.
Figure 2. showContent: false
hides the content inside the frame.
childrenIds
• childrenIds: string
[]
An array of unique identifiers.
The IDs represent child items inside the frame.
They help retrieve child items inside a parent item.
style
• style: Object
The style
object groups properties that define the layout, the look and feel of specific elements of an item, when it's displayed on the board.
For example: background color, font family, font type, horizontal and vertical alignment of the text, text color, and so on.
The Miro Web SDK doesn't support all standard style, yet. Additional styles will be included in future releases.
style
data structure:
style: {
fillColor: 'transparent', // Default value: transparent (no fill color)
},
fillColor
fillColor
Hex value representing the background color that fills the area of the frame.
Default: transparent
(no fill color)
Type declaration
Name | Type |
---|---|
fillColor | string |
id
• Readonly
id: string
Unique ID of the item, assigned automatically upon creation.
Example: 3658432978520043388
origin
• origin: "center"
origin
marks:
- The positioning reference point of a board item.
This is the point used to calculate thex
andy
coordinates of an item when it's positioned on the board, or when it's a child inside a parent item. - The rotation pivot point of a board item that supports rotation.
origin
accepts only one value: center
.
Any other value throws an error.
parentId
• Readonly
parentId: null
| string
If an item is a child of another item, the child's parentId
returns the unique identifier of the corresponding parent item.
If an item has no parent, its parentId
is null
.
You can use the value to retrieve a tree structure when items are nested inside containers.
For example, sticky notes inside frames.
createdAt
• Readonly
createdAt: string
Timestamp
Date and time when the item was created.
Format: UTC, ISO 8601.
Includes a trailing Z offset.
Example: 2021-05-18T07:59:01Z
ℹ️ Note:
- Timestamps indicating creation and update times are always in UTC time, regardless of the time offset configured on the machine where the app runs or where the code is executed.
createdBy
• Readonly
createdBy: string
Miro users are automatically assigned a unique ID.
createdBy
contains the ID of the user who created the item.
Example: 3658432978520043388
modifiedAt
• Readonly
modifiedAt: string
Timestamp
Date and time when the item was last modified.
Format: UTC, ISO 8601.
Includes a trailing Z offset.
Example: 2021-05-18T07:59:01Z
ℹ️ Note:
- Timestamps indicating creation and update times are always in UTC time, regardless of the time offset configured on the machine where the app runs or where the code is executed.
modifiedBy
• Readonly
modifiedBy: string
Miro users are automatically assigned a unique ID.
modifiedBy
contains the ID of the user who applied the most recent edit to the item.
Example: 3658432978520043388
Methods
add
▸ add<T
>(item
): Promise
<T
>
Adds an item to a frame as a child.
The frame becomes the corresponding parent.
The add()
method takes a board item as an argument.
To add a board item to a frame with add()
, the item to add must:
- Exist on the board.
- Be located inside the frame.
add()
establishes a parent/child relationship between the containing frame and the items inside it.
After calling add()
:
- The
parentId
of the child item corresponds to the parent frame ID. - The child item ID is added to the frame
childrenIds
array. - The
x
andy
coordinates of the child item are recalculated relative to the top-left corner of the parent frame.
This enables repositioning a frame on the board along with its children, as they keep the same relative position inside the parent frame.
It also affects the positioning reference of the child item, because its x
and y
values are no longer relative to the center of the board.
After adding an item to a frame, the x
and y
coordinates of the child item inside the parent frame mark the center point of the child, relative to the top-left corner of the parent frame.
Adding a board item to a frame as a child can fail if:
- The parent frame doesn't exist.
- The child item is located outside the bounds of the parent frame.
- The child item is already a child inside a different frame.
Type parameters
Parameters
Name | Type |
---|---|
item | T |
Returns
Promise
<T
>
remove
▸ remove<T
>(item
): Promise
<void
>
Removes a child item from a frame.
The method removes the parent-child relationship between the items.
Both items still exist on the board as independent, detached items.
This affects the positioning reference of the item, because its x
and y
values are no longer relative to the top-left corner of the frame.
After removing an item from a frame, the item's x
and y
coordinates mark the center point of the item, relative to the center of the board.
The frame.remove()
method takes an item as an argument.
The promise that the method returns can fail if:
- The child item you're trying to remove doesn't exist.
- The item you're trying to remove isn't a child of the frame.
- The frame doesn't exist.
Example:
// Create a frame.
const frame = await miro.board.createFrame({
title: 'this frame ratio is 16:9',
style: {
fillColor: '#FFFFFF',
},
width: 800,
height: 450,
x: 4100,
y: 4200,
});
// Create a text item, and position it inside the frame.
const text = await miro.board.createText({
content: 'this is a piece of text',
style: {
fillColor: '#fff9b1', // Light yellow
},
x: frame.x + 180,
y: frame.y + 10,
});
// Create a shape item, and position it inside the frame.
const shape = await miro.board.createShape({
width: 200,
height: 250,
x: frame.x + 20,
y: frame.y + 50,
style: {
fillColor: '#FF0000',
},
});
// Add the text and the shape items as children of the parent frame.
await frame.add(text);
await frame.add(shape);
// Move the frame on the board.
// The children items move along with the frame:
// their coordinates are relative to the top-left corner of the frame.
frame.x = -400;
frame.y = -500;
await frame.sync();
// Update the child shape position inside the frame
// by specifying relative coordinates.
const shapes = await miro.board.get({type: 'shape'});
await Promise.all(
shapes.map((child) => {
child.x += 150;
child.y += 200;
return child.sync();
}),
);
// Remove the parent/child relationship between frame and text item.
await frame.remove(text);
// Move the frame on the board.
// The text item doesn't move along with the frame:
// its coordinates are relative to the center of the board.
frame.x += 400;
frame.y += 500;
await frame.sync();
// Remove the text item from the board
await miro.board.remove(text);
// Remove the frame from the board
await miro.board.remove(frame);
Type parameters
Parameters
Name | Type |
---|---|
item | T |
Returns
Promise
<void
>
getChildren
▸ getChildren(): Promise
<Item
[]>
Returns an array containing all the child items inside a parent frame.
If a frame has no children, the method returns an empty array.
Example:
// Specify all frame items on the board
let frames = await miro.board.get({type: 'frame'});
// Log to the console the child items of the frames
for (const frame of frames) {
const children = await frame.getChildren();
console.log(children);
}
Returns
Promise
<Item
[]>
sync
▸ sync(): Promise
<void
>
sync
propagates to the board any changes to item and tag properties.
After updating the properties of an item or a tag, sync it with the board to:
- Propagate to the board the changes applied to the item or to the tag.
- Make the changes visible on the board.
All board items and tags require sync
to make any changes to their properties visible on the board.
For more information and examples, see Update and sync item properties.
Example:
(The code example updates a text item using sync
.
The same mechanism applies to and works in the same way for all supported board items.)
// Create an item.
// In this case, a text item.
const text = await miro.board.createText({
content: '<p>This is a piece of text to remind me that I always finish what I ...</p>',
style: {
fillColor: 'transparent',
textAlign: 'left',
},
x: 0,
y: 0,
width: 450,
rotation: 0.0,
});
// Update the board item by modifying the values of its properties.
// In the text item case, the updated properties modify content, background color, and rotation of the item.
text.content = 'A fourteneer is "A line that rumbles on like this for being a bit too long."';
text.style.fillColor = '#a9fe65';
text.rotation = 180.0;
// Call 'sync' to make the changed board item properties visible on the board.
await text.sync();
// Output the updated board item to the developer console.
console.log(text);
Example:
(The code example updates a tag using sync
.
The same mechanism applies to and works in the same way for all supported board items.)
// Create a tag.
const todo = await miro.board.createTag({
title: 'todo',
color: 'yellow',
});
// Create a sticky note and attach the tag to it.
const stickyNote = await miro.board.createStickyNote({
content: 'sticky note with tag: "todo"',
tagIds: [todo.id],
});
console.log(stickyNote.tagIds); // => ['3074457345627244742']
// Update the tag properties: title and color.
todo.title = "won't fix";
todo.color = 'green';
// Call 'sync' to make the changed tag properties visible on the board.
await todo.sync();
// Output the updated tag to the developer console.
console.log(todo);
Returns
Promise
<void
>
getMetadata
▸ getMetadata(): Promise
<AppData
>
Experimental
Fetches board item metadata, stored per app, for the specified metadata key.
The response contains the metadata value assigned to the requested key.
To fetch all the metadata for a board item, invoke the method without passing any arguments.
The response contains all the metadata associated with the board item as key/value pairs.
An app can access only the metadata that it sets.
It cannot access metadata set by other apps.
getMetadata
and setMetadata
are available for the following board items:
- Card
- Connector
- Embed
- Image
- Preview
- Shape
- Sticky note
- Text
The methods aren't available for the following board items:
- Frames
- Unsupported board items
ℹ️ Note:
- To access board item metadata, apps require the
boards:read
permission. - To store board item metadata, apps require the
boards:write
permission. getMetadata
returns a new object, not a reference to the object that was previously set withsetMetadata
.- If the specified key isn't found, the method returns
undefined
.
⚠️ Warning:
- Use
AppMetadata
to store limited amounts of metadata.
Recommended: < 6 KB. - When updating metadata, limit the data size of the update payload.
Recommended: < 6 KB. - Don't use
AppMetadata
as a file storage solution (< 300 KB).
Example:
// Get the board item you want to retrieve metadata from.
const [geoCard] = await miro.board.get({type: 'card'});
// Set item metadata for an imaginary geocaching game, and store it to the retrieved card item.
await geoCard.setMetadata('leaderboard', ['Ziltoid', 'Howard', 'Paul']);
// Get the specific 'leaderboard' metadata from the card item.
const leaderboard = await geoCard.getAppData('leaderboard');
// Get all the metadata from the card item by passing no arguments.
await geoCard.getMetadata();
Returns
Promise
<AppData
>
▸ getMetadata<T
>(key
): Promise
<T
>
Type parameters
Name | Type |
---|---|
T | extends AppDataValue |
Parameters
Name | Type |
---|---|
key | string |
Returns
Promise
<T
>
setMetadata
▸ setMetadata<T
>(key
, value
): Promise
<T
>
Experimental
Adds board item metadata to make it available on the board that the app runs on.
An app can access only the board item metadata that it sets.
It cannot access metadata set by other apps.
Board item metadata is stored in the item it refers to. Therefore:
- When duplicating an item, the metadata is copied to the new item.
- When deleting an item, the corresponding metadata is removed with the deleted item.
Board item metadata is synced across, and available to, all the users who can:
- Access and view the board that the app is running on, AND
- Run the app on the board.
AppMetadata
is a key/value-pair object. It can contain values with the following data types:
string
number
boolean
Object
Array
getMetadata
and setMetadata
are available for the following board items:
- Card
- Connector
- Embed
- Image
- Preview
- Shape
- Sticky note
- Text
The methods aren't available for the following board items:
- Frames
- Unsupported board items
ℹ️ Note:
- To access board item metadata, apps require the
boards:read
permission. - To store board item metadata, apps require the
boards:write
permission. - You can overwrite the value of an existing key inside
AppMetadata
: if you pass the same key multiple times with different values, only the last/most recent value is stored with the key. - After setting a key, you cannot delete it; you can only update it.
However, you can delete the corresponding value by setting it tonull
, or to an empty value (''
). - You can assign an empty array (
[]
) as the value of a key. It's returned as an empty array.
⚠️ Warning:
- Use
AppMetadata
to store limited amounts of metadata.
Recommended: < 6 KB. - When updating metadata, limit the data size of the update payload.
Recommended: < 6 KB. - Don't use
AppMetadata
as a file storage solution (< 300 KB).
Example:
// Get the board item you want to set metadata to.
const [geoCard] = await miro.board.get({type: 'card'});
// Set item metadata for an imaginary geocaching game, and store it to the retrieved card item.
await geoCard.setMetadata('geoData', {
name: 'null',
coordinates: {
latitude: '33.950278',
longitude: '-105.314167',
},
lastFound: '1947-07-08',
content: true,
difficulty: 5,
keywords: ['x-files', 'truth-is-out-there', 'area-51', 'roswell', 'aliens'],
geoCache: [
{
name: 'UFO',
description: 'Severely damaged unidentified flying object. ',
},
{
name: 'Alien',
description: 'Remains of an alien life form.',
},
{
name: 'Artifacts',
description: 'Tools, equipment, and other items found at the crash site.',
},
{
name: 'Edibles',
description: 'The alien was likely as high as a kite when they crashed. Typical.',
},
],
});
// Get the specific 'geoData' metadata from the card item.
// The response contains the metadata value assigned to the key.
const geoCardGeoData = await geoCard.getMetadata('geoData');
// Get all the metadata from the card item.
// The response contains all the metadata assigned to the board item as key/value pairs.
const geoCardAllMetaData = await geoCard.getMetadata();
// Clear the metadata about the imaginary geocaching game by assigning 'geoData' an empty object.
await geoCard.setMetadata('geoData', {});
// If the card item metadata has a top-level key, you can clear all the metadata
// from the card item by assigning the top-level key an empty object.
// In this example, the top-level key name is 'metaData'.
await geoCard.setMetadata('metaData', {});
Type parameters
Name | Type |
---|---|
T | extends AppData |
Parameters
Name | Type |
---|---|
key | string |
value | AppDataValue |
Returns
Promise
<T
>
Updated 12 days ago
Go to board
to explore the methods to perform CRUD operations on board items, to set and get metadata, and to retrieve user information.