pxt-core 10.0.2 → 10.0.4

package/built/pxtblocks/blockDragger.d.ts

@@ -0,0 +1,10 @@
+import * as Blockly from "blockly";
+import { DuplicateOnDragBlockDragger } from "./plugins/duplicateOnDrag";
+/**
+ * The following patch to blockly is to add the Trash icon on top of the toolbox,
+ * the trash icon should only show when a user drags a block that is already in the workspace.
+ */
+export declare class BlockDragger extends DuplicateOnDragBlockDragger {
+    drag(e: PointerEvent, currentDragDeltaXY: Blockly.utils.Coordinate): void;
+    endDrag(e: PointerEvent, currentDragDeltaXY: Blockly.utils.Coordinate): void;
+}

package/built/pxtblocks/breakpointIcon.d.ts

@@ -0,0 +1,15 @@
+import * as Blockly from "blockly";
+export declare class BreakpointIcon extends Blockly.icons.Icon {
+    protected readonly onStateChange: (block: Blockly.Block, isSet: boolean) => void;
+    static readonly type: Blockly.icons.IconType<Blockly.IIcon>;
+    protected isSet_: boolean;
+    protected breakpointSvg: SVGCircleElement;
+    constructor(sourceBlock: Blockly.Block, onStateChange: (block: Blockly.Block, isSet: boolean) => void);
+    getType(): Blockly.icons.IconType<Blockly.IIcon>;
+    initView(pointerdownListener: (e: PointerEvent) => void): void;
+    getSize(): Blockly.utils.Size;
+    onClick(): void;
+    isEnabled(): boolean;
+    setEnabled(enabled: boolean): void;
+    protected updateColor(): void;
+}

package/built/pxtblocks/builtins/functions.d.ts

@@ -0,0 +1,2 @@
+/// <reference path="../../pxtlib.d.ts" />
+export declare function initFunctions(): void;

package/built/pxtblocks/builtins/lists.d.ts

@@ -0,0 +1,2 @@
+/// <reference path="../../pxtlib.d.ts" />
+export declare function initLists(): void;

package/built/pxtblocks/builtins/logic.d.ts

@@ -0,0 +1,2 @@
+/// <reference path="../../pxtlib.d.ts" />
+export declare function initLogic(): void;

package/built/pxtblocks/builtins/loops.d.ts

@@ -0,0 +1,2 @@
+/// <reference path="../../pxtlib.d.ts" />
+export declare function initLoops(): void;

package/built/pxtblocks/builtins/math.d.ts

@@ -0,0 +1,4 @@
+/// <reference path="../../pxtlib.d.ts" />
+export declare function initMath(blockInfo: pxtc.BlocksInfo): void;
+export declare function initMathOpBlock(): void;
+export declare function initMathRoundBlock(): void;

package/built/pxtblocks/builtins/misc.d.ts

@@ -0,0 +1 @@
+export declare function initOnStart(): void;

package/built/pxtblocks/builtins/text.d.ts

@@ -0,0 +1 @@
+export declare function initText(): void;

package/built/pxtblocks/builtins/variables.d.ts

@@ -0,0 +1 @@
+export declare function initVariables(): void;

package/built/pxtblocks/codecardRenderer.d.ts

@@ -0,0 +1,5 @@
+export interface CodeCardRenderOptions {
+    hideHeader?: boolean;
+    shortName?: boolean;
+}
+export declare function renderCodeCard(card: pxt.CodeCard, options?: CodeCardRenderOptions): HTMLElement;

package/built/pxtblocks/compiler/compiler.d.ts

@@ -0,0 +1,8 @@
+/// <reference path="../../pxtlib.d.ts" />
+import * as Blockly from "blockly";
+import { BlockCompilationResult, BlockCompileOptions, Environment } from "./environment";
+export declare function compileBlockAsync(b: Blockly.Block, blockInfo: pxtc.BlocksInfo): Promise<BlockCompilationResult>;
+export declare function compileAsync(b: Blockly.Workspace, blockInfo: pxtc.BlocksInfo, opts?: BlockCompileOptions): Promise<BlockCompilationResult>;
+export declare function callKey(e: Environment, b: Blockly.Block): string;
+export declare function compileExpression(e: Environment, b: Blockly.Block, comments: string[]): pxt.blocks.JsNode;
+export declare function workerOpAsync(op: string, arg: pxtc.service.OpArg): Promise<any>;

package/built/pxtblocks/compiler/environment.d.ts

@@ -0,0 +1,97 @@
+/// <reference path="../../pxtlib.d.ts" />
+import * as Blockly from "blockly";
+export interface Environment {
+    workspace: Blockly.Workspace;
+    options: BlockCompileOptions;
+    stdCallTable: pxt.Map<StdFunc>;
+    userFunctionReturnValues: pxt.Map<Point>;
+    diagnostics: BlockDiagnostic[];
+    errors: Blockly.Block[];
+    renames: RenameMap;
+    stats: pxt.Map<number>;
+    enums: pxtc.EnumInfo[];
+    kinds: pxtc.KindInfo[];
+    idToScope: pxt.Map<Scope>;
+    blockDeclarations: pxt.Map<VarInfo[]>;
+    blocksInfo: pxtc.BlocksInfo;
+    allVariables: VarInfo[];
+    placeholders: pxt.Map<pxt.Map<PlaceholderLikeBlock>>;
+}
+export interface StdFunc {
+    f: string;
+    comp: pxt.blocks.BlockCompileInfo;
+    attrs: ts.pxtc.CommentAttrs;
+    isExtensionMethod?: boolean;
+    isExpression?: boolean;
+    imageLiteral?: number;
+    imageLiteralColumns?: number;
+    imageLiteralRows?: number;
+    hasHandler?: boolean;
+    property?: boolean;
+    namespace?: string;
+    isIdentity?: boolean;
+}
+export interface RenameMap {
+    oldToNew: pxt.Map<string>;
+    takenNames: pxt.Map<boolean>;
+    oldToNewFunctions: pxt.Map<string>;
+}
+export interface PlaceholderLikeBlock extends Blockly.Block {
+    p?: Point;
+}
+export interface BlockCompilationResult {
+    source: string;
+    sourceMap: pxt.blocks.BlockSourceInterval[];
+    stats: pxt.Map<number>;
+    diagnostics: BlockDiagnostic[];
+}
+export interface BlockCompileOptions {
+    emitTilemapLiterals?: boolean;
+}
+export declare class Point {
+    link: Point;
+    type: string;
+    parentType?: Point;
+    childType?: Point;
+    isArrayType?: boolean;
+    constructor(link: Point, type: string, parentType?: Point, childType?: Point, isArrayType?: boolean);
+}
+export interface Scope {
+    parent?: Scope;
+    firstStatement: Blockly.Block;
+    declaredVars: pxt.Map<VarInfo>;
+    referencedVars: number[];
+    assignedVars: number[];
+    children: Scope[];
+}
+export declare enum BlockDeclarationType {
+    None = 0,
+    Argument = 1,
+    Assigned = 2,
+    Implicit = 3
+}
+export interface BlockDiagnostic {
+    blockId: string;
+    message: string;
+}
+export interface VarInfo {
+    name: string;
+    id: number;
+    escapedName?: string;
+    type?: Point;
+    alreadyDeclared?: BlockDeclarationType;
+    firstReference?: Blockly.Block;
+    isAssigned?: boolean;
+    isFunctionParameter?: boolean;
+}
+export interface GrayBlock extends Blockly.Block {
+    setPythonEnabled(enabled: boolean): void;
+}
+export interface GrayBlockStatement extends GrayBlock {
+    domToMutation(xmlElement: Element): void;
+    mutationToDom(): Element;
+    getLines: () => string[];
+    declaredVariables: string;
+}
+export declare function emptyEnv(w: Blockly.Workspace, options: BlockCompileOptions): Environment;
+export declare function mkEnv(w: Blockly.Workspace, blockInfo?: pxtc.BlocksInfo, options?: BlockCompileOptions): Environment;

package/built/pxtblocks/compiler/typeChecker.d.ts

@@ -0,0 +1,25 @@
+import * as Blockly from "blockly";
+import { Point, Environment, VarInfo, StdFunc } from "./environment";
+interface DeclaredVariable {
+    name: string;
+    type: Point;
+    isFunctionParameter?: boolean;
+}
+export interface IfBlock extends Blockly.Block {
+    elseifCount_: number;
+    elseCount_: number;
+}
+export declare function infer(allBlocks: Blockly.Block[], e: Environment, w: Blockly.Workspace): void;
+export declare function mkPoint(t: string, isArrayType?: boolean): Point;
+export declare function find(p: Point): Point;
+export declare function returnType(e: Environment, b: Blockly.Block): Point;
+export declare function attachPlaceholderIf(e: Environment, b: Blockly.Block, n: string, type?: string): void;
+export declare function getConcreteType(point: Point, found?: Point[]): Point;
+export declare function lookup(e: Environment, b: Blockly.Block, name: string): VarInfo;
+export declare function getDeclaredVariables(block: Blockly.Block, e: Environment): DeclaredVariable[];
+export declare function isFunctionRecursive(e: Environment, b: Blockly.Block, strict: boolean): boolean;
+export declare function getEscapedCBParameters(b: Blockly.Block, stdfun: StdFunc, e: Environment): string[];
+export declare function defaultValueForType(t: Point): pxt.blocks.JsNode;
+export declare function isStringType(type: Point): boolean;
+export declare function isBooleanType(type: Point): boolean;
+export {};

package/built/pxtblocks/compiler/util.d.ts

@@ -0,0 +1,15 @@
+import * as Blockly from "blockly";
+import { Environment, Scope, StdFunc } from "./environment";
+import { MutatingBlock } from "../legacyMutations";
+export declare function forEachChildExpression(block: Blockly.Block, cb: (block: Blockly.Block) => void, recursive?: boolean): void;
+export declare function forEachStatementInput(block: Blockly.Block, cb: (block: Blockly.Block) => void): void;
+export declare function printScope(scope: Scope, depth?: number): void;
+export declare function getLoopVariableField(e: Environment, b: Blockly.Block): Blockly.Block;
+export declare function getFunctionName(functionBlock: Blockly.Block): string;
+export declare function visibleParams({ comp }: StdFunc, optionalCount: number): pxt.blocks.BlockParameter[];
+export declare function countOptionals(b: Blockly.Block, func: StdFunc): number;
+export declare function getInputTargetBlock(e: Environment, b: Blockly.Block, n: string): Blockly.Block;
+export declare function isMutatingBlock(b: Blockly.Block): b is MutatingBlock;
+export declare function escapeVarName(name: string, e: Environment, isFunction?: boolean): string;
+export declare function append<T>(a1: T[], a2: T[]): void;
+export declare function isFunctionDefinition(b: Blockly.Block): boolean;

package/built/pxtblocks/compiler/variables.d.ts

@@ -0,0 +1,4 @@
+/// <reference path="../../pxtlib.d.ts" />
+import * as Blockly from "blockly";
+import { Scope, Environment } from "./environment";
+export declare function trackAllVariables(topBlocks: Blockly.Block[], e: Environment): Scope;

package/built/pxtblocks/composableMutations.d.ts

@@ -0,0 +1,9 @@
+/// <reference path="../pxtlib.d.ts" />
+import * as Blockly from "blockly";
+export interface ComposableMutation {
+    mutationToDom(mutationElement: Element): Element;
+    domToMutation(savedElement: Element): void;
+}
+export declare function appendMutation(block: Blockly.Block, mutation: ComposableMutation): void;
+export declare function initVariableArgsBlock(b: Blockly.Block, handlerArgs: pxt.blocks.HandlerArg[]): void;
+export declare function initExpandableBlock(info: pxtc.BlocksInfo, b: Blockly.Block, def: pxtc.ParsedBlockDef, comp: pxt.blocks.BlockCompileInfo, toggle: boolean, addInputs: () => void): void;

package/built/pxtblocks/constants.d.ts

@@ -0,0 +1,4 @@
+import * as Blockly from "blockly";
+export declare let provider: Blockly.zelos.ConstantProvider;
+export declare const optionalDummyInputPrefix = "0_optional_dummy";
+export declare const optionalInputWithFieldPrefix = "0_optional_field";

package/built/pxtblocks/contextMenu/blockItems.d.ts

@@ -0,0 +1,2 @@
+/// <reference path="../../pxtlib.d.ts" />
+export declare function registerBlockitems(): void;

package/built/pxtblocks/contextMenu/contextMenu.d.ts

@@ -0,0 +1,4 @@
+/// <reference path="../../pxtlib.d.ts" />
+import * as Blockly from "blockly";
+export declare function initContextMenu(): void;
+export declare function setupWorkspaceContextMenu(workspace: Blockly.WorkspaceSvg): void;

package/built/pxtblocks/contextMenu/index.d.ts

@@ -0,0 +1 @@
+export * from "./contextMenu";

package/built/pxtblocks/contextMenu/workspaceItems.d.ts

@@ -0,0 +1,2 @@
+/// <reference path="../../pxtlib.d.ts" />
+export declare function registerWorkspaceItems(): void;

package/built/pxtblocks/diff.d.ts

@@ -0,0 +1,22 @@
+/// <reference path="../pxtlib.d.ts" />
+import * as Blockly from "blockly";
+import { BlocksRenderOptions } from "./render";
+export interface DiffOptions {
+    hideDeletedTopBlocks?: boolean;
+    hideDeletedBlocks?: boolean;
+    renderOptions?: BlocksRenderOptions;
+    statementsOnly?: boolean;
+}
+export interface DiffResult {
+    ws?: Blockly.WorkspaceSvg;
+    message?: string;
+    error?: any;
+    svg?: Element;
+    deleted: number;
+    added: number;
+    modified: number;
+}
+export declare function needsDecompiledDiff(oldXml: string, newXml: string): boolean;
+export declare function diffXml(oldXml: string, newXml: string, options?: DiffOptions): DiffResult;
+export declare function mergeXml(xmlA: string, xmlO: string, xmlB: string): string;
+export declare function decompiledDiffAsync(oldTs: string, oldResp: pxtc.CompileResult, newTs: string, newResp: pxtc.CompileResult, options?: DiffOptions): DiffResult;

package/built/pxtblocks/external.d.ts

@@ -0,0 +1,14 @@
+import * as Blockly from "blockly";
+export declare function promptTranslateBlock(blockId: string, blockTranslationIds: string[]): void;
+export declare function setPromptTranslateBlock(impl: (blockId: string, blockTranslationIds: string[]) => void): void;
+export declare function extensionBlocklyPatch(pkgTargetVersion: string, el: Element): void;
+export declare function setExtensionBlocklyPatch(impl: (pkgTargetVersion: string, el: Element) => void): void;
+export declare function openHelpUrl(url: string): void;
+export declare function setOpenHelpUrl(impl: (url: string) => void): void;
+export declare function onWorkspaceContextMenu(workspace: Blockly.WorkspaceSvg, options: Blockly.ContextMenuRegistry.ContextMenuOption[]): void;
+export declare function setOnWorkspaceContextMenu(impl: (workspace: Blockly.WorkspaceSvg, options: Blockly.ContextMenuRegistry.ContextMenuOption[]) => void): void;
+export interface PromptOptions {
+    placeholder: string;
+}
+export declare function setPrompt(impl: (message: string, defaultValue: string, callback: (value: string) => void, options?: PromptOptions) => void, setBlocklyAlso?: boolean): void;
+export declare function prompt(message: string, defaultValue: string, callback: (value: string) => void, options?: PromptOptions): void;

package/built/pxtblocks/fields/fieldEditorRegistry.d.ts

@@ -0,0 +1,5 @@
+/// <reference path="../../pxtlib.d.ts" />
+import { FieldCustom, FieldCustomConstructor } from "./field_utils";
+export declare function initFieldEditors(): void;
+export declare function registerFieldEditor(selector: string, field: FieldCustomConstructor, validator?: any): void;
+export declare function createFieldEditor(selector: string, text: string, params: any): FieldCustom;

package/built/pxtblocks/fields/field_animation.d.ts

@@ -0,0 +1,39 @@
+/// <reference path="../../pxtlib.d.ts" />
+import * as Blockly from "blockly";
+import svg = pxt.svgUtil;
+import { FieldAssetEditor } from "./field_asset";
+export interface FieldAnimationOptions {
+    initWidth: string;
+    initHeight: string;
+    disableResize: string;
+    filter?: string;
+    lightMode: boolean;
+}
+export interface ParsedFieldAnimationOptions {
+    initWidth: number;
+    initHeight: number;
+    disableResize: boolean;
+    filter?: string;
+    lightMode: boolean;
+}
+export declare class FieldAnimationEditor extends FieldAssetEditor<FieldAnimationOptions, ParsedFieldAnimationOptions> {
+    protected frames: string[];
+    protected preview: svg.Image;
+    protected animateRef: any;
+    protected asset: pxt.Animation;
+    protected initInterval: number;
+    initView(): void;
+    showEditor_(): void;
+    render_(): void;
+    protected getAssetType(): pxt.AssetType;
+    protected createNewAsset(text?: string): pxt.Asset;
+    protected onEditorClose(newValue: pxt.Animation): void;
+    protected getValueText(): string;
+    protected redrawPreview(): void;
+    protected onMouseEnter: () => void;
+    protected onMouseLeave: () => void;
+    protected getParentIntervalBlock(): Blockly.Block;
+    protected setParentInterval(interval: number): void;
+    protected getParentInterval(): number;
+    protected parseFieldOptions(opts: FieldAnimationOptions): ParsedFieldAnimationOptions;
+}

package/built/pxtblocks/fields/field_argumentvariable.d.ts

@@ -0,0 +1,11 @@
+/// <reference path="../../pxtlib.d.ts" />
+import * as Blockly from "blockly";
+/**
+ * Subclass of FieldVariable to filter out the "delete" option when
+ * variables are part of a function argument (or else the whole function
+ * gets deleted).
+*/
+export declare class FieldArgumentVariable extends Blockly.FieldVariable {
+    constructor(varName: string);
+    generateMenu(): any;
+}

package/built/pxtblocks/fields/field_asset.d.ts

@@ -0,0 +1,63 @@
+/// <reference path="../../pxtlib.d.ts" />
+import * as Blockly from "blockly";
+import { FieldBase } from "./field_base";
+export interface FieldAssetEditorOptions {
+    initWidth?: string;
+    initHeight?: string;
+    disableResize?: string;
+}
+interface ParsedFieldAssetEditorOptions {
+    initWidth?: number;
+    initHeight?: number;
+    disableResize?: boolean;
+    lightMode?: boolean;
+}
+export declare abstract class FieldAssetEditor<U extends FieldAssetEditorOptions, V extends ParsedFieldAssetEditorOptions> extends FieldBase<U> {
+    protected asset: pxt.Asset;
+    protected params: V;
+    protected blocksInfo: pxtc.BlocksInfo;
+    protected lightMode: boolean;
+    protected undoRedoState: any;
+    protected pendingEdit: boolean;
+    protected isEmpty: boolean;
+    isGreyBlock: boolean;
+    constructor(text: string, params: any, validator?: Blockly.FieldValidator);
+    protected abstract getAssetType(): pxt.AssetType;
+    protected abstract createNewAsset(text?: string): pxt.Asset;
+    protected abstract getValueText(): string;
+    onInit(): void;
+    onValueChanged(newValue: string): string;
+    showEditor_(): void;
+    protected showEditorFullscreen(editorKind: string, params: any): void;
+    protected showEditorInWidgetDiv(editorKind: string, params: any): void;
+    protected onFieldEditorHide(fv: pxt.react.FieldEditorView<pxt.Asset>): void;
+    render_(): void;
+    getDisplayText_(): string;
+    updateEditable(): void;
+    getValue(): string;
+    onDispose(): void;
+    disposeOfTemporaryAsset(): void;
+    clearTemporaryAssetData(): void;
+    isTemporaryAsset(): boolean;
+    getAsset(): pxt.Asset;
+    updateAsset(asset: pxt.Asset): void;
+    protected onEditorClose(newValue: pxt.Asset): void;
+    protected redrawPreview(): void;
+    protected parseValueText(newText: string): void;
+    protected parseFieldOptions(opts: U): V;
+    protected updateAssetMeta(): void;
+    protected updateAssetListener(): void;
+    protected assetChangeListener: () => void;
+    protected isFullscreen(): boolean;
+}
+export declare class BlocklyTilemapChange extends Blockly.Events.BlockChange {
+    protected oldRevision: number;
+    protected newRevision: number;
+    oldAssetId: string;
+    newAssetId: string;
+    fieldName: string;
+    constructor(block: Blockly.Block, element: string, name: string, oldValue: any, newValue: any, oldRevision: number, newRevision: number);
+    isNull(): boolean;
+    run(forward: boolean): void;
+}
+export {};

package/built/pxtblocks/fields/field_autocomplete.d.ts

@@ -0,0 +1,32 @@
+/// <reference path="../../pxtlib.d.ts" />
+import * as Blockly from "blockly";
+import { FieldCustom } from "./field_utils";
+import { FieldTextDropdown, FieldTextDropdownOptions } from "./field_textdropdown";
+export interface FieldAutoCompleteOptions extends FieldTextDropdownOptions {
+    key: string;
+}
+export declare class FieldAutoComplete extends FieldTextDropdown implements FieldCustom {
+    isFieldCustom_: boolean;
+    protected key: string;
+    protected parsedValue: string;
+    protected quoteSize_: number;
+    protected quoteWidth_: number;
+    protected quoteLeftX_: number;
+    protected quoteRightX_: number;
+    protected quoteY_: number;
+    protected quoteLeft_: SVGTextElement;
+    protected quoteRight_: SVGTextElement;
+    constructor(text: string, options: FieldAutoCompleteOptions, opt_validator?: Blockly.FieldValidator);
+    isOptionListDynamic(): boolean;
+    getDisplayText_(): string;
+    doValueUpdate_(newValue: string): void;
+    getValue(): string;
+    getOptions(): [string, string][];
+    showDropdown_(): void;
+    getKey(): string;
+    initView(): void;
+    updateSize_(): void;
+    positionRight(x: number): number;
+    positionLeft(x: number): number;
+    createSVGArrow(): void;
+}

package/built/pxtblocks/fields/field_base.d.ts

@@ -0,0 +1,31 @@
+/// <reference path="../../pxtlib.d.ts" />
+import * as Blockly from "blockly";
+import { FieldCustom } from "./field_utils";
+export declare abstract class FieldBase<U> extends Blockly.Field implements FieldCustom {
+    isFieldCustom_: true;
+    SERIALIZABLE: boolean;
+    options: U;
+    protected valueText: string;
+    protected loaded: boolean;
+    protected workspace: Blockly.Workspace;
+    constructor(text: string, params: U, validator?: Blockly.FieldValidator);
+    protected abstract onInit(): void;
+    protected abstract onDispose(): void;
+    protected abstract onValueChanged(newValue: string): string;
+    static pendingInit: FieldBase<any>[];
+    static pendingTimeout: any;
+    static enqueueInit(field: FieldBase<any>): void;
+    static flushInitQueue(): void;
+    init(): void;
+    dispose(): void;
+    getValue(): string;
+    doValueUpdate_(newValue: string): void;
+    getDisplayText_(): string;
+    onLoadedIntoWorkspace(): void;
+    protected getAnchorDimensions(): any;
+    protected isInitialized(): boolean;
+    protected getBlockData(): string;
+    protected setBlockData(value: string): void;
+    protected getSiblingBlock(inputName: string, useGrandparent?: boolean): Blockly.Block;
+    protected getSiblingField(fieldName: string, useGrandparent?: boolean): Blockly.Field<any>;
+}

package/built/pxtblocks/fields/field_colorwheel.d.ts

@@ -0,0 +1,32 @@
+/// <reference path="../../pxtlib.d.ts" />
+import * as Blockly from "blockly";
+import { FieldCustom } from "./field_utils";
+import { FieldSlider } from "../plugins/math";
+export declare class FieldColorWheel extends FieldSlider implements FieldCustom {
+    isFieldCustom_: boolean;
+    private params;
+    private channel_;
+    /**
+     * Class for a color wheel field.
+     * @param {number|string} value The initial content of the field.
+     * @param {Function=} opt_validator An optional function that is called
+     *     to validate any constraints on what the user entered.  Takes the new
+     *     text as an argument and returns either the accepted text, a replacement
+     *     text, or null to abort the change.
+     * @extends {Blockly.FieldNumber}
+     * @constructor
+     */
+    constructor(value_: any, params: any, opt_validator?: Blockly.FieldValidator);
+    /**
+     * Set the gradient CSS properties for the given node and channel
+     * @param {Node} node - The DOM node the gradient will be set on.
+     * @private
+     */
+    setBackground_(node: HTMLElement): void;
+    setReadout_(readout: Element, value: string): void;
+    createColourStops_(): string[];
+    colorWheel(wheelPos: number, channel?: string): string;
+    hsvFast(hue: number, sat: number, val: number): string;
+    private hex;
+    private componentToHex;
+}

package/built/pxtblocks/fields/field_colour.d.ts

@@ -0,0 +1,38 @@
+/// <reference path="../../pxtlib.d.ts" />
+import * as Blockly from "blockly";
+import { FieldCustom, FieldCustomOptions } from "./field_utils";
+/**
+     * The value modes:
+     *     hex - Outputs an HTML color string: "#ffffff" (with quotes)
+     *     rgb - Outputs an RGB number in hex: 0xffffff
+     *     index - Outputs the index of the color in the list of colors: 0
+     */
+export declare type FieldColourValueMode = "hex" | "rgb" | "index";
+export interface FieldColourNumberOptions extends FieldCustomOptions {
+    colours?: string;
+    columns?: string;
+    className?: string;
+    valueMode?: FieldColourValueMode;
+}
+export declare class FieldColorNumber extends Blockly.FieldColour implements FieldCustom {
+    isFieldCustom_: boolean;
+    protected colour_: string;
+    private valueMode_;
+    protected colours_: string[];
+    constructor(text: string, params: FieldColourNumberOptions, opt_validator?: Blockly.FieldValidator);
+    setColours(colours: string[], titles?: string[]): Blockly.FieldColour;
+    doClassValidation_(colour: string): string;
+    /**
+     * Return the current colour.
+     * @param {boolean} opt_asHex optional field if the returned value should be a hex
+     * @return {string} Current colour in '#rrggbb' format.
+     */
+    getValue(opt_asHex?: boolean): string;
+    /**
+     * Set the colour.
+     * @param {string} colour The new colour in '#rrggbb' format.
+     */
+    doValueUpdate_(colour: string): void;
+    getColours_(): string[];
+    applyColour(): void;
+}

package/built/pxtblocks/fields/field_dropdown.d.ts

@@ -0,0 +1,5 @@
+import * as Blockly from "blockly";
+export declare class FieldDropdown extends Blockly.FieldDropdown {
+    protected shouldAddBorderRect_(): boolean;
+    protected showEditor_(e?: MouseEvent): void;
+}