Options
All
  • Public
  • Public/Protected
  • All
Menu

@kano/code

Index

Enumerations

Classes

Interfaces

Type aliases

Variables

Functions

Object literals

Type aliases

CaretType

CaretType: "center" | "start"

DialogElement

DialogElement: T & object

IAPIJointDefinition

IAPIJointDefinition: IAPIDefinition | IAPIFunctionDefition

IBlocklyCategory

IBlocklyCategory: ICategory & object

IConfigResolver

IConfigResolver: function

Type declaration

    • <T>(key: string): T | null

    • Type parameters

      • T

      Parameters

      • key: string

      Returns T | null

IDiffResult

IDiffResult: INodeDiffResult | IInnerTextDiffResult | IEqualDiffResult

ISequenceConfig

ISequenceConfig: boolean[]

KanoAlertElement

KanoAlertElement: DialogElement<KanoAlert> & object

PluginLifecycleStep

PluginLifecycleStep: "onInstall" | "onInject" | "onDispose" | "onImport" | "onCreationImport" | "onExport" | "onCreationExport"

TooltipPosition

TooltipPosition: "top" | "right" | "bottom" | "left" | "float" | "rightTop"

Variables

Buffer

Buffer: any

Const Color

Color: unique symbol = Symbol()

Const CopyGenerators

CopyGenerators: ContributionManager<ContributionManager<ICopyGenerator>> = new ContributionManager<ContributionManager<ICopyGenerator>>()

CrossFade

CrossFade: any

Const DataAPI

DataAPI: IMetaDefinition[] = [{type: 'function',name: 'refresh',verbose: _('PART_DATA_REFRESH', 'refresh'),}, {type: 'function',name: 'onUpdate',verbose: _('PART_DATA_WHEN_UDPATED', 'when updated'),parameters: [{type: 'parameter',name: 'callback',verbose: '',returnType: Function,}],blockly: {postProcess(block : Block) {addFlashField(block);block.setPreviousStatement(false);block.setNextStatement(false);},},}]

Const FieldAssetPicker

FieldAssetPicker: FieldAssetPicker = Blockly.FieldAssetPicker

Const FileLoaders

FileLoaders: ContributionManager<IFileLoader> = new ContributionManager<IFileLoader>()

Const Flags

Flags: FlagsManager = new FlagsManager()

GifReader

GifReader: any

GifWriter

GifWriter: any

Loop

Loop: any

Const Msg$0

Msg$0: Msg$0

Const RESOURCE_CACHE_RESOLUTION_MULTIPLIER

RESOURCE_CACHE_RESOLUTION_MULTIPLIER: 2 = 2

Sequence

Sequence: any

Const SpeakerAPI

SpeakerAPI: IPartAPI = SpeakerAPIFactory(SpeakerPart)

Tone

Tone: any

Const TransformAPI

TransformAPI: IMetaDefinition[] = [{type: 'function',name: 'moveAlong',verbose: _('PART_TRANSFORM_MOVE', 'move'),parameters: [{type: 'parameter',name: 'distance',verbose: _('PART_TRANSFORM_DISTANCE', 'distance'),returnType: Number,default: 0,}],},{type: 'function',name: 'turn',verbose: _('PART_TRANSFORM_TURN', 'turn'),parameters: [{type: 'parameter',name: 'type',verbose: '',returnType: 'Enum',enum: [['\u21BB', 'clockwise'],['\u21BA', 'counterclockwise'],[_('PART_TRANSFORM_TURN_TO', 'to'), 'to'],],default: 'clockwise',}, {type: 'parameter',name: 'rotation',verbose: _('PART_TRANSFORM_ROTATION', 'rotation'),returnType: Number,default: 0,blockly: {shadow(defaultValue: number) {return `<shadow type="angle"><field name="VALUE">${defaultValue}</field></shadow>`}}}],blockly: {javascript(Blockly : Blockly, block : Block, m : Meta) {const type = block.getFieldValue('TYPE');const value = Blockly.JavaScript.valueToCode(block, 'ROTATION', Blockly.JavaScript.ORDER_ASSIGNMENT) || 0;const prefix = m.getNameChain('.').replace(/\.turn$/, '');if (type === 'to') {return `${prefix}.rotation = ${value};\n`;} else if (type === 'clockwise') {return `${prefix}.turnCW(${value});\n`;} else {return `${prefix}.turnCCW(${value});\n`;}},},},{type: 'function',name: 'setScale',verbose: _('PART_TRANSFORM_SET_SCALE', 'set size to'),parameters: [{type: 'parameter',name: 'scale',verbose: _('PART_TRANSFORM_SCALE', 'scale'),returnType: Number,default: 100,}],},{type: 'function',name: 'moveTo',verbose: _('PART_TRANSFORM_MOVE_TO', 'move to'),parameters: [{type: 'parameter',name: 'x',verbose: _('PART_TRANSFORM_X', 'x'),returnType: Number,default: 0,}, {type: 'parameter',name: 'y',verbose: _('PART_TRANSFORM_Y', 'y'),returnType: Number,default: 0,}],},{type: 'variable',name: 'opacity',verbose: _('PART_TRANSFORM_OPACITY', 'opacity'),returnType: Number,default: 100,setter: true,},{type: 'variable',name: 'x',verbose: _('PART_TRANSFORM_X', 'x'),returnType: Number,},{type: 'variable',name: 'y',verbose: _('PART_TRANSFORM_Y', 'y'),returnType: Number,},{type: 'variable',name: 'scale',verbose: _('PART_TRANSFORM_SCALE', 'scale'),returnType: Number,},{type: 'variable',name: 'rotation',verbose: _('PART_TRANSFORM_ROTATION', 'rotation'),returnType: Number,},{type: 'function',name: 'onClick',verbose: _('PART_TRANSFORM_ON_CLICK', 'on click'),parameters: [{type: 'parameter',name: 'callback',verbose: '',returnType: Function,}],blockly: {postProcess(block : Block) {addFlashField(block);block.setPreviousStatement(false);block.setNextStatement(false);},},},]

Transport

Transport: any

Const Wave

Wave: unique symbol = Symbol()

Const WebAudioTimestamp

WebAudioTimestamp: unique symbol = Symbol()

Const add

add: HTMLTemplateElement = svg`<svg viewBox="0 0 64 64" preserveAspectRatio="xMidYMid meet" focusable="false" style="pointer-events: none; display: block; width: 100%; height: 100%;"><g><path d="M25.94,35.92H18.09a2,2,0,0,1-1.5-.62,2.14,2.14,0,0,1-.64-1.52V30.29a2.14,2.14,0,0,1,.64-1.52,2,2,0,0,1,1.5-.62h7.85A2.18,2.18,0,0,0,28.1,26V18.14a2,2,0,0,1,.62-1.5A2.14,2.14,0,0,1,30.24,16h3.48a2.14,2.14,0,0,1,1.52.64,2,2,0,0,1,.62,1.5V26A2.18,2.18,0,0,0,38,28.15h7.85a2,2,0,0,1,1.5.62A2.14,2.14,0,0,1,48,30.29v3.48a2.14,2.14,0,0,1-.64,1.52,2,2,0,0,1-1.5.62H38a2.18,2.18,0,0,0-2.16,2.16v7.85a2,2,0,0,1-1.06,1.85,2.09,2.09,0,0,1-1.08.29H30.24a2.14,2.14,0,0,1-1.52-.64,2,2,0,0,1-.62-1.5V38.08a2.18,2.18,0,0,0-2.16-2.16Z"></path></g></svg>`

Const blockExceptions

blockExceptions: Map<string, IExceptionMapItem> = new Map<string, IExceptionMapItem>([['app', {blocks: new Map<string, string>([['app_onStart', 'onStart']]),}],['draw', {category: 'ctx',blocks: new Map<string, string>([['random', 'stamp_random']]),}],])

Const button

button: HTMLTemplateElement = html`<style>button.tool {display: flex;flex-direction: row;align-items: center;justify-content: center;@apply --kano-button;background-color: rgba(255, 255, 255, 0.25);border-radius: 3px;margin: 0 8px 0 0;font-size: 12px;font-weight: normal;text-shadow: none;font-family: var(--font-body);width: 32px;height: 32px;padding: 0px;cursor: pointer;}button.tool:hover,button.tool:focus {background-color: #FF6900;outline: 0;}button.tool>* {margin: 0 auto;}</style>`

Const challengeStyles

challengeStyles: CSSResult = css`.emoji {max-width: 18px;max-height: 18px;transform: translateY(4px);}kc-editor-banner {width: 272px;}@media only screen and (max-width: 980px) {kc-editor-banner {width: 195px;}}`

Const clear

clear: HTMLTemplateElement = svg`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><g><path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"></path></g></svg>`

Const create

Const debug

debug: log = logDecoratorFactory('DEBUG')

Const download

download: HTMLTemplateElement = svg`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><g><path d="M19 9h-4V3H9v6H5l7 7 7-7zM5 18v2h14v-2H5z"></path></g></svg>`

Const flash

flash: HTMLTemplateElement = svg`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 40 40"><polygon class="cls-1" points="17.59 23.26 17.61 22.78 6.36 22.78 16.8 0 28.82 0 23.61 11.39 35.22 11.39 17.59 39.9 17.59 23.26"/></svg>`

Const general

general: any[] = [{block: (part : any) => {return {id: 'set_background_color',message0: `${part.name}: ${_('DRAW_SET_BACKGROUND_COLOR', 'Set background color')} %1`,args0: [{type: "input_value",name: "COLOR",check: 'Colour'}],inlineInputs: true,previousStatement: null,nextStatement: null,};},javascript: () => {return function (block : Block) {let c = Blockly.JavaScript.valueToCode(block, 'COLOR', Blockly.JavaScript.ORDER_ASSIGNMENT) || `'#ffffff'`;return `ctx.background = ${c};\n`;};}}, {block: (part : any) => {return {id: 'set_transparency',message0: `${part.name}: ${_('DRAW_SET_TRANSPARENCY', 'Set transparency to')} %1`,args0: [{type: "input_value",name: "ALPHA",check: 'Number'}],inlineInputs: true,previousStatement: null,nextStatement: null,};},javascript: () => {return function (block : Block) {let a = Blockly.JavaScript.valueToCode(block, 'ALPHA', Blockly.JavaScript.ORDER_ASSIGNMENT) || '100';return `ctx.opacity = ${a};\n`;};}}]

Const next

next: HTMLTemplateElement = svg`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><g><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"></path></g></svg>`

Const paths

paths: any[] = [{block: (part : any) => {return {id: 'line_to',lookup: 'lineTo(x, y)',message0: `${part.name}: ${Blockly.Msg.BLOCK_CANVAS_LINE_TO}`,args0: [{type: "input_value",name: "X",check: 'Number'},{type: "input_value",name: "Y",check: 'Number',align: 'RIGHT'}],inlineInputs: true,previousStatement: null,nextStatement: null,};},javascript: () => {return function (block : Block) {let x = Blockly.JavaScript.valueToCode(block, 'X', Blockly.JavaScript.ORDER_COMMA) || 'null',y = Blockly.JavaScript.valueToCode(block, 'Y', Blockly.JavaScript.ORDER_COMMA) || 'null';return `ctx.lineTo(${x}, ${y});\n`;};}},{block: (part : any) => {return {id: 'line',lookup: 'line(x, y)',message0: `${part.name}: ${Blockly.Msg.BLOCK_CANVAS_LINE_ALONG}`,args0: [{type: "input_value",name: "X",check: 'Number'},{type: "input_value",name: "Y",check: 'Number',align: 'RIGHT'}],inlineInputs: true,previousStatement: null,nextStatement: null,};},javascript: () => {return function (block : Block) {let x = Blockly.JavaScript.valueToCode(block, 'X', Blockly.JavaScript.ORDER_COMMA) || 'null',y = Blockly.JavaScript.valueToCode(block, 'Y', Blockly.JavaScript.ORDER_COMMA) || 'null';return `ctx.line(${x}, ${y});\n`;};},}]

Const play

play: HTMLTemplateElement = svg`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><g><path d="M8 5v14l11-7z"></path></g></svg>`

Const previous

previous: HTMLTemplateElement = svg`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><g><path d="M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z"></path></g></svg>`

Const prismTheme

prismTheme: CSSResult = css`code[class*="language-"],pre[class*="language-"] {color: black;background: none;text-shadow: 0 1px white;font-family: Consolas, Monaco, 'Andale Mono', 'Ubuntu Mono', monospace;text-align: left;white-space: pre;word-spacing: normal;word-break: normal;word-wrap: normal;line-height: 1.5;-moz-tab-size: 4;-o-tab-size: 4;tab-size: 4;-webkit-hyphens: none;-moz-hyphens: none;-ms-hyphens: none;hyphens: none;}pre[class*="language-"]::-moz-selection, pre[class*="language-"] ::-moz-selection,code[class*="language-"]::-moz-selection, code[class*="language-"] ::-moz-selection {text-shadow: none;background: #b3d4fc;}pre[class*="language-"]::selection, pre[class*="language-"] ::selection,code[class*="language-"]::selection, code[class*="language-"] ::selection {text-shadow: none;background: #b3d4fc;}@media print {code[class*="language-"],pre[class*="language-"] {text-shadow: none;}}/* Code blocks */pre[class*="language-"] {padding: 1em;margin: .5em 0;overflow: auto;}:not(pre) > code[class*="language-"],pre[class*="language-"] {background: #f5f2f0;}/* Inline code */:not(pre) > code[class*="language-"] {padding: .1em;border-radius: .3em;white-space: normal;}.token.comment,.token.prolog,.token.doctype,.token.cdata {color: slategray;}.token.punctuation {color: #fff;}.namespace {opacity: .7;}.token.property,.token.tag,.token.boolean,.token.number,.token.constant,.token.symbol,.token.deleted {color: #ff9800;;}.token.selector,.token.attr-name,.token.string,.token.char,.token.builtin,.token.inserted {color: #88c440;}.token.operator,.token.entity,.token.url,.language-css .token.string,.style .token.string {color: #E65544;}.token.atrule,.token.attr-value,.token.keyword {color: #ff9800;}.token.function {color: #21a6e6;}.token.regex,.token.important,.token.variable {color: #ff9800;}.token.important,.token.bold {font-weight: bold;}.token.italic {font-style: italic;}.token.entity {cursor: help;}`

Const samples

samples: ISampleSet[] = [{label: 'Drum Machine',id: 'drum-machine',resources: [{id: 'claves',label: 'Claves',src: 'claves.wav',}, {id: 'bass-drum',label: 'Bass drum',src: 'bass_drum.wav',}, {src: 'closed_hi_hat.wav',label: 'Closed hi hat',id: 'closed_hi_hat',}, {src: 'cowbell.wav',label: 'Cowbell',id: 'cowbell',}, {src: 'cymbal.wav',label: 'Cymbal',id: 'cymbal',}, {src: 'hand_clap.wav',label: 'Hand clap',id: 'hand_clap',}, {src: 'hi_conga.wav',label: 'Hi conga',id: 'hi_conga',}, {src: 'hi_tom.wav',label: 'Hi tom',id: 'hi_tom',}, {src: 'low_conga.wav',label: 'Low conga',id: 'low_conga',}, {src: 'low_tom.wav',label: 'Low tom',id: 'low_tom',}, {src: 'maracas.wav',label: 'Maracas',id: 'maracas',}, {src: 'mid_conga.wav',label: 'Mid conga',id: 'mid_conga',}, {src: 'mid_tom.wav',label: 'Mid tom',id: 'mid_tom',}, {src: 'open_hi_hat.wav',label: 'Open hi hat',id: 'open_hi_hat',}, {src: 'rim_shot.wav',label: 'Rim shot',id: 'rim_shot',}, {src: 'snare_drum.wav',label: 'Snare drum',id: 'snare_drum',}],}, {label: 'Acoustic Guitar',id: 'acoustic-guitar',resources: [{src: 'guitar_1st_E.wav',id: 'guitar_1st_E',label: 'Note 1',}, {src: 'guitar_2nd_B.wav',id: 'guitar_2nd_B',label: 'Note 2',}, {src: 'guitar_3rd_G.wav',id: 'guitar_3rd_G',label: 'Note 3',}, {src: 'guitar_4th_D.wav',id: 'guitar_4th_D',label: 'Note 4',}, {src: 'guitar_5th_A.wav',id: 'guitar_5th_A',label: 'Note 5',}],}, {label: 'Electric Guitar',id: 'electric-guitar',resources: [{src: 'electric_guitar_1.wav',id: 'electric_guitar_1',label: 'Note 1',}, {src: 'electric_guitar_2.wav',id: 'electric_guitar_2',label: 'Note 2',}, {src: 'electric_guitar_3.wav',id: 'electric_guitar_3',label: 'Note 3',}, {src: 'electric_guitar_4.wav',id: 'electric_guitar_4',label: 'Note 4',}, {src: 'electric_guitar_5.wav',id: 'electric_guitar_5',label: 'Note 5',}]}, {label: 'Instruments',id: 'instruments',resources: [{src: 'ambi_piano.wav',id: 'ambi_piano',label: 'Ambi Piano',}, {src: 'bass_hit_c.wav',id: 'bass_hit_c',label: 'Bass Hit',}, {src: 'bass_voxy_hit_c.wav',id: 'bass_voxy_hit_c',label: 'Bass Voxy Hit',}, {src: 'drum_bass_hard.wav',id: 'drum_bass_hard',label: 'Drum Bass Hard',}, {src: 'bd_ada.wav',id: 'bd_ada',label: 'Drum Beat',}, {src: 'drum_cymbal_hard.wav',id: 'drum_cymbal_hard',label: 'Drum Cymbal Hard',}, {src: 'drum_roll.wav',id: 'drum_roll',label: 'Drum Roll',}, {src: 'joke_drum.wav',id: 'joke_drum',label: 'Joke Drum',}]}, {label: 'Kano',id: 'kano',resources: [{src: 'boot_up_v2.wav',id: 'boot_up_v2',label: 'Boot Up',}, {src: 'boot_up.wav',id: 'boot_up',label: 'Boot Up 2',}, {src: 'challenge_complete.wav',id: 'challenge_complete',label: 'Challenge Complete',}, {src: 'error2.wav',id: 'error2',label: 'Error',}, {src: 'error_v2.wav',id: 'error_v2',label: 'Error 2',}, {src: 'error.wav',id: 'error',label: 'Error 3',}, {src: 'grab.wav',id: 'grab',label: 'Grab',}, {src: 'make.wav',id: 'make',label: 'Make',}, {src: 'ungrab.wav',id: 'ungrab',label: 'Ungrab',}]}, {label: 'Loops',id: 'loops',resources: [{src: 'loop_amen_full.wav',id: 'loop_amen_full',label: 'Amen',}, {src: 'apache.wav',id: 'apache',label: 'Apache',}, {src: 'bass_loop.wav',id: 'bass_loop',label: 'Bass',}, {src: 'loop_compus.wav',id: 'loop_compus',label: 'Compus',}, {src: 'loop_mika.wav',id: 'loop_mika',label: 'Mika',}, {src: 'loop_mountain.wav',id: 'loop_mountain',label: 'Mountain',}, {src: 'loop_safari.wav',id: 'loop_safari',label: 'Safari',}],}, {label: 'Sounds',id: 'sounds',resources: [{src: 'perc_bell.wav',id: 'perc_bell',label: 'Bell',}, {src: 'misc_burp.wav',id: 'misc_burp',label: 'Burp',}, {src: 'misc_crow.wav',id: 'misc_crow',label: 'Crow',}, {src: 'air_horn.wav',id: 'air_horn',label: 'Air Horn',}, {src: 'short_fart.wav',id: 'short_fart',label: 'Fart',}, {src: 'frequency_sweep.wav',id: 'frequency_sweep',label: 'Frequency Sweep',}, {src: 'elec_ping.wav',id: 'elec_ping',label: 'Ping',}, {src: 'perc_snap.wav',id: 'perc_snap',label: 'Snap',}, {src: 'perc_swash.wav',id: 'perc_swash',label: 'Swash',}, {src: 'elec_twip.wav',id: 'elec_twip',label: 'Twip',}, {src: 'vinyl_backspin.wav',id: 'vinyl_backspin',label: 'Vinyl',}]}]

Const setters

setters: (object | object)[] = [{block: (part : any) => {return {id: 'color',lookup: 'fillColor(color)',message0: `${part.name}: ${Blockly.Msg.BLOCK_CANVAS_FILL_COLOR}`,args0: [{type: 'input_value',name: 'COLOR',check: 'Colour',}],previousStatement: null,nextStatement: null,};},javascript: () => {return function javascript(block : Block) {const color = Blockly.JavaScript.valueToCode(block, 'COLOR', Blockly.JavaScript.ORDER_NONE) || 'null';return `ctx.color(${color});\n`;};},}, {block: (part : any) => {return {id: 'no_fill',lookup: 'noFill',message0: `${part.name}: ${Blockly.Msg.BLOCK_CANVAS_NO_FILL}`,previousStatement: null,nextStatement: null};},javascript: () => {return function () {return `ctx.color('transparent');\n`;};}}, {block: (part : any) => {return {id: 'stroke',lookup: 'stroke(color, thickness)',message0: `${part.name}: ${Blockly.Msg.BLOCK_CANVAS_STROKE}`,args0: [{type: "input_value",name: "COLOR",check: 'Colour'},{type: "input_value",name: "SIZE",check: 'Number',align: 'RIGHT'}],previousStatement: null,nextStatement: null,};},javascript: () => {return function (block : Block) {let color = Blockly.JavaScript.valueToCode(block, 'COLOR', Blockly.JavaScript.ORDER_COMMA) || 'null',size = Blockly.JavaScript.valueToCode(block, 'SIZE', Blockly.JavaScript.ORDER_COMMA) || 'null';return `ctx.stroke(${color}, ${size});\n`;};},}]

Const shapes

shapes: (object | object)[] = [{block: (part : any) => {return {id: 'circle',lookup: 'circle(radius)',message0: `${part.name}: ${Blockly.Msg.BLOCK_CANVAS_CIRCLE}`,args0: [{type: "input_value",name: "RADIUS",check: 'Number'}],previousStatement: null,nextStatement: null,};},javascript: () => {return function (block : Block) {let radius = Blockly.JavaScript.valueToCode(block, 'RADIUS', Blockly.JavaScript.ORDER_NONE) || 'null';return `ctx.circle(${radius});\n`;};}},{block: (part : any) => {return {id: 'ellipse',lookup: 'ellipse(rx, ry)',message0: `${part.name}: ${Blockly.Msg.BLOCK_CANVAS_ELIPSE}`,args0: [{type: "input_value",name: "RADIUSX",check: 'Number'},{type: "input_value",name: "RADIUSY",check: 'Number',align: 'RIGHT'}],previousStatement: null,nextStatement: null,};},javascript: () => {return function (block : Block) {let radiusx = Blockly.JavaScript.valueToCode(block, 'RADIUSX', Blockly.JavaScript.ORDER_COMMA) || 'null',radiusy = Blockly.JavaScript.valueToCode(block, 'RADIUSY', Blockly.JavaScript.ORDER_COMMA) || 'null';return `ctx.ellipse(${radiusx}, ${radiusy});`;};}},{block: (part : any) => {return {id: 'square',lookup: 'square(size)',message0: `${part.name}: ${Blockly.Msg.BLOCK_CANVAS_SQUARE}`,args0: [{type: "input_value",name: "SIZE",check: 'Number'}],previousStatement: null,nextStatement: null,};},javascript: (part : any) => {return function (block: Block) {let size = Blockly.JavaScript.valueToCode(block, 'SIZE', Blockly.JavaScript.ORDER_NONE) || 'null';return `ctx.square(${size});`;};}},{block: (part : any) => {return {id: 'rectangle',lookup: 'rectangle(width, height)',message0: `${part.name}: ${Blockly.Msg.BLOCK_CANVAS_RECTANGLE}`,args0: [{type: "input_value",name: "WIDTH",check: 'Number'},{type: "input_value",name: "HEIGHT",check: 'Number',align: 'RIGHT'}],previousStatement: null,nextStatement: null,};},javascript: (part : any) => {return function (block: Block) {let width = Blockly.JavaScript.valueToCode(block, 'WIDTH', Blockly.JavaScript.ORDER_COMMA) || 'null',height = Blockly.JavaScript.valueToCode(block, 'HEIGHT', Blockly.JavaScript.ORDER_COMMA) || 'null';return `ctx.rectangle(${width}, ${height});`;};}},{block: (part : any) => {return {id: 'triangle',lookup: 'triangle(width, height)',message0: `${part.name}: ${Blockly.Msg.BLOCK_CANVAS_TRIANGLE}`,args0: [{type: "input_value",name: "WIDTH",check: 'Number'},{type: "input_value",name: "HEIGHT",check: 'Number',align: 'RIGHT'}],previousStatement: null,nextStatement: null,};},javascript: (part : any) => {return function (block: Block) {let width = Blockly.JavaScript.valueToCode(block, 'WIDTH', Blockly.JavaScript.ORDER_COMMA) || 'null',height = Blockly.JavaScript.valueToCode(block, 'HEIGHT', Blockly.JavaScript.ORDER_COMMA) || 'null';return `ctx.triangle(${width}, ${height});`;};}},{block: (part : any) => {return {id: 'arc',lookup: 'arc(radius, start, end, close)',message0: `${part.name}: ${Blockly.Msg.BLOCK_CANVAS_ARC}`,args0: [{type: "input_value",name: "RADIUS",check: 'Number'},{type: "input_value",name: "START",check: 'Number'},{type: "input_value",name: "END",check: 'Number'},{type: "input_value",name: "CLOSE",check: 'Boolean'}],previousStatement: null,nextStatement: null,};},javascript: (part : any) => {return function (block: Block) {let radius = Blockly.JavaScript.valueToCode(block, 'RADIUS', Blockly.JavaScript.ORDER_COMMA) || 'null',start = Blockly.JavaScript.valueToCode(block, 'START', Blockly.JavaScript.ORDER_COMMA) || 'null',end = Blockly.JavaScript.valueToCode(block, 'END', Blockly.JavaScript.ORDER_COMMA) || 'null',close = block.getFieldValue('CLOSE') || false;return `ctx.arc(${radius}, ${start}, ${end}, ${close});`;};}},{block: (part : any) => {let id = 'shapes_polygon';Blockly.Blocks[`${part.id}_${id}`] = {init: function () {this.points = 1;this.workspace.addChangeListener((e : any) => {if (e.type === Blockly.Events.MOVE &&(e.newParentId === this.id || e.oldParentId === this.id)&& e.newInputName !== 'CLOSE') {this._updateShape();}});this.setColour(COLOUR);this.appendDummyInput().appendField(`${part.name}: ${Blockly.Msg.BLOCK_CANVAS_POLYGON}`);this.setNextStatement(true);this.setPreviousStatement(true);this._initShape();},/*** Populate the block with inputs mapping to the points*/_initShape () {let inputName;for (let i = 1; i <= this.points; i++) {inputName = `X${i}`;if (!this.getInput(inputName)) {this.appendValueInput(inputName).setCheck('Number').setAlign(Blockly.ALIGN_RIGHT).appendField(`x${i}`);}inputName = `Y${i}`;if (!this.getInput(inputName)) {this.appendValueInput(inputName).setCheck('Number').setAlign(Blockly.ALIGN_RIGHT).appendField(`y${i}`);}}if (!this.getInput('CLOSE')) {this.appendValueInput('CLOSE').setCheck('Boolean').setAlign(Blockly.ALIGN_RIGHT).appendField('close path');}},/*** Check the inputs for the last and before last points and add/delete inputs accordingly*/_updateShape () {let xInput = this.getInput(`X${this.points}`)if (this.getInput('CLOSE')) {this.removeInput('CLOSE');}if (!xInput) {this.appendValueInput(`X${this.points}`).setCheck('Number').setAlign(Blockly.ALIGN_RIGHT).appendField(`x${this.points}`);this.appendValueInput(`Y${this.points}`).setCheck('Number').setAlign(Blockly.ALIGN_RIGHT).appendField(`y${this.points}`);}xInput = this.getInput(`X${this.points}`);let yInput = this.getInput(`Y${this.points}`);if (xInput.connection.targetConnection || yInput.connection.targetConnection) {this.points++;this._updateShape();} else {xInput = this.getInput(`X${this.points - 1}`);yInput = this.getInput(`Y${this.points - 1}`);if (this.points > 1 && !xInput.connection.targetConnection && !yInput.connection.targetConnection) {this.removeInput(`X${this.points}`);this.removeInput(`Y${this.points}`);this.points--;this._updateShape();}}if (!this.getInput('CLOSE')) {this.appendValueInput('CLOSE').setCheck('Boolean').setAlign(Blockly.ALIGN_RIGHT).appendField(Blockly.Msg.BLOCK_CANVAS_CLOSE_PATH);}},mutationToDom (block: Block) {let container = document.createElement('mutation');container.setAttribute('points', this.points);return container;},domToMutation(xmlElement : HTMLElement) {this.points = xmlElement.getAttribute('points');this._initShape();}};return {id,lookup: 'polygon(x1, y1, x2, y2, ...)',doNotRegister: true,colour: COLOUR};},javascript: (part : any) => {return function (block : Block) {let points = [],close = Blockly.JavaScript.valueToCode(block, 'CLOSE', Blockly.JavaScript.ORDER_COMMA) || true;for (let i = 1; i <= (block as any).points; i++) {points.push(Blockly.JavaScript.valueToCode(block, `X${i}`, Blockly.JavaScript.ORDER_COMMA) || 0);points.push(Blockly.JavaScript.valueToCode(block, `Y${i}`, Blockly.JavaScript.ORDER_COMMA) || 0);}return `ctx.polygon(${points.join(', ')}, ${close});`;};}}]

Const space

space: object[] = [{block: (part : any) => {return {id: 'move_to',lookup: 'moveTo(x, y)',message0: `${part.name}: ${Blockly.Msg.BLOCK_CANVAS_MOVE_TO}`,args0: [{type: "input_value",name: "X",check: 'Number'},{type: "input_value",name: "Y",check: 'Number',align: 'RIGHT'}],inlineInputs: true,previousStatement: null,nextStatement: null,};},javascript: (part : any) => {return function (block: Block) {let x = Blockly.JavaScript.valueToCode(block, 'X', Blockly.JavaScript.ORDER_COMMA) || 'null',y = Blockly.JavaScript.valueToCode(block, 'Y', Blockly.JavaScript.ORDER_COMMA) || 'null';return `ctx.moveTo(${x}, ${y});\n`;};}},{block: (part : any) => {return {id: 'move_to_random',lookup: 'moveToRandom()',message0: `${part.name}: ${Blockly.Msg.BLOCK_CANVAS_MOVE_TO_RANDOM}`,args0: [],inlineInputs: false,previousStatement: null,nextStatement: null,shadow: {}};},javascript: (part : any) => {return function (block: Block) {return `ctx.moveToRandom();\n`;};}},{block: (part : any) => {return {id: 'move',lookup: 'move(x, y)',message0: `${part.name}: ${Blockly.Msg.BLOCK_CANVAS_MOVE_BY}`,args0: [{type: "input_value",name: "X",check: 'Number'},{type: "input_value",name: "Y",check: 'Number',align: 'RIGHT'}],inlineInputs: true,previousStatement: null,nextStatement: null,};},javascript: (part : any) => {return function (block: Block) {let x = Blockly.JavaScript.valueToCode(block, 'X', Blockly.JavaScript.ORDER_COMMA) || 'null',y = Blockly.JavaScript.valueToCode(block, 'Y', Blockly.JavaScript.ORDER_COMMA) || 'null';return `ctx.move(${x}, ${y});\n`;};},}]

Const stamp

stamp: object[] = [{block: (part : any) => {return {id: 'stamp',lookup: 'stamp(sticker, size, rotation)',message0: `Draw: ${Blockly.Msg.BLOCK_CANVAS_STAMP}`,args0: [{type: "input_value",name: "STICKER",check: 'Sticker',},{type: "input_value",name: "SIZE",check: 'Number',align: 'RIGHT'},{type: "input_value",name: "ROTATION",check: 'Number',align: 'RIGHT'}],previousStatement: null,nextStatement: null,}},javascript: (part : any) => {return function (block: Block) {const image = Blockly.JavaScript.valueToCode(block, 'STICKER', Blockly.JavaScript.ORDER_NONE) || 'null';const size = Blockly.JavaScript.valueToCode(block, 'SIZE', Blockly.JavaScript.ORDER_NONE) || 'null';const rotation = Blockly.JavaScript.valueToCode(block, 'ROTATION', Blockly.JavaScript.ORDER_NONE) || 'null';return `ctx.stamp(${image}, ${size}, ${rotation});`;}}}]

Const stop

stop: HTMLTemplateElement = svg`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><g><path d="M6 6h12v12H6z"></path></g></svg>`

Const templateContent

templateContent: (Anonymous function) = directive((template: HTMLTemplateElement) => (part: Part) => {if (templateMap.get(part) === template) {return;}templateMap.set(part, template)const content = (template.cloneNode(true) as HTMLTemplateElement).content;part.setValue(content);part.commit();})

Const tick

tick: HTMLTemplateElement = svg`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" ><g><path d="M9 16.17L4.83 12l-1.42 1.41L9 19 21 7l-1.41-1.41z"></path></g></svg>`

Const trace

trace: log = logDecoratorFactory('TRACE')

Const warning

warning: HTMLTemplateElement = svg`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><g id="warning" transform="translate(5.500000, 0.000000)"><path d="M2.61428571,11.8036364 C3.13404856,11.7673648 3.64329609,11.9649512 4.00753956,12.3442142 C4.37178303,12.7234773 4.55439279,13.2462769 4.50714286,13.7745455 C4.54795493,14.2993508 4.35780279,14.8155155 3.98808005,15.1835326 C3.61835732,15.5515497 3.10723494,15.7334243 2.59285714,15.68 C2.07901925,15.7281865 1.57090708,15.5401176 1.20741569,15.1672029 C0.843924308,14.7942881 0.663068346,14.2755276 0.714285714,13.7527273 C0.6631724,13.2241461 0.846322205,12.699905 1.21380204,12.3229305 C1.58128187,11.9459559 2.09477522,11.7555545 2.61428571,11.8036364 L2.61428571,11.8036364 Z" id="Shape"></path><path d="M1.15,1.26545455 C1.56284514,0.8757266 2.11746672,0.680454566 2.67857143,0.727272727 C3.24476188,0.687824497 3.80142374,0.890811893 4.21428571,1.28727273 C4.51225594,1.62649322 4.65501962,2.07842877 4.60714286,2.53090909 L4.1,8.94545455 C4.09162508,9.32804259 3.92779838,9.68996264 3.64755827,9.94497253 C3.36731816,10.1999824 2.99576214,10.3252442 2.62142857,10.2909091 C2.25332722,10.3192009 1.8902603,10.1902808 1.61926851,9.93505579 C1.34827672,9.67983079 1.19379455,9.32131374 1.19285714,8.94545455 L0.714285714,2.48727273 C0.682262373,2.03544263 0.840718181,1.59110516 1.15,1.26545455 L1.15,1.26545455 Z" id="Shape"></path></g></svg>`

Functions

Const AppAPI

DrawAPI

  • DrawAPI(editor: Editor, removeBackground?: Boolean): object

  • Parameters

    • editor: Editor
    • Default value removeBackground: Boolean = false

    Returns object

Const FieldSoundsFactory

  • FieldSoundsFactory(Blockly: any): FieldSounds

  • Parameters

    • Blockly: any

    Returns FieldSounds

MouseAPI

  • Parameters

    Returns IPartAPI

NoBackgroundDrawAPI

  • NoBackgroundDrawAPI(editor: Editor): object

  • Parameters

    Returns object

SpeakerAPIFactory

  • Parameters

    Returns IPartAPI

StampAPI

  • StampAPI(editor: Editor): object

  • Parameters

    Returns object

StickerAPI

  • Parameters

    Returns IPartAPI

addFlashField

  • addFlashField(block: Block): void

  • Parameters

    • block: Block

    Returns void

aliasTagHandlerFactory

  • aliasTagHandlerFactory(queryEngine: QueryEngine, map: Map<string, string>): (Anonymous function)

  • Parameters

    Returns (Anonymous function)

Const base64

  • base64(strings: string[], values: any[]): string

  • Parameters

    • strings: string[]
    • Rest values: any[]

    Returns string

calculateFullTransform

  • calculateFullTransform(origin: object, angle: number, scale: number): any[]

  • Parameters

    • origin: object
    • angle: number
    • scale: number

    Returns any[]

calculateRotation

  • calculateRotation(origin: object, angle: number): any[]

  • Parameters

    • origin: object
    • angle: number

    Returns any[]

collectPrototype

  • collectPrototype<T>(key: string, base: any, limit: any): Map<string, T>

  • Type parameters

    • T

    Parameters

    • key: string
    • base: any
    • limit: any

    Returns Map<string, T>

component

  • Parameters

    Returns (Anonymous function)

createBriefing

  • Parameters

    Returns Briefing

createChallenge

createRemix

  • Parameters

    Returns Remix

debounce

  • debounce(func: Function, wait: number): Function

  • Parameters

    • func: Function
    • wait: number

    Returns Function

degreesToRadians

  • degreesToRadians(deg: number): number

  • Parameters

    • deg: number

    Returns number

deprecated

  • deprecated(message: string): (Anonymous function)

  • Parameters

    • message: string

    Returns (Anonymous function)

downloadFile

  • downloadFile(filename: string, contents: string): void

  • Parameters

    • filename: string
    • contents: string

    Returns void

extname

  • extname(p: string): null | string

  • Parameters

    • p: string

    Returns null | string

findFirstTreeDiff

  • findFirstTreeDiff(treeA: HTMLElement, treeB: HTMLElement): IDiffResult

  • Parameters

    • treeA: HTMLElement
    • treeB: HTMLElement

    Returns IDiffResult

findInSet

  • findInSet<T>(set: Set<T>, predicate: function): null | T

  • Type parameters

    • T

    Parameters

    • set: Set<T>
    • predicate: function
        • (value: T): boolean

        • Parameters

          • value: T

          Returns boolean

    Returns null | T

findStartNodes

  • findStartNodes(root: XMLDocument): HTMLElement[]

  • Parameters

    • root: XMLDocument

    Returns HTMLElement[]

getAncestor

  • getAncestor(target: Element, test: function): null | Element

  • Parameters

    • target: Element
    • test: function
        • (node: Element): boolean

        • Parameters

          • node: Element

          Returns boolean

    Returns null | Element

getHelpers

  • Parameters

    • id: string

    Returns undefined | ICreatorHelper[]

getSelectorForNode

  • getSelectorForNode(node: HTMLElement, limit: HTMLElement): string

  • Parameters

    • node: HTMLElement
    • limit: HTMLElement

    Returns string

getSourceEditor

  • getSourceEditor(id: string): undefined | SourceEditorConstructor

  • Parameters

    • id: string

    Returns undefined | SourceEditorConstructor

getStickerIdForLegacy

  • getStickerIdForLegacy(set: string, sticker: string): string

  • Parameters

    • set: string
    • sticker: string

    Returns string

highlight

  • highlight(src: string, language: string): function

  • Parameters

    • src: string
    • language: string

    Returns function

      • (part: Part): void

      • Parameters

        • part: Part

        Returns void

Const img

  • img(strings: string[], values: any[]): HTMLTemplateElement

  • Parameters

    • strings: string[]
    • Rest values: any[]

    Returns HTMLTemplateElement

join

  • join(a: string, b: string): string

  • Parameters

    • a: string
    • b: string

    Returns string

load

  • load(lang: string, opts?: ILoadOptions): Promise<IMessageDB[]>

  • Parameters

    • lang: string
    • Default value opts: ILoadOptions = { modulesPath: DEFAULT_MODULES_PATH }

    Returns Promise<IMessageDB[]>

loadBlocklyMsg

  • loadBlocklyMsg(url: string): Promise<IMessageDB>

  • Parameters

    • url: string

    Returns Promise<IMessageDB>

marked

  • marked(src: string): function

  • Parameters

    • src: string

    Returns function

      • (part: Part): void

      • Parameters

        • part: Part

        Returns void

memoize

  • memoize(target: any, key: string, descriptor: any): void

  • Parameters

    • target: any
    • key: string
    • descriptor: any

    Returns void

Const multiply

  • multiply(a: any, b: any): any[]

  • Parameters

    • a: any
    • b: any

    Returns any[]

nodeIsNonShadowStatementOrValue

  • nodeIsNonShadowStatementOrValue(node: Element): boolean

  • Parameters

    • node: Element

    Returns boolean

onDidCreateBlockType

  • onDidCreateBlockType(workspace: Workspace, type: string, cb: function): IDisposable

  • Parameters

    • workspace: Workspace
    • type: string
    • cb: function
        • (e: any): void

        • Parameters

          • e: any

          Returns void

    Returns IDisposable

onInstall

  • Type parameters

    • T

    Parameters

    Returns void

onTransformInstall

  • Parameters

    Returns void

parseXml

  • parseXml(src: string): Document

  • Parameters

    • src: string

    Returns Document

part

  • part(type: string): (Anonymous function)

  • Parameters

    • type: string

    Returns (Anonymous function)

property

  • property(propOptions: IPropertiesOptions): (Anonymous function)

  • Parameters

    • propOptions: IPropertiesOptions

    Returns (Anonymous function)

random

Const registerAnglePicker

  • registerAnglePicker(Blockly: Blockly): void

  • Parameters

    Returns void

registerBriefing

  • registerBriefing(id: string, briefing: Briefing): void

  • Parameters

    Returns void

registerChallengeEngine

  • registerChallengeEngine(id: string, engine: Engine): void

  • Parameters

    Returns void

registerCopyGenerator

  • registerCopyGenerator(sourceType: string, type: string, generator: ICopyGenerator): void

  • Parameters

    Returns void

registerCreator

  • registerCreator(id: string, creator: CreatorConstructor): void

  • Parameters

    • id: string
    • creator: CreatorConstructor

    Returns void

registerCreatorFieldHelper

  • registerCreatorFieldHelper<T>(fieldConstructor: any, helper: function): void

  • Type parameters

    • T: Field

    Parameters

    Returns void

registerCreatorHelper

  • Parameters

    Returns void

registerRemix

  • registerRemix(id: string, remix: Remix): void

  • Parameters

    • id: string
    • remix: Remix

    Returns void

Const registerRepeatDrawing

  • registerRepeatDrawing(Blockly: Blockly, defaultColor: string): void

  • Parameters

    • Blockly: Blockly
    • defaultColor: string

    Returns void

Const registerRepeatInCircle

  • registerRepeatInCircle(Blockly: Blockly, defaultColor: string): void

  • Parameters

    • Blockly: Blockly
    • defaultColor: string

    Returns void

registerSourceEditor

  • registerSourceEditor(id: string, sourceEditorClass: SourceEditorConstructor): IDisposable

  • Parameters

    • id: string
    • sourceEditorClass: SourceEditorConstructor

    Returns IDisposable

registerStepperFieldHelper

  • registerStepperFieldHelper<T>(fieldConstructor: any, helper: function): void

  • Type parameters

    • T: Field

    Parameters

    • fieldConstructor: any
    • helper: function
        • (field: T, value: string, workspace: Workspace): string

        • Parameters

          • field: T
          • value: string
          • workspace: Workspace

          Returns string

    Returns void

registerTypeSerializer

  • Parameters

    Returns void

registerUITagHandlers

  • registerUITagHandlers(editor: Editor): void

  • Parameters

    Returns void

resolveLegacyShadowTree

  • resolveLegacyShadowTree(value: string | object): undefined | string

  • Parameters

    • value: string | object

    Returns undefined | string

resolveShadowTree

  • resolveShadowTree(param: MetaParameter): undefined | null | string

  • Parameters

    Returns undefined | null | string

sanitizeVariable

  • sanitizeVariable(input: string): string

  • Parameters

    • input: string

    Returns string

setupFlash

  • setupFlash<T>(editor: Editor, id: string, emitter: EventEmitter<T>, method: string, shouldFlash: undefined | function): void

  • Type parameters

    • T

    Parameters

    • editor: Editor
    • id: string
    • emitter: EventEmitter<T>
    • method: string
    • Optional shouldFlash: undefined | function

    Returns void

stampChoice

Const svg

  • svg(strings: string[], values: any[]): HTMLTemplateElement

  • Parameters

    • strings: string[]
    • Rest values: any[]

    Returns HTMLTemplateElement

throttle

  • throttle(callback: Function, wait: number, immediate?: boolean): (Anonymous function)

  • Parameters

    • callback: Function
    • wait: number
    • Default value immediate: boolean = false

    Returns (Anonymous function)

transformBanner

  • transformBanner(data: any): any

  • Parameters

    • data: any

    Returns any

transformBlocklyValidation

  • transformBlocklyValidation(step: any, validation: any): void

  • Parameters

    • step: any
    • validation: any

    Returns void

transformChallenge

  • transformChallenge(data: any): void

  • Parameters

    • data: any

    Returns void

transformLegacy

  • transformLegacy(app: any): void

  • Parameters

    • app: any

    Returns void

transformLegacyApp

  • transformLegacyApp(app: any, output: Output): any

  • Parameters

    Returns any

transformLegacyButton

  • transformLegacyButton(app: any): void

  • Parameters

    • app: any

    Returns void

transformLegacyClock

  • transformLegacyClock(app: any): void

  • Parameters

    • app: any

    Returns void

transformLegacyCreation

  • transformLegacyCreation(data: any, output: Output): Promise<any>

  • Parameters

    Returns Promise<any>

transformLegacyDOMPart

  • transformLegacyDOMPart(type: string, app: any): void

  • Parameters

    • type: string
    • app: any

    Returns void

transformLegacyDataPart

  • transformLegacyDataPart(type: string, app: any): void

  • Parameters

    • type: string
    • app: any

    Returns void

transformLegacyLogic

  • transformLegacyLogic(app: any): void

  • Parameters

    • app: any

    Returns void

transformLegacyMicrophone

  • transformLegacyMicrophone(app: any): void

  • Parameters

    • app: any

    Returns void

transformLegacyMouse

  • transformLegacyMouse(app: any): void

  • Parameters

    • app: any

    Returns void

transformLegacyOscillator

  • transformLegacyOscillator(app: any): void

  • Parameters

    • app: any

    Returns void

transformLegacySlider

  • transformLegacySlider(app: any): void

  • Parameters

    • app: any

    Returns void

transformLegacySpeaker

  • transformLegacySpeaker(app: any): void

  • Parameters

    • app: any

    Returns void

transformLegacySticker

  • transformLegacySticker(app: any): void

  • Parameters

    • app: any

    Returns void

transformLegacySynth

  • transformLegacySynth(app: any): void

  • Parameters

    • app: any

    Returns void

transformLegacyTerminal

  • transformLegacyTerminal(app: any): void

  • Parameters

    • app: any

    Returns void

transformLegacyText

  • transformLegacyText(app: any): void

  • Parameters

    • app: any

    Returns void

transformLegacyTextInput

  • transformLegacyTextInput(app: any): void

  • Parameters

    • app: any

    Returns void

transformLegacyWeather

  • transformLegacyWeather(app: any): void

  • Parameters

    • app: any

    Returns void

transformStep

  • transformStep(step: any): void

  • Parameters

    • step: any

    Returns void

transformToolboxSelector

  • transformToolboxSelector(legacySelector: any): undefined | string

  • Parameters

    • legacySelector: any

    Returns undefined | string

transformTooltips

  • transformTooltips(step: any, tooltips: any[]): any[]

  • Parameters

    • step: any
    • tooltips: any[]

    Returns any[]

transformValidation

  • transformValidation(step: any, validation: any): void

  • Parameters

    • step: any
    • validation: any

    Returns void

walkUpstream

  • walkUpstream<T>(block: Block, cb: function): T | null

  • Type parameters

    • T

    Parameters

    • block: Block
    • cb: function
        • (block: Block): T | false

        • Parameters

          • block: Block

          Returns T | false

    Returns T | null

Object literals

Const BlocklyCreatorToolbox

BlocklyCreatorToolbox: object

color

color: string = "#676767"

name

name: string = "generator"

symbols

symbols: (object | object | object | object)[] = [{type: 'function',name: 'id',verbose: 'Challenge id',parameters: [{type: 'parameter',name: 'id',verbose: '',default: 'challenge-id',returnType: String,blockly: {field: true,},}],blockly: {javascript(Blockly : Blockly, block : Block) {const text = block.getFieldValue('ID');return `// @challenge-id: ${text}\n`;},},}, {type: 'function',name: 'name',verbose: 'Challenge name',parameters: [{type: 'parameter',name: 'name',verbose: '',default: 'Challenge Name',returnType: String,blockly: {field: true,},}],blockly: {javascript(Blockly : Blockly, block : Block) {const text = block.getFieldValue('NAME');return `// @challenge-name: ${text}\n`;},},}, {type: 'function',name: 'start',blockly: {javascript(Blockly : Blockly) {return '// @challenge-start\n';},},}, {type: 'function',name: 'banner',parameters: [{type: 'parameter',name: 'text',verbose: '',default: 'Banner content',returnType: String,blockly: {field: true,},}],blockly: {javascript(Blockly : Blockly, block : Block) {const bannerText = block.getFieldValue('TEXT');return `// @banner: ${bannerText}\n`;},},}, {type: 'function',name: 'challengeEnd',verbose: 'end of challenge',parameters: [{type: 'parameter',name: 'text',verbose: '',default: 'content',returnType: String,blockly: {field: true,},}],blockly: {javascript(Blockly : Blockly, block : Block) {const bannerText = block.getFieldValue('TEXT');return `// @end-of-challenge: ${bannerText}\n`;},},}, {type: 'function',name: 'step',verbose: 'custom step',blockly: {javascript() {return '// @step\n';},},}]

type

type: "module" = "module"

verbose

verbose: string = "Challenge"

Const ButtonAPI

ButtonAPI: object

color

color: string = "#00c7b6"

icon

icon: HTMLTemplateElement = button

inlineDisplay

inlineDisplay: TransformInlineDisplay = TransformInlineDisplay

label

label: string = _('PART_BUTTON_LABEL', 'Button')

symbols

symbols: IMetaDefinition[] = [{type: 'variable',name: 'label',verbose: _('BUTTON_LABEL', 'label'),setter: true,returnType: String,default: _('BUTTON_LABEL_DEFAULT_VALUE', 'Click Me!'),}, {type: 'variable',name: 'background',verbose: _('PART_BUTTON_BACKGROUND', 'background'),returnType: 'Color',default: '#FF8F00',setter: true,}, {type: 'variable',name: 'color',verbose: _('PART_BUTTON_COLOR', 'color'),returnType: 'Color',default: '#FFFFFF',setter: true,}, ...TransformAPI]

type

type: string = ButtonPart.type

onInstall

  • Parameters

    Returns void

Const ClockAPI

ClockAPI: object

color

color: string = "#9b61bd"

icon

icon: HTMLTemplateElement = clock

inlineDisplay

inlineDisplay: ClockInlineDisplay = ClockInlineDisplay

label

label: string = _('PART_CLOCK_LABEL', 'Clock')

symbols

symbols: (object | object)[] = [{type: 'function',name: 'getCurrent',verbose: _('PART_CLOCK_CURRENT', 'current'),returnType: Number,parameters: [{type: 'parameter',name: 'key',verbose: '',returnType: 'Enum',enum: [[_('PART_CLOCK_YEAR', 'Year'),'year',],[_('PART_CLOCK_MONTH', 'Month'),'month',],[_('PART_CLOCK_DAY', 'Day'),'day',],[_('PART_CLOCK_HOUR', 'Hour'),'hour',],[_('PART_CLOCK_MINUTE', 'Minute'),'minute',],[_('PART_CLOCK_SECONDS', 'Seconds'),'seconds',],[_('PART_CLOCK_MILLISECONDS', 'Milliseconds'),'milliseconds',],]}],}, {type: 'function',name: 'get',verbose: _('PART_CLOCK_CURRENT', 'current'),returnType: String,parameters: [{type: 'parameter',name: 'key',verbose: '',returnType: 'Enum',enum: [[_('PART_CLOCK_DATE', 'Date'),'date',],[_('PART_CLOCK_TIME', 'Time'),'time',],]}],}]

type

type: string = ClockPart.type

Const ColorAPI

ColorAPI: object

id

id: string = ID

name

name: string = ID

type

type: string = "blockly"

typeScriptDefinition

typeScriptDefinition: string = `const color = {random() : string;create(type : 'rgb', r : number, g : number, b : number) : string;create(type : 'hsv', h : number, s : number, v : number) : string;lerp(from : number, to : number, percent : number) : string;};`

register

  • Parameters

    Returns void

category

category: object

blocks

blocks: (string | object)[] = ['colour_picker','create_color','random_colour',{id: 'color_lerp',defaults: ['FROM', 'TO', 'PERCENT'],},]

colour

colour: string = COLOR

id

id: string = ID

name

name:

defaults

defaults: object

color_lerp

color_lerp: object

FROM

FROM: string = "#000000"

PERCENT

PERCENT: number = 50

TO

TO: string = "#ffffff"

colour_picker

colour_picker: object

COLOUR

COLOUR: string = "#ff0000"

create_color

create_color: object

1

1: number = 0

2

2: number = 0

3

3: number = 0

TYPE

TYPE: string = "rgb"

labels

labels: object

create_color

create_color: object

TYPE

TYPE: string[][] = colorFormats

Const ControlAPI

ControlAPI: object

id

id: string = ID

name

name: string = ID

type

type: string = "blockly"

typeScriptDefinition

typeScriptDefinition: string = `const loop = {forever(callback : function) : void;};const time = {every(interval : number, unit : 'seconds'|'milliseconds'|'frames', callback : function) : void;later(delay : number, unit : 'seconds'|'milliseconds'|'frames', callback : function) : void;};`

register

  • Parameters

    Returns void

category

category: object

blocks

blocks: (string | object)[] = [{id: 'repeat_x_times',defaults: ['N'],},'loop_forever',{id: 'every_x_seconds',defaults: ['INTERVAL'],},{id: 'in_x_time',defaults: ['DELAY'],},'restart_code',]

colour

colour: string = COLOR

id

id: string = ID

name

name:

defaults

defaults: object

every_x_seconds

every_x_seconds: object

INTERVAL

INTERVAL: number = 1

UNIT

UNIT: string = "seconds"

in_x_time

in_x_time: object

DELAY

DELAY: number = 1

UNIT

UNIT: string = "seconds"

repeat_x_times

repeat_x_times: object

N

N: number = 10

labels

labels: object

every_x_seconds

every_x_seconds: object

UNIT

UNIT: string[][] = everyUnits

in_x_time

in_x_time: object

UNIT

UNIT: string[][] = inTimeUnits

Const LegacyUtil

LegacyUtil: object

addPartBlocks

  • addPartBlocks(partData: any, root: HTMLElement): HTMLElement

  • Parameters

    • partData: any
    • root: HTMLElement

    Returns HTMLElement

forEachPart

  • forEachPart(app: any, type: string, callback: function): void

  • Parameters

    • app: any
    • type: string
    • callback: function
        • (part: any): void

        • Parameters

          • part: any

          Returns void

    Returns void

getDOM

  • getDOM(source: string): undefined | HTMLElement

  • Parameters

    • source: string

    Returns undefined | HTMLElement

renameElement

  • renameElement(block: HTMLElement, tag: string, name: string, newName: string): void

  • Parameters

    • block: HTMLElement
    • tag: string
    • name: string
    • newName: string

    Returns void

renameStatement

  • renameStatement(block: HTMLElement, name: string, newName: string): void

  • Parameters

    • block: HTMLElement
    • name: string
    • newName: string

    Returns void

renameValue

  • renameValue(block: HTMLElement, name: string, newName: string): void

  • Parameters

    • block: HTMLElement
    • name: string
    • newName: string

    Returns void

transformBlock

  • transformBlock(root: HTMLElement, selector: string, mutator: function): void

  • Parameters

    • root: HTMLElement
    • selector: string
    • mutator: function
        • (block: HTMLElement): void

        • Parameters

          • block: HTMLElement

          Returns void

    Returns void

transformEventBlock

  • transformEventBlock(root: HTMLElement, event: string, type: string, statement: string): void

  • Parameters

    • root: HTMLElement
    • event: string
    • type: string
    • statement: string

    Returns void

transformField

  • transformField(block: HTMLElement, name: string, mutator: function): void

  • Parameters

    • block: HTMLElement
    • name: string
    • mutator: function
        • (name: string, content: string | null): object

        • Parameters

          • name: string
          • content: string | null

          Returns object

    Returns void

Const ListsAPI

ListsAPI: object

id

id: string = ID

name

name: string = ID

type

type: string = "blockly"

register

  • Parameters

    Returns void

category

category: object

blocks

blocks: string[] = CORE_BLOCKS

colour

colour: string = COLOR

id

id: string = ID

name

name:

defaults

defaults: object

lists_getIndex

lists_getIndex: object

MODE

MODE: string = "GET"

WHERE

WHERE: string = "FROM_START"

lists_indexOf

lists_indexOf: object

END

END: string = "FIRST"

lists_setIndex

lists_setIndex: object

MODE

MODE: string = "SET"

WHERE

WHERE: string = "FROM_START"

labels

labels: object

lists_getIndex

lists_getIndex: object

MODE

MODE: string[][] = [[Blockly.Msg.LISTS_GET_INDEX_GET, "GET"], [Blockly.Msg.LISTS_GET_INDEX_GET_REMOVE, "GET_REMOVE"], [Blockly.Msg.LISTS_GET_INDEX_REMOVE, "REMOVE"]]

WHERE

WHERE: string[][] = [[Blockly.Msg.LISTS_GET_INDEX_FROM_START, "FROM_START"], [Blockly.Msg.LISTS_GET_INDEX_FROM_END, "FROM_END"], [Blockly.Msg.LISTS_GET_INDEX_FIRST, "FIRST"], [Blockly.Msg.LISTS_GET_INDEX_LAST, "LAST"], [Blockly.Msg.LISTS_GET_INDEX_RANDOM, "RANDOM"]]

lists_indexOf

lists_indexOf: object

END

END: string[][] = [[Blockly.Msg.LISTS_INDEX_OF_FIRST, "FIRST"], [Blockly.Msg.LISTS_INDEX_OF_LAST, "LAST"]]

lists_setIndex

lists_setIndex: object

MODE

MODE: string[][] = [[Blockly.Msg.LISTS_SET_INDEX_SET, "SET"], [Blockly.Msg.LISTS_SET_INDEX_INSERT, "INSERT"]]

WHERE

WHERE: string[][] = [[Blockly.Msg.LISTS_GET_INDEX_FROM_START, "FROM_START"], [Blockly.Msg.LISTS_GET_INDEX_FROM_END, "FROM_END"], [Blockly.Msg.LISTS_GET_INDEX_FIRST, "FIRST"], [Blockly.Msg.LISTS_GET_INDEX_LAST, "LAST"], [Blockly.Msg.LISTS_GET_INDEX_RANDOM, "RANDOM"]]

Const LogicAPI

LogicAPI: object

id

id: string = ID

name

name: string = ID

type

type: string = "blockly"

register

  • Parameters

    Returns void

category

category: object

blocks

blocks: string[] = ['controls_if','controls_if_else_custom','logic_compare','logic_operation','logic_negate','logic_boolean',]

colour

colour: string = COLOR

id

id: string = ID

name

name:

defaults

defaults: object

logic_boolean

logic_boolean: object

BOOL

BOOL: string = "TRUE"

logic_compare

logic_compare: object

OP

OP: string = "EQ"

logic_operation

logic_operation: object

OP

OP: string = "AND"

labels

labels: object

logic_boolean

logic_boolean: object

BOOL

BOOL: string[][] = [['true', 'TRUE'], ['false', 'FALSE']]

logic_compare

logic_compare: object

OP

OP: string[][] = Object.keys(compareOptions).map((value) => [compareOptions[value], value])

logic_operation

logic_operation: object

OP

OP: string[][] = [['and', 'AND'], ['or', 'OR']]

Const MathAPI

MathAPI: object

id

id: string = MathModule.id

name

name: string = MathModule.id

type

type: string = "blockly"

typeScriptDefinition

typeScriptDefinition: string = `declare namespace math {declare function random(min: number, max: number): number;declare function lerp(from: number, to: number, percent: number): number;}`

register

  • Parameters

    Returns void

category

category: object

blocks

blocks: (string | object)[] = ['math_number','math_arithmetic',{id: 'unary',defaults: ['RIGHT_HAND'],}, {id: 'math_random',defaults: ['MIN', 'MAX'],}, {id: 'math_lerp',defaults: ['FROM', 'TO', 'PERCENT'],}, {id: 'math_trig',defaults: ['SIN'],},'math_single','math_constant','math_number_property','math_round','math_modulo','math_constrain','math_min_max','math_sign',]

colour

colour: string = COLOR

id

id: string = MathModule.id

name

name:

defaults

defaults: object

math_arithmetic

math_arithmetic: object

A

A: number = 0

B

B: number = 0

OP

OP: string = "ADD"

math_constant

math_constant: object

CONSTANT

CONSTANT: string = "PI"

math_constrain

math_constrain: object

HIGH

HIGH: number = 0

LOW

LOW: number = 0

VALUE

VALUE: number = 0

math_lerp

math_lerp: object

FROM

FROM: number = 0

PERCENT

PERCENT: number = 50

TO

TO: number = 200

math_min_max

math_min_max: object

ARG1

ARG1: number = 0

ARG2

ARG2: number = 0

MINMAX

MINMAX: string = "min"

math_modulo

math_modulo: object

DIVIDEND

DIVIDEND: number = 0

DIVISOR

DIVISOR: number = 0

math_number

math_number: object

NUM

NUM: string = "0"

math_number_property

math_number_property: object

NUMBER_TO_CHECK

NUMBER_TO_CHECK: number = 0

PROPERTY

PROPERTY: string = "EVEN"

math_random

math_random: object

MAX

MAX: number = 10

MIN

MIN: number = 0

TYPE

TYPE: string = "integer"

math_round

math_round: object

OP

OP: string = "ROUND"

math_sign

math_sign: object

ARG

ARG: number = 0

math_single

math_single: object

OP

OP: string = "ROOT"

math_trig

math_trig: object

OP

OP: string = "SIN"

unary

unary: object

LEFT_HAND

LEFT_HAND: string = "item"

OPERATOR

OPERATOR: string = "+="

RIGHT_HAND

RIGHT_HAND: number = 1

labels

labels: object

math_arithmetic

math_arithmetic: object

OP

OP: string[][] = Object.keys(arithmeticOptions).map(value => [utils.replaceMessageReferences(arithmeticOptions[value]), value])

math_constant

math_constant: object

CONSTANT

CONSTANT: string[][] = [["\u03c0", "PI"], ["e", "E"], ["\u03c6", "GOLDEN_RATIO"], ["sqrt(2)", "SQRT2"], ["sqrt(\u00bd)", "SQRT1_2"], ["\u221e", "INFINITY"]]

math_min_max

math_min_max: object

MINMAX

MINMAX: string[][] = minMaxOptions

math_number_property

math_number_property: object

PROPERTY

PROPERTY: string[][] = processBlocklyMessages([["%{BKY_MATH_IS_EVEN}", "EVEN"], ["%{BKY_MATH_IS_ODD}", "ODD"], ["%{BKY_MATH_IS_PRIME}", "PRIME"], ["%{BKY_MATH_IS_WHOLE}", "WHOLE"], ["%{BKY_MATH_IS_POSITIVE}", "POSITIVE"], ["%{BKY_MATH_IS_NEGATIVE}", "NEGATIVE"], ["%{BKY_MATH_IS_DIVISIBLE_BY}", "DIVISIBLE_BY"]])

math_round

math_round: object

OP

OP: string[][] = processBlocklyMessages([["%{BKY_MATH_ROUND_OPERATOR_ROUND}", "ROUND"], ["%{BKY_MATH_ROUND_OPERATOR_ROUNDUP}", "ROUNDUP"], ["%{BKY_MATH_ROUND_OPERATOR_ROUNDDOWN}", "ROUNDDOWN"]])

math_single

math_single: object

OP

OP: string[][] = processBlocklyMessages([["%{BKY_MATH_SINGLE_OP_ROOT}", "ROOT"], ["%{BKY_MATH_SINGLE_OP_ABSOLUTE}", "ABS"], ["-", "NEG"], ["ln", "LN"], ["log10", "LOG10"], ["e^", "EXP"], ["10^", "POW10"]])

math_trig

math_trig: object

OP

OP: string[][] = [['sin', 'SIN'],['cos', 'COS'],['tan', 'TAN'],['asin', 'ASIN'],['acos', 'ACOS'],['atan', 'ATAN'],]

math_unary

math_unary: object

OPERATOR

OPERATOR: string[][] = unaryOptions

Const MicrophoneAPI

MicrophoneAPI: object

color

color: string = "#ef5284"

icon

icon: HTMLTemplateElement = microphone

inlineDisplay

inlineDisplay: MicrophoneInlineDisplay = MicrophoneInlineDisplay

label

label: string = _('PART_MIC_LABEL', 'Microphone')

symbols

symbols: (object | object)[] = [{type: 'variable',name: 'volume',verbose: _('PART_MIC_VOLUME', 'volume'),returnType: Number,default: 0,}, {type: 'variable',name: 'pitch',verbose: _('PART_MIC_PITCH', 'pitch'),returnType: Number,default: 0,}, {type: 'function',name: 'onEdge',verbose: _('PART_MIC_ON_EDGE', 'when volume goes'),parameters: [{type: 'parameter',name: 'type',verbose: '',returnType: 'Enum',enum: [[_('PART_MIC_OVER', 'over'), 'rising'],[_('PART_MIC_UNDER', 'under'), 'falling'],],}, {type: 'parameter',name: 'value',verbose: '',returnType: Number,default: 70,}, {type: 'parameter',name: 'callback',verbose: '',returnType: Function,}],blockly: {postProcess(block : any) {block.setInputsInline(true);block.setPreviousStatement(false);block.setNextStatement(false);},},}]

type

type: string = MicrophonePart.type

Const OscillatorAPI

OscillatorAPI: object

color

color: string = "#00c7b6"

icon

icon: HTMLTemplateElement = oscillator

inlineDisplay

inlineDisplay: OscillatorInlineDisplay = OscillatorInlineDisplay

label

label: string = _('PART_OSC_LABEL', 'Osc')

symbols

symbols: (object | object | object)[] = [{type: 'variable',name: 'value',verbose: _('PART_OSC_VALUE', 'value'),returnType: Number,}, {type: 'variable',name: 'speed',verbose: _('PART_OSC_SPEED', 'speed'),returnType: Number,default: 50,setter: true,}, {type: 'variable',name: 'delay',verbose: _('PART_OSC_DELAY', 'delay'),returnType: Number,default: 50,setter: true,}, {type: 'variable',name: 'wave',verbose: _('PART_OSC_WAVE', 'wave'),returnType: 'Enum',enum: [[_('PART_OSC_SINE', 'sine'), 'sine'],[_('PART_OSC_SQUARE', 'square'), 'square'],[_('PART_OSC_SAWTOOTH', 'sawtooth'), 'sawtooth'],[_('PART_OSC_TRIANGLE', 'triangle'), 'triangle'],],getter: false,setter: true,}]

type

type: string = OscillatorPart.type

Const OutputConfig

OutputConfig: object

get

  • get<T>(key: string, fallback: T): T

  • Type parameters

    • T

    Parameters

    • key: string
    • fallback: T

    Returns T

Const Palette

Palette: object

aliceblue

aliceblue: string = "#F0F8FF"

antiquewhite

antiquewhite: string = "#FAEBD7"

aqua

aqua: string = "#29c4eb"

aquamarine

aquamarine: string = "#4ef6b7"

azure

azure: string = "#F0FFFF"

beige

beige: string = "#E5DFBD"

bisque

bisque: string = "#FFE4C4"

black

black: string = "#000000"

blanchedalmond

blanchedalmond: string = "#FFEBCD"

blue

blue: string = "#1b9be2"

blueviolet

blueviolet: string = "#955CC9"

brown

brown: string = "#A36A42"

burlywood

burlywood: string = "#DEB887"

cadetblue

cadetblue: string = "#5F9EA0"

charcoal

charcoal: string = "#333333"

chartreuse

chartreuse: string = "#7FFF00"

chocolate

chocolate: string = "#D2691E"

coral

coral: string = "#FF7F50"

cornflowerblue

cornflowerblue: string = "#6495ED"

cornsilk

cornsilk: string = "#FFF8DC"

crimson

crimson: string = "#DC143C"

cyan

cyan: string = "#0FDDFC"

darkblue

darkblue: string = "#165f88"

darkbrown

darkbrown: string = "#5E4323"

darkcyan

darkcyan: string = "#33A7B8"

darkergray

darkergray: string = "#333333"

darkgoldenrod

darkgoldenrod: string = "#B8860B"

darkgray

darkgray: string = "#A9A9A9"

darkgreen

darkgreen: string = "#566b3f"

darkkhaki

darkkhaki: string = "#BCB585"

darkmagenta

darkmagenta: string = "#A32E86"

darkolivegreen

darkolivegreen: string = "#556B2F"

darkorange

darkorange: string = "#FF8C00"

darkorchid

darkorchid: string = "#9932CC"

darkpurple

darkpurple: string = "#593570"

darkred

darkred: string = "#9A4544"

darksalmon

darksalmon: string = "#E9967A"

darkseagreen

darkseagreen: string = "#8FBC8F"

darkslateblue

darkslateblue: string = "#483D8B"

darkslategray

darkslategray: string = "#2F4F4F"

darkturquoise

darkturquoise: string = "#00CED1"

darkviolet

darkviolet: string = "#9400D3"

deeppink

deeppink: string = "#FF1493"

deepskyblue

deepskyblue: string = "#00BFFF"

dimgray

dimgray: string = "#696969"

dodgerblue

dodgerblue: string = "#1E90FF"

firebrick

firebrick: string = "#B22222"

floralwhite

floralwhite: string = "#FFFAF0"

forestgreen

forestgreen: string = "#228B22"

fuchsia

fuchsia: string = "#FF00FF"

gainsboro

gainsboro: string = "#DCDCDC"

ghostwhite

ghostwhite: string = "#F8F8FF"

gold

gold: string = "#FFD700"

goldenrod

goldenrod: string = "#DAA520"

gray

gray: string = "#808080"

green

green: string = "#9BCE64"

greenyellow

greenyellow: string = "#ADFF2F"

honeydew

honeydew: string = "#F0FFF0"

hotpink

hotpink: string = "#FF69B4"

indianred

indianred: string = "#CD5C5C"

indigo

indigo: string = "#4B0082"

ivory

ivory: string = "#FFFFF0"

khaki

khaki: string = "#F0E68C"

lavender

lavender: string = "#E6E6FA"

lavenderblush

lavenderblush: string = "#FFF0F5"

lawngreen

lawngreen: string = "#7CFC00"

lemonchiffon

lemonchiffon: string = "#FFFACD"

lightblue

lightblue: string = "#4cfdf3"

lightbrown

lightbrown: string = "#e49d6b"

lightcoral

lightcoral: string = "#F08080"

lightcyan

lightcyan: string = "#E0FFFF"

lightgoldenrodyellow

lightgoldenrodyellow: string = "#FAFAD2"

lightgray

lightgray: string = "#D3D3D3"

lightgreen

lightgreen: string = "#90EE90"

lightpink

lightpink: string = "#FFB6C1"

lightsalmon

lightsalmon: string = "#FFA07A"

lightseagreen

lightseagreen: string = "#20B2AA"

lightskyblue

lightskyblue: string = "#87CEFA"

lightslategray

lightslategray: string = "#778899"

lightsteelblue

lightsteelblue: string = "#B0C4DE"

lightyellow

lightyellow: string = "#FFFFE0"

lime

lime: string = "#B3F55E"

limegreen

limegreen: string = "#32CD32"

linen

linen: string = "#FAF0E6"

magenta

magenta: string = "#EF3AC7"

maroon

maroon: string = "#800000"

mediumaquamarine

mediumaquamarine: string = "#66CDAA"

mediumblue

mediumblue: string = "#0000CD"

mediumorchid

mediumorchid: string = "#BA55D3"

mediumpurple

mediumpurple: string = "#9370DB"

mediumseagreen

mediumseagreen: string = "#3CB371"

mediumslateblue

mediumslateblue: string = "#7B68EE"

mediumspringgreen

mediumspringgreen: string = "#00FA9A"

mediumturquoise

mediumturquoise: string = "#48D1CC"

mediumvioletred

mediumvioletred: string = "#C71585"

midnightblue

midnightblue: string = "#191970"

mintcream

mintcream: string = "#F5FFFA"

mistyrose

mistyrose: string = "#FFE4E1"

moccasin

moccasin: string = "#FFE4B5"

navajowhite

navajowhite: string = "#FFDEAD"

navy

navy: string = "#000080"

oldlace

oldlace: string = "#FDF5E6"

olive

olive: string = "#808000"

olivedrab

olivedrab: string = "#6B8E23"

orange

orange: string = "#FF842A"

orangered

orangered: string = "#FF4500"

orchid

orchid: string = "#DA70D6"

palegoldenrod

palegoldenrod: string = "#EEE8AA"

palegreen

palegreen: string = "#98FB98"

paleturquoise

paleturquoise: string = "#AFEEEE"

palevioletred

palevioletred: string = "#DB7093"

papayawhip

papayawhip: string = "#FFEFD5"

peachpuff

peachpuff: string = "#FFDAB9"

peru

peru: string = "#CD853F"

pink

pink: string = "#F8C9B9"

plum

plum: string = "#BB99BB"

powderblue

powderblue: string = "#B0E0E6"

purple

purple: string = "#9F5FAD"

rebeccapurple

rebeccapurple: string = "#663399"

red

red: string = "#E95C5A"

rosybrown

rosybrown: string = "#BC8F8F"

royalblue

royalblue: string = "#4169E1"

saddlebrown

saddlebrown: string = "#8B4513"

salmon

salmon: string = "#ED8E74"

sandybrown

sandybrown: string = "#F4A460"

seagreen

seagreen: string = "#2E8B57"

seashell

seashell: string = "#FFF5EE"

sienna

sienna: string = "#A0522D"

silver

silver: string = "#C0C0C0"

skyblue

skyblue: string = "#87CEEB"

slateblue

slateblue: string = "#6A5ACD"

slategray

slategray: string = "#708090"

snow

snow: string = "#FFFAFA"

springgreen

springgreen: string = "#00FF7F"

steelblue

steelblue: string = "#4682B4"

tan

tan: string = "#D2B48C"

teal

teal: string = "#008080"

thistle

thistle: string = "#D8BFD8"

tomato

tomato: string = "#FF6347"

turquoise

turquoise: string = "#40E0D0"

violet

violet: string = "#EE82EE"

wheat

wheat: string = "#F5DEB3"

white

white: string = "#FFFFFF"

whitesmoke

whitesmoke: string = "#F5F5F5"

yellow

yellow: string = "#ffd839"

yellowgreen

yellowgreen: string = "#9ACD32"

Const SequencerAPI

SequencerAPI: object

color

color: string = "#ef5284"

icon

icon: HTMLTemplateElement

inlineDisplay

inlineDisplay: SequencerInlineDisplay = SequencerInlineDisplay

label

label: string = _('PART_SEQ_LABEL', 'Sequencer')

symbols

symbols: (object | object | object)[] = [{type: 'function',name: 'createSteps',verbose: '',parameters: [{type: 'parameter',name: 'sequence',verbose: '',blockly: {customField() {return new FieldSequence(8);},},}, {type: 'function',name: 'callback',verbose: '',returnType: Function,parameters: [{type: 'parameter',name: 'time',returnType: Number,blockly: {scope: WebAudioTimestamp,},}],}],blockly: {postProcess(block : Block) {// Remove top and bottom pegsblock.setPreviousStatement(false);block.setNextStatement(false);// Define mutation data. This will persist and reload the steps data(block as any).mutationToDom = function() {const container = document.createElement('mutation');const field = this.getField('SEQUENCE');const data = field._steps.map((isOn : boolean) => isOn ? '1' : '0').join('')container.setAttribute('steps', data);return container;};(block as any).domToMutation = function (container : SVGElement) {const data = container.getAttribute('steps');if (!data) {return;}const field = this.getField('SEQUENCE') as FieldSequence;const config = data.split('').map(item => item === '1');field.setSteps(config);};// Add the config fieldconst input = block.getInput('SEQUENCE');if (!input) {return;}const configField = new FieldSequenceConfig('Sequencer', 8);input.insertFieldAt(0, configField, 'CONFIG');},javascript(Blockly : Blockly, block : Block, m : Meta) {const method = m.getNameChain('.');const statement = Blockly.JavaScript.statementToCode(block, 'CALLBACK');const sequenceField = block.getField('SEQUENCE') as FieldSequence;const steps = sequenceField.getSteps().map(enabled => enabled ? 1 : 0);return `var steps = ${method}('${sequenceField.__id}', [${steps.join(', ')}]);\nsteps.onHit(function (time) {\n${statement}\n});\n`;},},}, {type: 'variable',name: 'bpm',verbose: _('PART_SEQ_BPM', 'bpm'),setter: true,returnType: Number,default: 120,}, {type: 'function',name: 'start',verbose: _('PART_SEQ_START', 'start'),}, {type: 'function',name: 'stop',verbose: _('PART_SEQ_STOP', 'stop'),}, {type: 'function',name: 'shuffle',verbose: _('PART_SEQ_SHUFFLE', 'shuffle'),}]

type

type: string = SequencerPart.type

onInstall

  • Parameters

    Returns void

Const SliderAPI

SliderAPI: object

color

color: string = "#00c7b6"

icon

icon: HTMLTemplateElement = slider

inlineDisplay

inlineDisplay: SliderInlineDisplay = SliderInlineDisplay

label

label: string = _('PART_SLIDER_NAME', 'Slider')

symbols

symbols: IMetaDefinition[] = [{type: 'variable',name: 'value',verbose: _('PART_SLIDER_VALUE', 'value'),returnType: Number,default: 0,setter: true,}, {type: 'function',name: 'onChange',verbose: _('PART_SLIDER_ON_CHANGE', 'on change'),parameters: [{type: 'parameter',name: 'callback',verbose: '',returnType: Function,}],blockly: {postProcess(block : Block) {addFlashField(block);block.setPreviousStatement(false);block.setNextStatement(false);},},}, ...TransformAPI]

type

type: string = SliderPart.type

onInstall

  • Parameters

    Returns void

Const SynthAPI

SynthAPI: object

color

color: string = "#ef5284"

icon

icon: HTMLTemplateElement

label

label: string = _('PART_SYNTH_LABEL', 'Synth')

symbols

symbols: (object | object | object | object)[] = [{type: 'variable',name: 'volume',verbose: _('PART_SYNTH_VOLUME', 'volume'),setter: true,getter: false,returnType: Number,default: 100,}, {type: 'function',name: 'playFrequency',verbose: _('PART_SYNTH_PLAY', 'play'),parameters: [{type: 'parameter',name: 'pitch',verbose: _('PART_SYNTH_PITCH', 'pitch'),returnType: Number,default: 25,}, {type: 'parameter',name: 'for',verbose: _('PART_SYNTH_FOR', 'for'),returnType: Number,default: 200,}],}, {type: 'function',name: 'start',verbose: _('PART_SYNTH_START', 'start'),}, {type: 'function',name: 'stop',verbose: _('PART_SYNTH_STOP', 'stop'),}, {type: 'variable',name: 'pitch',verbose: _('PART_SYNTH_PITCH', 'pitch'),setter: true,getter: false,returnType: Number,default: 25,}, {type: 'variable',name: 'wave',verbose: _('PART_SYNTH_WAVE', 'wave'),setter: true,getter: false,returnType: 'Enum',enum: [[_('PART_SYNTH_SINE', 'sine'), 'sine'],[_('PART_SYNTH_SQUARE', 'square'), 'square'],[_('PART_SYNTH_SAWTOOTH', 'sawtooth'), 'sawtooth'],[_('PART_SYNTH_TRIANGLE', 'triangle'), 'triangle'],],}]

type

type: string = SynthPart.type

Const TerminalAPI

TerminalAPI: object

color

color: string = "#00c7b6"

icon

icon: HTMLTemplateElement = terminal

label

label: string = _('PART_TERMINAL_LABEL', 'Terminal')

symbols

symbols: (object | object | object)[] = [{type: 'variable',name: 'visible',verbose: _('PART_TERMINAL_VISIBLE', 'visible'),returnType: 'Enum',enum: [[_('PART_TERMINAL_SHOW', 'show'), 'true'],[_('PART_TERMINAL_HIDE', 'hide'), 'false'],],default: true,setter: true,getter: false,}, {type: 'function',name: 'printLine',verbose: _('PART_TERMINAL_PRINT', 'print'),parameters: [{type: 'parameter',name: 'line',verbose: _('PART_TERMINAL_LINE', 'line'),returnType: String,default: '',}],}, {type: 'function',name: 'print',verbose: _('PART_TERMINAL_PRINT', 'print'),parameters: [{type: 'parameter',name: 'line',verbose: '',returnType: String,default: '',}],}, {type: 'function',name: 'clear',verbose: _('PART_TERMINAL_CLEAR', 'clear'),}]

type

type: string = TerminalPart.type

Const TexAPI

TexAPI: object

color

color: string = "#00c7b6"

icon

icon: HTMLTemplateElement = text

label

label: string = _('PART_TEXT_LABEL', 'Text')

symbols

symbols: IMetaDefinition[] = [{type: 'variable',name: 'value',verbose: _('PART_TEXT_VALUE', 'value'),setter: true,returnType: String,default: 'Text',}, {type: 'variable',name: 'color',verbose: _('PART_TEXT_COLOR', 'color'),setter: true,getter: false,returnType: 'Color',default: '#000000',}, {type: 'variable',name: 'font',verbose: _('PART_TEXT_FONT', 'font'),setter: true,getter: false,returnType: 'Enum',enum: [[_('PART_TEXT_Bariol', 'Bariol'),'bariol',],[_('PART_TEXT_ARIAL', 'Arial'),'arial',],[_('PART_TEXT_TIMES', 'Times'),'times',],[_('PART_TEXT_HELVETICA', 'Helvetica'),'helvetica',],[_('PART_TEXT_VERDANA', 'Verdana'),'verdana',],[_('PART_TEXT_OPTIMA', 'Optima'),'optima',],[_('PART_TEXT_CAMBRIA', 'Cambria'),'cambria',],[_('PART_TEXT_GARAMOND', 'Garamond'),'garamond',],[_('PART_TEXT_MONACO', 'Monaco'),'monaco',],[_('PART_TEXT_DIDOT', 'Didot'),'didot',],[_('PART_TEXT_BRUSH', 'Brush Script MT'),'brush script mt',],]}, ...TransformAPI]

type

type: string = TextPart.type

onInstall

  • Parameters

    Returns void

Const TextInputAPI

TextInputAPI: object

color

color: string = "#00c7b6"

icon

icon: HTMLTemplateElement = textInput

inlineDisplay

inlineDisplay: TextInputInlineDisplay = TextInputInlineDisplay

label

label: string = _('PART_TEXTINPUT_LABEL', 'Text Input')

symbols

symbols: IMetaDefinition[] = [{type: 'variable',name: 'value',verbose: _('PART_TEXTINPUT_VALUE', 'value'),setter: true,returnType: String,default: '',}, {type: 'variable',name: 'placeholder',verbose: _('PART_TEXTINPUT_PLACEHOLDER', 'placeholder'),setter: true,returnType: String,default: '',}, {type: 'function',name: 'onChange',verbose: _('PART_TEXTINPUT_ON_CHANGE', 'on'),parameters: [{type: 'parameter',name: 'callback',returnType: Function,}],blockly: {postProcess(block : Block) {addFlashField(block);block.setPreviousStatement(false);block.setNextStatement(false);},},}, ...TransformAPI]

type

type: string = TextInputPart.type

onInstall

  • Parameters

    Returns void

Const ToolbarEntryPosition

ToolbarEntryPosition: object

LEFT

LEFT: number = 0

RIGHT

RIGHT: number = 1

Const TouchAPI

TouchAPI: object

color

color: string = "#ef5284"

icon

icon: HTMLTemplateElement = touch

label

label: string = _('PART_TOUCH_LABEL', 'Touch')

symbols

symbols: (object | object | object)[] = [{type: 'function',name: 'onTouchStart',verbose: _('PART_TOUCH_ON_TOUCH', 'on touch'),parameters: [{type: 'parameter',name: 'callback',verbose: '',returnType: Function,}],blockly: {postProcess(block : Block) {block.setNextStatement(false);block.setPreviousStatement(false);addFlashField(block);},},}, {type: 'function',name: 'onTouchEnd',verbose: _('PART_TOUCH_ON_RELEASE', 'on release'),parameters: [{type: 'parameter',name: 'callback',verbose: '',returnType: Function,}],blockly: {postProcess(block : Block) {block.setNextStatement(false);block.setPreviousStatement(false);addFlashField(block);},},}, {type: 'function',name: 'onTouchMove',verbose: _('PART_TOUCH_ON_MOVE', 'on move'),parameters: [{type: 'parameter',name: 'callback',verbose: '',returnType: Function,}],blockly: {postProcess(block : Block) {block.setNextStatement(false);block.setPreviousStatement(false);addFlashField(block);},},}, {type: 'function',name: 'forEach',verbose: _('PART_TOUCH_FOR_EACH', 'for each finger'),parameters: [{type: 'parameter',name: 'callback',verbose: '',returnType: Function,parameters: [{type: 'parameter',name: 'x',returnType: Number,// Define the type for the scopeblockly: {scope: XPosition}}, {type: 'parameter',name: 'y',returnType: Number,// Define the type for the scopeblockly: {scope: YPosition}}],}],}, {type: 'variable',name: 'firstX',verbose: _('PART_TOUCH_X', 'x'),returnType: Number,// Become an argument if this type exists in the scopeblockly: {scope: XPosition,},}, {type: 'variable',name: 'firstY',verbose: _('PART_TOUCH_Y', 'y'),returnType: Number,// Become an argument if this type exists in the scopeblockly: {scope: YPosition,},}]

type

type: string = TouchPart.type

onInstall

  • Parameters

    Returns void

Const Utils

Utils: object

endShape

  • endShape(session: ISession, close: undefined | false | true, back: undefined | false | true): void

  • Parameters

    • session: ISession
    • Optional close: undefined | false | true
    • Optional back: undefined | false | true

    Returns void

getCenter

  • Parameters

    Returns object

isColorValue

  • isColorValue(val: string): boolean

  • Parameters

    • val: string

    Returns boolean

isNumber

  • isNumber(val: any): boolean

  • Parameters

    • val: any

    Returns boolean

isString

  • isString(val: any): boolean

  • Parameters

    • val: any

    Returns boolean

parseColor

  • parseColor(val: string): string

  • Parameters

    • val: string

    Returns string

parseCoordinate

  • parseCoordinate(session: ISession, val: string | number, type: string): number

  • Parameters

    • session: ISession
    • val: string | number
    • type: string

    Returns number

parseCoordinates

  • parseCoordinates(session: ISession, x: string | number, y: string | number): object

  • Parameters

    • session: ISession
    • x: string | number
    • y: string | number

    Returns object

parseLineStyle

  • parseLineStyle(attributes: (string | number)[]): object

  • Parameters

    • attributes: (string | number)[]

    Returns object

startShape

  • Parameters

    Returns void

Const VariablesAPI

VariablesAPI: object

id

id: string = ID

name

name: string = ID

type

type: string = "blockly"

register

  • Parameters

    Returns void

category

category: object

blocks

blocks: string[] = ['math_number','text','text_join','variables_set','variables_get',]

colour

colour: string = COLOR

id

id: string = ID

name

name:

defaults

defaults: object

math_number

math_number: object

NUM

NUM: string = "0"

text

text: object

TEXT

TEXT: string = ""

variables_get

variables_get: object

VAR

VAR: string = "item"

variables_set

variables_set: object

VAR

VAR: string = "item"

Const VoiceAPI

VoiceAPI: object

color

color: string = "#00c7b6"

icon

icon: HTMLTemplateElement = oscillator

label

label: string = _('PART_TTS_LABEL', 'Text-To-Speech')

symbols

symbols: object[] = [{type: 'function',name: 'say',verbose: _('PART_TTS_SAY', 'say'),parameters: [{type: 'parameter',name: 'text',verbose: '',returnType: String,default: 'Hello'}, {type: 'parameter',name: 'rate',verbose: _('PART_TTS_RATE', 'speed'),returnType: Number,default: 100}, {type: 'parameter',name: 'language',verbose: _('PART_TTS_LANGUAGE', 'language'),returnType: 'Enum',enum: accents,default: 'en-GB'}]}]

type

type: string = VoicePart.type

Const WeatherAPI

WeatherAPI: object

color

color: string = "#9b61bd"

icon

icon: HTMLTemplateElement = weather

inlineDisplay

inlineDisplay: WeatherInlineDisplay = WeatherInlineDisplay

label

label: string = _('PART_WEATHER_LABEL', 'Weather')

symbols

symbols: IMetaDefinition[] = [{type: 'function',name: 'is',verbose: _('PART_WEATHER_IS', 'is'),returnType: Boolean,parameters: [{type: 'parameter',name: 'type',returnType: 'Enum',enum: [[_('PART_WEATER_CLOUDY', 'cloudy'), 'cloudy'],[_('PART_WEATER_RAINY', 'rainy'), 'rainy'],[_('PART_WEATER_SNOWY', 'snowy'), 'snowy'],[_('PART_WEATER_SUNNY', 'sunny'), 'sunny'],],}],}, {type: 'variable',name: 'temperature',verbose: _('PART_WEATHER_TEMPERATURE', 'temperature'),returnType: Number,}, {type: 'variable',name: 'windSpeed',verbose: _('PART_WEATHER_WIND_SPEED', 'wind speed'),returnType: Number,}, {type: 'variable',name: 'windDirection',verbose: _('PART_WEATHER_WIND_DIRECTION', 'wind direction'),returnType: Number,}, {type: 'variable',name: 'clouds',verbose: _('PART_WEATHER_CLOUDS', 'clouds'),returnType: Number,}, {type: 'variable',name: 'emoji',verbose: _('PART_WEATHER_EMOJI', 'emoji'),returnType: String,}, {type: 'variable',name: 'location',verbose: _('PART_WEATHER_LOCATION', 'location'),setter: true,returnType: String,default: WeatherPart.defaultLocation,}, ...DataAPI]

type

type: string = WeatherPart.type

onInstall

  • Parameters

    Returns void

Const blocklyLangMap

blocklyLangMap: object

en-us

en-us: [string, string] = ['en', 'en-us']

ja-jp

ja-jp: [string, string] = ['en', 'en-us']

Const defaultDropOverlayProvider

defaultDropOverlayProvider: object

domNode

domNode: null = null

template

template: null = null

animateDragEnter

  • animateDragEnter(): void

  • Returns void

animateDragLeave

  • animateDragLeave(): void

  • Returns void

animateDrop

  • animateDrop(): void

  • Returns void

getDomNode

  • getDomNode(): any

  • Returns any

Const defaultSerializer

defaultSerializer: object

load

  • load(serialized: any): any

  • Parameters

    • serialized: any

    Returns any

serialize

  • serialize(data: any): any

  • Parameters

    • data: any

    Returns any

Const generate

generate: object

number

  • number(min?: number, max?: number): number

  • Parameters

    • Default value min: number = 0
    • Default value max: number = 512

    Returns number

rgb

  • rgb(): number[]

  • Returns number[]

rgbString

  • rgbString(): string

  • Returns string

string

  • string(length?: number): string

  • Parameters

    • Default value length: number = 20

    Returns string

Const noopSerializer

noopSerializer: object

load

  • load(): null

  • Returns null

serialize

  • serialize(): null

  • Returns null

Const stickersMap

stickersMap: object

ambulance

ambulance: string = "ambulance"

animal-bee

animal-bee: string = "bee"

animal-bird

animal-bird: string = "bird"

animal-blowfish

animal-blowfish: string = "blowfish"

animal-bluehwhale

animal-bluehwhale: string = "bluehwhale"

animal-bunny

animal-bunny: string = "bunny"

animal-camel

animal-camel: string = "camel"

animal-cat

animal-cat: string = "cat"

animal-centipede

animal-centipede: string = "centipede"

animal-chicken

animal-chicken: string = "chicken"

animal-clownfish

animal-clownfish: string = "clownfish"

animal-cow

animal-cow: string = "cow"

animal-crab

animal-crab: string = "crab"

animal-crocodile

animal-crocodile: string = "crocodile"

animal-dog

animal-dog: string = "dog"

animal-dolphin

animal-dolphin: string = "dolphin"

animal-duck

animal-duck: string = "duck"

animal-elephant

animal-elephant: string = "elephant"

animal-fish-1

animal-fish-1: string = "fish"

animal-goat

animal-goat: string = "goat"

animal-ladybug

animal-ladybug: string = "ladybug"

animal-monkey

animal-monkey: string = "monkey"

animal-mouse

animal-mouse: string = "mouse"

animal-octopus

animal-octopus: string = "octopus"

animal-pig

animal-pig: string = "pig"

animal-poodle

animal-poodle: string = "poodle"

animal-sheep

animal-sheep: string = "sheep"

animal-shrimp

animal-shrimp: string = "shrimp"

animal-snail

animal-snail: string = "snail"

animal-snake

animal-snake: string = "snake"

animal-spider

animal-spider: string = "spider"

animal-squirrel

animal-squirrel: string = "squirrel"

animal-tiger

animal-tiger: string = "tiger"

animal-tortoise

animal-tortoise: string = "tortoise"

animal-unicorn

animal-unicorn: string = "unicorn"

animal-whale

animal-whale: string = "whale"

arrow

arrow: string = "arrow"

bolt

bolt: string = "bolt"

creeper

creeper: string = "creeper"

doubting-donut

doubting-donut: string = "doubting-donut"

earth-america

earth-america: string = "america"

earth-asia

earth-asia: string = "asia"

earth-europe

earth-europe: string = "europe"

fire-engine

fire-engine: string = "fire-engine"

food-burger

food-burger: string = "burger"

food-burrito

food-burrito: string = "burrito"

food-candy

food-candy: string = "candy"

food-cheese

food-cheese: string = "cheese"

food-cherry

food-cherry: string = "cherry"

food-chicken

food-chicken: string = "chicken-leg"

food-donut

food-donut: string = "donut"

food-eggplant

food-eggplant: string = "eggplant"

food-icecream

food-icecream: string = "icecream"

food-melon

food-melon: string = "melon"

food-noodles

food-noodles: string = "noodles"

food-peach

food-peach: string = "peach"

food-pineapple

food-pineapple: string = "pineapple"

food-pizza

food-pizza: string = "pizza"

food-shrimp

food-shrimp: string = "tempura"

food-sushi

food-sushi: string = "sushi"

food-taco

food-taco: string = "taco"

food-tomato

food-tomato: string = "tomato"

food-watermelon

food-watermelon: string = "watermelon"

holidays-candle

holidays-candle: string = "candle"

holidays-gift

holidays-gift: string = "gift"

holidays-gingerbread

holidays-gingerbread: string = "gingerbread"

holidays-hat

holidays-hat: string = "hat"

holidays-tree

holidays-tree: string = "tree"

judoka-face

judoka-face: string = "judoka"

judoka-record

judoka-record: string = "record"

krink-marker

krink-marker: string = "krink-marker"

markers

markers: string = "Markers"

mask-alien

mask-alien: string = "alien"

mask-bear

mask-bear: string = "bear"

mask-blank

mask-blank: string = "blank"

mask-boar

mask-boar: string = "boar"

mask-cat

mask-cat: string = "cat-head"

mask-chicken

mask-chicken: string = "chicken-head"

mask-cool

mask-cool: string = "cool"

mask-cow

mask-cow: string = "cow-head"

mask-deer

mask-deer: string = "deer"

mask-devil

mask-devil: string = "devil"

mask-dog

mask-dog: string = "dog-head"

mask-easter-island

mask-easter-island: string = "easter-island"

mask-facemask

mask-facemask: string = "facemask"

mask-fox

mask-fox: string = "fox"

mask-frog

mask-frog: string = "frog"

mask-gorilla

mask-gorilla: string = "gorilla"

mask-grin

mask-grin: string = "grin"

mask-horse

mask-horse: string = "horse"

mask-ill

mask-ill: string = "ill"

mask-koala

mask-koala: string = "koala"

mask-laughcry

mask-laughcry: string = "laughcry"

mask-lion

mask-lion: string = "lion"

mask-meh

mask-meh: string = "meh"

mask-monkey

mask-monkey: string = "monkey-head"

mask-mouse

mask-mouse: string = "mouse-head"

mask-panda

mask-panda: string = "panda"

mask-pig

mask-pig: string = "pig-head"

mask-pumpkin

mask-pumpkin: string = "pumpkin"

mask-rabbit

mask-rabbit: string = "rabbit"

mask-robot

mask-robot: string = "robot"

mask-rolleyes

mask-rolleyes: string = "rolleyes"

mask-santa

mask-santa: string = "santa"

mask-skull

mask-skull: string = "skull"

mask-sleep

mask-sleep: string = "sleep"

mask-small-mouse

mask-small-mouse: string = "small-mouse"

mask-smile

mask-smile: string = "smile"

mask-tiger

mask-tiger: string = "tiger-head"

mask-traditional

mask-traditional: string = "traditional"

meteor

meteor: string = "meteor"

moon-1

moon-1: string = "moon"

moon-2

moon-2: string = "moon2"

moon-3

moon-3: string = "moon3"

moon-4

moon-4: string = "moon4"

moon-5

moon-5: string = "moon5"

moon-6

moon-6: string = "moon6"

moon-7

moon-7: string = "moon7"

moon-8

moon-8: string = "moon8"

moon-smiling

moon-smiling: string = "moon-smiling"

mouse

mouse: string = "mouse-art"

mrsprinkles

mrsprinkles: string = "mrsprinkles"

music-bell

music-bell: string = "bell"

music-drum

music-drum: string = "drum"

music-guitar

music-guitar: string = "guitar"

music-musical-note

music-musical-note: string = "note"

music-musical-notes

music-musical-notes: string = "notes"

music-pick

music-pick: string = "pick"

music-sax

music-sax: string = "sax"

music-trumpet

music-trumpet: string = "trumpet"

night-sky

night-sky: string = "night"

old-schooler

old-schooler: string = "old-schooler"

other-avocado

other-avocado: string = "avocado"

other-ball

other-ball: string = "ball"

other-ball-baseball

other-ball-baseball: string = "baseball"

other-ball-basketball

other-ball-basketball: string = "basketball"

other-ball-football

other-ball-football: string = "football"

other-ball-tennis

other-ball-tennis: string = "tennis"

other-cactus

other-cactus: string = "cactus"

other-cake

other-cake: string = "cake"

other-clap

other-clap: string = "clap"

other-clubs

other-clubs: string = "clubs"

other-controller

other-controller: string = "controller"

other-diamonds

other-diamonds: string = "diamonds"

other-dice

other-dice: string = "dice"

other-eightball

other-eightball: string = "eightball"

other-face

other-face: string = "face"

other-ghost

other-ghost: string = "ghost"

other-hearts

other-hearts: string = "hearts"

other-hotdog

other-hotdog: string = "hotdog"

other-keyboard

other-keyboard: string = "keyboard"

other-keytar

other-keytar: string = "keytar"

other-lightning-bolt

other-lightning-bolt: string = "lightning"

other-map

other-map: string = "map"

other-medal

other-medal: string = "medal"

other-medal-2

other-medal-2: string = "medal2"

other-microphone

other-microphone: string = "microphone"

other-micropscope

other-micropscope: string = "microscope"

other-minecraft-block

other-minecraft-block: string = "minecraft"

other-paintbrush

other-paintbrush: string = "paintbrush"

other-palm-tree

other-palm-tree: string = "palmtree"

other-palmtree

other-palmtree: string = "palmtree"

other-pen

other-pen: string = "pen"

other-piano-keyboard

other-piano-keyboard: string = "piano"

other-poop

other-poop: string = "poop"

other-popcorn

other-popcorn: string = "popcorn"

other-space-invader

other-space-invader: string = "space-invader"

other-spades

other-spades: string = "spades"

other-sprout

other-sprout: string = "sprout"

other-thermometer

other-thermometer: string = "thermometer"

other-toadstool

other-toadstool: string = "toadstool"

other-trophy

other-trophy: string = "trophy"

other-waffles

other-waffles: string = "pancakes"

peace

peace: string = "peace"

photo-animal-nose

photo-animal-nose: string = "animal-nose"

photo-boom

photo-boom: string = "boom"

photo-bubble-see-speech

photo-bubble-see-speech: string = "speech"

photo-bubble-speech-left

photo-bubble-speech-left: string = "speech-left"

photo-bubble-speech-right

photo-bubble-speech-right: string = "speech-right"

photo-bubble-speech-urgent

photo-bubble-speech-urgent: string = "speech-urgent"

photo-bubble-thought

photo-bubble-thought: string = "thought"

photo-crown

photo-crown: string = "crown"

photo-ears

photo-ears: string = "ears"

photo-eye

photo-eye: string = "eye"

photo-eyes

photo-eyes: string = "eyes"

photo-hearts

photo-hearts: string = "hearts"

photo-lightbulb

photo-lightbulb: string = "lightbulb"

photo-lips

photo-lips: string = "lips"

photo-mouth

photo-mouth: string = "mouth"

photo-nose

photo-nose: string = "nose"

photo-sunglasses

photo-sunglasses: string = "sunglasses"

photo-tongue

photo-tongue: string = "tongue"

photo-zzz

photo-zzz: string = "zzz"

pixel-spraycan

pixel-spraycan: string = "pixel-spraycan"

planet

planet: string = "planet"

point

point: string = "point"

police-car

police-car: string = "police-car"

rainbow-roller

rainbow-roller: string = "rainbow-roller"

red-car

red-car: string = "red-car"

robotnik

robotnik: string = "robotnik"

satellite

satellite: string = "satellite"

soydog

soydog: string = "soydog"

space-rocket

space-rocket: string = "rocket"

spraycan

spraycan: string = "spraycan"

spraying

spraying: string = "spraying"

sun-smiling

sun-smiling: string = "sun-smiling"

supreme-code

supreme-code: string = "supreme"

taxi

taxi: string = "taxi"

telescope

telescope: string = "telescope"

Generated using TypeDoc