Attributes

Attributes are the values an educator writes in the Chalk element. They are declared in the manifest, validated by the Chalk parser, and delivered to the plugin at load time via InitContext.

Reading Attributes

Attribute values arrive in InitContext.attrs when the plugin loads. Every attribute declared in the manifest is present — optional attributes that were omitted carry their declared default value, or undefined if no default was declared.

internote.onInitialize(({ attrs }) => {
  const particles = attrs.particles           // number
  const label     = attrs.label               // string
  const isLooping = attrs.loop                // boolean
  const [w, h]    = attrs.size                // [number, number]
  const colour    = attrs.colour              // string ('teal', 'blue', etc.)
})

Types correspond to what the manifest declares:

• "number" → number
• "string" → string
• "boolean" → boolean
• "dimensions" → [number, number]
• "colour" → string (the colour name, e.g. 'teal')

Body and Detail Content

Plugin elements support both a body block {} and a detail block []. Both are passed to the plugin as structured arrays of child elements — InitContext.body and InitContext.detail respectively. If a block is omitted, the corresponding field is null.

internote.onInitialize(({ attrs, body, detail }) => {
  // body  — array of child elements from the {} block, or null
  // detail — array of child elements from the [] block, or null
  if (detail) renderItems(detail)
})

Each child element in the array is a plain object:

interface PluginChildElement {
  type: string                        // element name, e.g. 'event'
  attrs: Record<string, unknown>      // resolved attribute values
  body: PluginChildElement[] | null   // nested body children
  detail: PluginChildElement[] | null // nested detail children
  text: string | null                 // inline text content if element has no children
}

Body content also forms part of the element's content hash, which is the key used for interaction storage. Including meaningful body content ensures distinct element instances have distinct hashes — see Storage for details.

The allowed child element types for each block are declared in the manifest under chalk.childElements — see Manifest Reference.

TypeScript

Declare a typed interface matching your manifest's chalk.attributes to avoid casting unknown throughout your plugin:

import { internote, type InitContext } from '@internote/plugin-sdk'

interface SimAttrs {
  particles: number
  gravity: number
  elasticity: number
  size: [number, number]
  colour: string
  loop: boolean
}

let attrs: SimAttrs

internote.onInitialize((ctx: InitContext) => {
  attrs = ctx.attrs as unknown as SimAttrs
  internote.ready()
})