pxt-core

/// <reference path="../localtypings/monaco.d.ts" /> /// <reference path="pxtlib.d.ts" /> /// <reference path="pxtblocks.d.ts" /> declare namespace pxt.editor { enum SimState { Stopped = 0, Pending = 1, Starting = 2, Running = 3 } interface IEditor { undo(): void; redo(): void; hasUndo(): boolean; hasRedo(): boolean; zoomIn(): void; zoomOut(): void; resize(): void; setScale(scale: number): void; } interface IFile { name: string; virtual?: boolean; } function isBlocks(f: IFile): boolean; interface FileHistoryEntry { id: string; name: string; pos: any; } interface EditorSettings { editorFontSize: number; fileHistory: FileHistoryEntry[]; } enum ErrorListState { HeaderOnly = "errorListHeader", Expanded = "errorListExpanded" } interface IAppProps { } interface IAppState { active?: boolean; header?: pxt.workspace.Header; editorState?: EditorState; currFile?: IFile; fileState?: string; showFiles?: boolean; sideDocsLoadUrl?: string; sideDocsCollapsed?: boolean; projectName?: string; suppressPackageWarning?: boolean; tutorialOptions?: pxt.tutorial.TutorialOptions; lightbox?: boolean; keymap?: boolean; simState?: SimState; autoRun?: boolean; resumeOnVisibility?: boolean; compiling?: boolean; isSaving?: boolean; publishing?: boolean; hideEditorFloats?: boolean; collapseEditorTools?: boolean; showBlocks?: boolean; showParts?: boolean; fullscreen?: boolean; showMiniSim?: boolean; mute?: boolean; embedSimView?: boolean; editorPosition?: { lineNumber: number; column: number; file: IFile; }; tracing?: boolean; debugging?: boolean; debugFirstRun?: boolean; bannerVisible?: boolean; pokeUserComponent?: string; flashHint?: boolean; editorOffset?: string; print?: boolean; greenScreen?: boolean; accessibleBlocks?: boolean; home?: boolean; hasError?: boolean; cancelledDownload?: boolean; simSerialActive?: boolean; deviceSerialActive?: boolean; errorListState?: ErrorListState; screenshoting?: boolean; extensionsVisible?: boolean; isMultiplayerGame?: boolean; onboarding?: boolean; } interface EditorState { filters?: pxt.editor.ProjectFilters; searchBar?: boolean; hasCategories?: boolean; } interface ProjectCreationOptions { prj?: pxt.ProjectTemplate; name?: string; documentation?: string; filesOverride?: pxt.Map<string>; filters?: ProjectFilters; temporary?: boolean; tutorial?: pxt.tutorial.TutorialOptions; dependencies?: pxt.Map<string>; tsOnly?: boolean; languageRestriction?: LanguageRestriction; preferredEditor?: string; extensionUnderTest?: string; skillmapProject?: boolean; } interface ExampleImportOptions { name: string; path: string; loadBlocks?: boolean; prj?: ProjectTemplate; preferredEditor?: string; } interface StartActivityOptions { activity: Activity; path: string; title?: string; editor?: string; focus?: boolean; importOptions?: pxt.editor.ExampleImportOptions; previousProjectHeaderId?: string; carryoverPreviousCode?: boolean; } interface ProjectFilters { namespaces?: { [index: string]: FilterState; }; blocks?: { [index: string]: FilterState; }; fns?: { [index: string]: FilterState; }; defaultState?: FilterState; } enum FilterState { Hidden = 0, Visible = 1, Disabled = 2 } interface ModalDialogButton { label: string; url?: string; } interface ModalDialogOptions { header: string; body: string; buttons?: ModalDialogButton[]; } interface ScreenshotData { data?: ImageData; delay?: number; event?: "start" | "stop"; } interface SimulatorStartOptions { clickTrigger?: boolean; } interface ImportFileOptions { extension?: boolean; openHomeIfFailed?: boolean; } interface UserInfo { id: string; userName?: string; name: string; profile?: string; loginHint?: string; initials?: string; photo?: string; } interface ShareData { url: string; embed: { code?: string; editor?: string; simulator?: string; url?: string; }; qr?: string; error?: any; } type Activity = "tutorial" | "recipe" | "example"; interface IProjectView { state: IAppState; setState(st: IAppState): void; forceUpdate(): void; reloadEditor(): void; openBlocks(): void; openJavaScript(giveFocusOnLoading?: boolean): void; openPython(giveFocusOnLoading?: boolean): void; openAssets(): void; openSettings(): void; openSimView(): void; openSimSerial(): void; openDeviceSerial(): void; openPreviousEditor(): void; switchTypeScript(): void; openTypeScriptAsync(): Promise<void>; openPythonAsync(): Promise<void>; saveBlocksToTypeScriptAsync(): Promise<string>; saveFileAsync(): Promise<void>; saveCurrentSourceAsync(): Promise<void>; saveProjectAsync(): Promise<void>; loadHeaderAsync(h: pxt.workspace.Header): Promise<void>; reloadHeaderAsync(): Promise<void>; importProjectAsync(prj: pxt.workspace.Project, editorState?: pxt.editor.EditorState): Promise<void>; importTutorialAsync(markdown: string): Promise<void>; openProjectByHeaderIdAsync(headerId: string): Promise<void>; overrideTypescriptFile(text: string): void; overrideBlocksFile(text: string): void; resetTutorialTemplateCode(keepAssets: boolean): Promise<void>; exportAsync(): Promise<string>; newEmptyProject(name?: string, documentation?: string, preferredEditor?: string): void; newProject(options?: ProjectCreationOptions): void; createProjectAsync(options: ProjectCreationOptions): Promise<void>; importExampleAsync(options: ExampleImportOptions): Promise<void>; showScriptManager(): void; importProjectDialog(): void; removeProject(): void; editText(): void; hasCloudSync(): boolean; getPreferredEditor(): string; saveAndCompile(): void; updateHeaderName(name: string): void; updateHeaderNameAsync(name: string): Promise<void>; compile(): void; setFile(fn: IFile, line?: number): void; setSideFile(fn: IFile, line?: number): void; navigateToError(diag: pxtc.KsDiagnostic): void; setSideDoc(path: string, blocksEditor?: boolean): void; setSideMarkdown(md: string): void; setSideDocCollapsed(shouldCollapse?: boolean): void; removeFile(fn: IFile, skipConfirm?: boolean): void; updateFileAsync(name: string, content: string, open?: boolean): Promise<void>; openHome(): void; unloadProjectAsync(home?: boolean): Promise<void>; setTutorialStep(step: number): void; setTutorialInstructionsExpanded(value: boolean): void; exitTutorial(): void; completeTutorialAsync(): Promise<void>; showTutorialHint(): void; isTutorial(): boolean; onTutorialLoaded(): void; setTutorialCodeStatus(step: number, status: pxt.tutorial.TutorialRuleStatus[]): void; pokeUserActivity(): void; stopPokeUserActivity(): void; clearUserPoke(): void; setHintSeen(step: number): void; setEditorOffset(): void; anonymousPublishHeaderByIdAsync(headerId: string, projectName?: string): Promise<ShareData>; publishCurrentHeaderAsync(persistent: boolean, screenshotUri?: string): Promise<string>; publishAsync(name: string, screenshotUri?: string, forceAnonymous?: boolean): Promise<pxt.editor.ShareData>; startStopSimulator(opts?: SimulatorStartOptions): void; stopSimulator(unload?: boolean, opts?: SimulatorStartOptions): void; restartSimulator(): void; startSimulator(opts?: SimulatorStartOptions): void; runSimulator(): void; isSimulatorRunning(): boolean; expandSimulator(): void; collapseSimulator(): void; toggleSimulatorCollapse(): void; toggleSimulatorFullscreen(): void; setSimulatorFullScreen(enabled: boolean): void; proxySimulatorMessage(content: string): void; toggleTrace(intervalSpeed?: number): void; setTrace(enabled: boolean, intervalSpeed?: number): void; toggleMute(): void; setMute(on: boolean): void; openInstructions(): void; closeFlyout(): void; printCode(): void; requestScreenshotAsync(): Promise<string>; downloadScreenshotAsync(): Promise<void>; toggleDebugging(): void; dbgPauseResume(): void; dbgStepInto(): void; dbgStepOver(): void; dbgInsertBreakpoint(): void; setBannerVisible(b: boolean): void; typecheckNow(): void; shouldPreserveUndoStack(): boolean; openExtension(extension: string, url: string, consentRequired?: boolean, trusted?: boolean): void; handleExtensionRequest(request: ExtensionRequest): void; fireResize(): void; updateEditorLogo(left: number, rgba?: string): number; loadBlocklyAsync(): Promise<void>; isBlocksEditor(): boolean; isTextEditor(): boolean; isPxtJsonEditor(): boolean; blocksScreenshotAsync(pixelDensity?: number, encodeBlocks?: boolean): Promise<string>; renderBlocksAsync(req: EditorMessageRenderBlocksRequest): Promise<EditorMessageRenderBlocksResponse>; renderPythonAsync(req: EditorMessageRenderPythonRequest): Promise<EditorMessageRenderPythonResponse>; toggleHighContrast(): void; setHighContrast(on: boolean): void; toggleGreenScreen(): void; toggleAccessibleBlocks(): void; setAccessibleBlocks(enabled: boolean): void; launchFullEditor(): void; resetWorkspace(): void; settings: EditorSettings; isEmbedSimActive(): boolean; isBlocksActive(): boolean; isJavaScriptActive(): boolean; isPythonActive(): boolean; isAssetsActive(): boolean; editor: IEditor; startActivity(options: StartActivityOptions): void; showLightbox(): void; hideLightbox(): void; showOnboarding(): void; hideOnboarding(): void; showKeymap(show: boolean): void; toggleKeymap(): void; showReportAbuse(): void; showLanguagePicker(): void; showShareDialog(title?: string, kind?: "multiplayer" | "vscode" | "share"): void; showAboutDialog(): void; showLoginDialog(continuationHash?: string): void; showProfileDialog(location?: string): void; showImportUrlDialog(): void; showImportFileDialog(options?: ImportFileOptions): void; showImportGithubDialog(): void; showResetDialog(): void; showExitAndSaveDialog(): void; showChooseHwDialog(skipDownload?: boolean): void; showExperimentsDialog(): void; showPackageDialog(query?: string): void; showBoardDialogAsync(features?: string[], closeIcon?: boolean): Promise<void>; checkForHwVariant(): boolean; pairAsync(): Promise<void>; createModalClasses(classes?: string): string; showModalDialogAsync(options: ModalDialogOptions): Promise<void>; askForProjectCreationOptionsAsync(): Promise<ProjectCreationOptions>; pushScreenshotHandler(handler: (msg: ScreenshotData) => void): void; popScreenshotHandler(): void; openNewTab(header: pxt.workspace.Header, dependent: boolean): void; createGitHubRepositoryAsync(): Promise<void>; saveLocalProjectsToCloudAsync(headerIds: string[]): Promise<pxt.Map<string> | undefined>; requestProjectCloudStatus(headerIds: string[]): Promise<void>; convertCloudProjectsToLocal(userId: string): Promise<void>; setLanguageRestrictionAsync(restriction: pxt.editor.LanguageRestriction): Promise<void>; hasHeaderBeenPersistentShared(): boolean; getSharePreferenceForHeader(): boolean; saveSharePreferenceForHeaderAsync(anonymousByDefault: boolean): Promise<void>; } interface IHexFileImporter { id: string; canImport(data: pxt.cpp.HexFile): boolean; importAsync(project: IProjectView, data: pxt.cpp.HexFile): Promise<void>; } interface IResourceImporter { id: string; canImport(data: File): boolean; importAsync(project: IProjectView, data: File): Promise<void>; } interface ISettingsProps { parent: IProjectView; visible?: boolean; collapsed?: boolean; simSerialActive?: boolean; devSerialActive?: boolean; } interface IFieldCustomOptions { selector: string; editor: Blockly.FieldCustomConstructor; text?: string; validator?: any; } interface ExtensionOptions { blocklyToolbox: ToolboxDefinition; monacoToolbox: ToolboxDefinition; projectView: IProjectView; } interface IToolboxOptions { blocklyToolbox?: ToolboxDefinition; monacoToolbox?: ToolboxDefinition; } interface ExtensionResult { hexFileImporters?: IHexFileImporter[]; resourceImporters?: IResourceImporter[]; beforeCompile?: () => void; patchCompileResultAsync?: (r: pxtc.CompileResult) => Promise<void>; deployAsync?: (r: pxtc.CompileResult) => Promise<void>; saveOnlyAsync?: (r: ts.pxtc.CompileResult) => Promise<void>; saveProjectAsync?: (project: pxt.cpp.HexFile) => Promise<void>; renderBrowserDownloadInstructions?: () => any; renderUsbPairDialog?: (firmwareUrl?: string, failedOnce?: boolean) => any; renderIncompatibleHardwareDialog?: (unsupportedParts: string[]) => any; showUploadInstructionsAsync?: (fn: string, url: string, confirmAsync: (options: any) => Promise<number>) => Promise<void>; showProgramTooLargeErrorAsync?: (variants: string[], confirmAsync: (options: any) => Promise<number>) => Promise<pxt.commands.RecompileOptions>; toolboxOptions?: IToolboxOptions; blocklyPatch?: (pkgTargetVersion: string, dom: Element) => void; webUsbPairDialogAsync?: (pairAsync: () => Promise<boolean>, confirmAsync: (options: any) => Promise<number>) => Promise<number>; mkPacketIOWrapper?: (io: pxt.packetio.PacketIO) => pxt.packetio.PacketIOWrapper; onTutorialCompleted?: () => void; onCodeStart?: () => void; onCodeStop?: () => void; } interface FieldExtensionOptions { } interface FieldExtensionResult { fieldEditors?: IFieldCustomOptions[]; } interface ToolboxDefinition { loops?: ToolboxCategoryDefinition; logic?: ToolboxCategoryDefinition; variables?: ToolboxCategoryDefinition; maths?: ToolboxCategoryDefinition; text?: ToolboxCategoryDefinition; arrays?: ToolboxCategoryDefinition; functions?: ToolboxCategoryDefinition; } interface ToolboxCategoryDefinition { /** * The display name for the category */ name?: string; /** * The icon of this category */ icon?: string; /** * The color of this category */ color?: string; /** * The weight of the category relative to other categories in the toolbox */ weight?: number; /** * Whether or not the category should be placed in the advanced category */ advanced?: boolean; /** * Blocks to appear in the category. Specifying this field will override * all existing blocks in the category. The ordering of the blocks is * determined by the ordering of this array. */ blocks?: ToolboxBlockDefinition[]; /** * Ordering of category groups */ groups?: string[]; } interface ToolboxBlockDefinition { /** * Internal id used to refer to this block or snippet, must be unique */ name: string; /** * Group label used to categorize block. Blocks are arranged with other * blocks that share the same group. */ group?: string; /** * Indicates an advanced API. Advanced APIs appear after basic ones in the * toolbox */ advanced?: boolean; /** * The weight for the block. Blocks are arranged in order of they appear in the category * definition's array but the weight can be specified in the case that other APIs are * dynamically added to the category (eg. loops.forever()) */ weight?: number; /** * Description of code to appear in the hover text */ jsDoc?: string; /** * TypeScript snippet of code to insert when dragged into editor */ snippet?: string; /** * Python snippet of code to insert when dragged into editor */ pySnippet?: string; /** * TypeScript name used for highlighting the snippet, uses name if not defined */ snippetName?: string; /** * Python name used for highlighting the snippet, uses name if not defined */ pySnippetName?: string; /** * Display just the snippet and nothing else. Should be set to true for * language constructs (eg. for-loops) and to false for function * calls (eg. Math.random()) */ snippetOnly?: boolean; /** * The return type of the block. This is used to determine the shape of the block rendered. */ retType?: string; /** * The block definition in XML for the blockly toolbox. */ blockXml?: string; /** * The Blockly block id used to identify this block. */ blockId?: string; } let initExtensionsAsync: (opts: ExtensionOptions) => Promise<ExtensionResult>; let initFieldExtensionsAsync: (opts: FieldExtensionOptions) => Promise<FieldExtensionResult>; interface NativeHostMessage { name?: string; download?: string; save?: string; cmd?: string; } let HELP_IMAGE_URI: string; function initEditorExtensionsAsync(): Promise<void>; } declare namespace pxt.editor { interface EditorMessage { /** * Constant identifier */ type: "pxteditor" | "pxthost" | "pxtpkgext" | "pxtsim"; /** * Original request id */ id?: string; /** * flag to request response */ response?: boolean; } interface EditorMessageResponse extends EditorMessage { /** * Additional response payload provided by the command */ resp?: any; /** * indicate if operation started or completed successfully */ success: boolean; /** * Error object if any */ error?: any; } interface EditorMessageRequest extends EditorMessage { /** * Request action */ action: "switchblocks" | "switchjavascript" | "startsimulator" | "restartsimulator" | "stopsimulator" | "hidesimulator" | "showsimulator" | "closeflyout" | "newproject" | "importproject" | "importtutorial" | "openheader" | "proxytosim" | "undo" | "redo" | "renderblocks" | "renderpython" | "setscale" | "startactivity" | "saveproject" | "unloadproject" | "shareproject" | "savelocalprojectstocloud" | "projectcloudstatus" | "requestprojectcloudstatus" | "convertcloudprojectstolocal" | "setlanguagerestriction" | "toggletrace" | "togglehighcontrast" | "sethighcontrast" | "togglegreenscreen" | "settracestate" | "setsimulatorfullscreen" | "print" | "pair" | "workspacesync" | "workspacereset" | "workspacesave" | "workspaceloaded" | "workspaceevent" | "workspacediagnostics" | "event" | "simevent" | "info" | "tutorialevent" | ExtInitializeType | ExtDataStreamType | ExtUserCodeType | ExtReadCodeType | ExtWriteCodeType; } /** * Request sent by the editor when a tick/error/expection is registered */ interface EditorMessageEventRequest extends EditorMessageRequest { action: "event"; tick: string; category?: string; message?: string; data?: Map<string | number>; } type EditorMessageTutorialEventRequest = EditorMessageTutorialProgressEventRequest | EditorMessageTutorialCompletedEventRequest | EditorMessageTutorialLoadedEventRequest | EditorMessageTutorialExitEventRequest; interface EditorMessageTutorialProgressEventRequest extends EditorMessageRequest { action: "tutorialevent"; tutorialEvent: "progress"; currentStep: number; totalSteps: number; isCompleted: boolean; tutorialId: string; projectHeaderId: string; } interface EditorMessageTutorialCompletedEventRequest extends EditorMessageRequest { action: "tutorialevent"; tutorialEvent: "completed"; tutorialId: string; projectHeaderId: string; } interface EditorMessageTutorialLoadedEventRequest extends EditorMessageRequest { action: "tutorialevent"; tutorialEvent: "loaded"; tutorialId: string; projectHeaderId: string; } interface EditorMessageTutorialExitEventRequest extends EditorMessageRequest { action: "tutorialevent"; tutorialEvent: "exit"; tutorialId: string; projectHeaderId: string; } interface EditorMessageStopRequest extends EditorMessageRequest { action: "stopsimulator"; /** * Indicates if simulator iframes should be unloaded or kept hot. */ unload?: boolean; } interface EditorMessageNewProjectRequest extends EditorMessageRequest { action: "newproject"; /** * Additional optional to create new project */ options?: ProjectCreationOptions; } interface EditorMessageSetScaleRequest extends EditorMessageRequest { action: "setscale"; scale: number; } interface EditorMessageSimulatorMessageProxyRequest extends EditorMessageRequest { action: "proxytosim"; /** * Content to send to the simulator */ content: any; } interface EditorWorkspaceSyncRequest extends EditorMessageRequest { /** * Synching projects from host into */ action: "workspacesync" | "workspacereset" | "workspaceloaded"; } interface EditorWorkspaceEvent extends EditorMessageRequest { action: "workspaceevent"; event: pxt.editor.events.Event; } interface EditorWorkspaceDiagnostics extends EditorMessageRequest { action: "workspacediagnostics"; operation: "compile" | "decompile" | "typecheck"; output: string; diagnostics: { code: number; category: "error" | "warning" | "message"; fileName?: string; start?: number; length?: number; line?: number; column?: number; endLine?: number; endColumn?: number; }[]; } interface EditorSyncState { filters?: pxt.editor.ProjectFilters; searchBar?: boolean; } interface EditorWorkspaceSyncResponse extends EditorMessageResponse { projects: pxt.workspace.Project[]; editor?: EditorSyncState; controllerId?: string; } interface EditorWorkspaceSaveRequest extends EditorMessageRequest { action: "workspacesave"; project: pxt.workspace.Project; } interface EditorMessageImportProjectRequest extends EditorMessageRequest { action: "importproject"; project: pxt.workspace.Project; filters?: pxt.editor.ProjectFilters; searchBar?: boolean; } interface EditorMessageSaveLocalProjectsToCloud extends EditorMessageRequest { action: "savelocalprojectstocloud"; headerIds: string[]; } interface EditorMessageSaveLocalProjectsToCloudResponse extends EditorMessageResponse { action: "savelocalprojectstocloud"; headerIdMap?: pxt.Map<string>; } interface EditorMessageProjectCloudStatus extends EditorMessageRequest { action: "projectcloudstatus"; headerId: string; status: pxt.cloud.CloudStatus; } interface EditorMessageRequestProjectCloudStatus extends EditorMessageRequest { action: "requestprojectcloudstatus"; headerIds: string[]; } interface EditorMessageConvertCloudProjectsToLocal extends EditorMessageRequest { action: "convertcloudprojectstolocal"; userId: string; } interface EditorMessageImportTutorialRequest extends EditorMessageRequest { action: "importtutorial"; markdown: string; } interface EditorMessageOpenHeaderRequest extends EditorMessageRequest { action: "openheader"; headerId: string; } interface EditorMessageRenderBlocksRequest extends EditorMessageRequest { action: "renderblocks"; ts: string; snippetMode?: boolean; layout?: pxt.blocks.BlockLayout; } interface EditorMessageRenderBlocksResponse { svg: SVGSVGElement; xml: Promise<any>; } interface EditorMessageRenderPythonRequest extends EditorMessageRequest { action: "renderpython"; ts: string; } interface EditorMessageRenderPythonResponse { python: string; } interface EditorSimulatorEvent extends EditorMessageRequest { action: "simevent"; subtype: "toplevelfinished" | "started" | "stopped" | "resumed"; } interface EditorSimulatorStoppedEvent extends EditorSimulatorEvent { subtype: "stopped"; exception?: string; } interface EditorMessageToggleTraceRequest extends EditorMessageRequest { action: "toggletrace"; intervalSpeed?: number; } interface EditorMessageSetTraceStateRequest extends EditorMessageRequest { action: "settracestate"; enabled: boolean; intervalSpeed?: number; } interface EditorMessageSetSimulatorFullScreenRequest extends EditorMessageRequest { action: "setsimulatorfullscreen"; enabled: boolean; } interface EditorMessageSetHighContrastRequest extends EditorMessageRequest { action: "sethighcontrast"; on: boolean; } interface EditorMessageStartActivity extends EditorMessageRequest { action: "startactivity"; activityType: "tutorial" | "example" | "recipe"; path: string; title?: string; previousProjectHeaderId?: string; carryoverPreviousCode?: boolean; } interface InfoMessage { versions: pxt.TargetVersions; locale: string; availableLocales?: string[]; } interface PackageExtensionData { ts: string; json?: any; } interface EditorPkgExtMessageRequest extends EditorMessageRequest { package: string; } interface EditorPkgExtMessageResponse extends EditorMessageResponse { package: string; } interface EditorSimulatorTickEvent extends EditorMessageEventRequest { type: "pxtsim"; } interface EditorShareRequest extends EditorMessageRequest { action: "shareproject"; headerId: string; projectName: string; } interface EditorShareResponse extends EditorMessageRequest { action: "shareproject"; script: Cloud.JsonScript; } interface EditorSetLanguageRestriction extends EditorMessageRequest { action: "setlanguagerestriction"; restriction: pxt.editor.LanguageRestriction; } /** * Binds incoming window messages to the project view. * Requires the "allowParentController" flag in the pxtarget.json/appTheme object. * * When the project view receives a request (EditorMessageRequest), * it starts the command and returns the result upon completion. * The response (EditorMessageResponse) contains the request id and result. * Some commands may be async, use the ``id`` field to correlate to the original request. */ function bindEditorMessages(getEditorAsync: () => Promise<IProjectView>): void; /** * Sends analytics messages upstream to container if any */ function enableControllerAnalytics(): void; /** * Determines if host messages should be posted */ function shouldPostHostMessages(): boolean; /** * Posts a message from the editor to the host */ function postHostMessageAsync(msg: EditorMessageRequest): Promise<EditorMessageResponse>; } declare namespace pxt.editor.events { type EditorType = 'blocks' | 'ts'; interface Event { type: string; editor: EditorType; } interface CreateEvent extends Event { type: "create"; blockId: string; } interface UIEvent extends Event { type: "ui"; action: "groupHelpClicked"; data?: pxt.Map<string>; } } declare namespace pxt.editor.experiments { interface Experiment { id: string; name: string; description: string; feedbackUrl?: string; enableOnline?: boolean; } function syncTheme(): AppTheme; function all(): Experiment[]; function clear(): void; function someEnabled(): boolean; function isEnabled(experiment: Experiment | string): boolean; function toggle(experiment: Experiment): void; function state(): string; function setState(experiment: Experiment, enabled: boolean): void; } declare namespace pxt.editor { interface DataStreams<T> { console?: T; messages?: T; } interface ExtensionFiles { code?: string; json?: string; jres?: string; asm?: string; } interface WriteExtensionFiles extends ExtensionFiles { dependencies?: pxt.Map<string>; } interface ExtensionMessage extends EditorMessage { type: "pxtpkgext"; } interface ExtensionResponse extends EditorMessageResponse { type: "pxtpkgext"; extId: string; } interface ExtensionRequest extends EditorMessageRequest { type: "pxtpkgext"; extId: string; body?: any; } /** * Events are fired by the editor on the extension iFrame. Extensions * receive events, they don't send them. */ interface ExtensionEvent extends ExtensionMessage { event: string; target: string; } /** * Event fired when the extension is loaded. */ interface LoadedEvent extends ExtensionEvent { event: "extloaded"; } /** * Event fired when the extension becomes visible. */ interface ShownEvent extends ExtensionEvent { event: "extshown"; } /** * Event fired when the extension becomes hidden. */ interface HiddenEvent extends ExtensionEvent { event: "exthidden"; body: HiddenReason; } type HiddenReason = "useraction" | "other"; /** * Event fired when console data is received */ interface ConsoleEvent extends ExtensionEvent { event: "extconsole"; body: { source: string; sim: boolean; data: string; }; } /** * Event fired when a message packet is received */ interface MessagePacketEvent extends ExtensionEvent { event: "extmessagepacket"; body: { source?: string; channel: string; data: Uint8Array; }; } /** * Event fired when extension is first shown. Extension * should send init request in response */ type ExtInitializeType = "extinit"; interface InitializeRequest extends ExtensionRequest { action: ExtInitializeType; body: string; } interface InitializeResponse extends ExtensionResponse { target?: pxt.AppTarget; } /** * Requests data stream event to be fired. Permission will * be requested if not already received. */ type ExtDataStreamType = "extdatastream"; interface DataStreamRequest extends ExtensionRequest { action: ExtDataStreamType; body: DataStreams<boolean>; } interface DataStreamResponse extends ExtensionResponse { resp: DataStreams<boolean>; } /** * Request to read the user's code. Will request permission if * not already granted */ type ExtUserCodeType = "extusercode"; interface UserCodeRequest extends ExtensionRequest { action: ExtUserCodeType; } interface UserCodeResponse extends ExtensionResponse { resp?: { [index: string]: string; }; } /** * Request to read the files saved by this extension */ type ExtReadCodeType = "extreadcode"; interface ReadCodeRequest extends ExtensionRequest { action: ExtReadCodeType; } interface ReadCodeResponse extends ExtensionResponse { action: ExtReadCodeType; body?: ExtensionFiles; } /** * Request to write the JSON and/or TS files saved * by this extension */ type ExtWriteCodeType = "extwritecode"; interface WriteCodeRequest extends ExtensionRequest { action: ExtWriteCodeType; body?: WriteExtensionFiles; } interface WriteCodeResponse extends ExtensionResponse { } } declare namespace pxt.vs { interface BlockDefiniton { commentAttr: pxtc.CommentAttrs; fns?: Map<string>; } interface MethodDef { sig: string; snippet: string; comment?: string; metaData?: pxtc.CommentAttrs; snippetOnly?: boolean; } interface NameDefiniton { fns: { [fn: string]: MethodDef; }; vars?: { [index: string]: string; }; metaData?: pxtc.CommentAttrs; builtin?: boolean; } type DefinitionMap = { [ns: string]: NameDefiniton; }; function syncModels(mainPkg: MainPackage, libs: { [path: string]: monaco.IDisposable; }, currFile: string, readOnly: boolean): void; function initMonacoAsync(element: HTMLElement): Promise<monaco.editor.IStandaloneCodeEditor>; function createEditor(element: HTMLElement): monaco.editor.IStandaloneCodeEditor; } declare namespace pxt.workspace { type ScriptText = pxt.Map<string>; interface Project { header?: Header; text?: ScriptText; } interface Asset { name: string; size: number; url: string; } type Version = any; interface File { header: Header; text: ScriptText; version: Version; } interface WorkspaceProvider { listAsync(): Promise<Header[]>; getAsync(h: Header): Promise<File>; setAsync(h: Header, prevVersion: Version, text?: ScriptText): Promise<Version>; deleteAsync?: (h: Header, prevVersion: Version) => Promise<void>; resetAsync(): Promise<void>; loadedAsync?: () => Promise<void>; getSyncState?: () => pxt.editor.EditorSyncState; saveScreenshotAsync?: (h: Header, screenshot: string, icon: string) => Promise<void>; saveAssetAsync?: (id: string, filename: string, data: Uint8Array) => Promise<void>; listAssetsAsync?: (id: string) => Promise<Asset[]>; fireEvent?: (ev: pxt.editor.events.Event) => void; } function freshHeader(name: string, modTime: number): Header; } declare namespace pxt.editor { interface TextEdit { range: monaco.Range; replacement: string; } interface MonacoFieldEditorHost { contentDiv(): HTMLDivElement; getText(range: monaco.Range): string; blocksInfo(): pxtc.BlocksInfo; package(): pxt.MainPackage; writeFileAsync(filename: string, content: string): Promise<void>; readFile(filename: string): string; } interface MonacoFieldEditor { getId(): string; showEditorAsync(fileType: FileType, editrange: monaco.Range, host: MonacoFieldEditorHost): Promise<TextEdit>; onClosed(): void; dispose(): void; } interface MonacoFieldEditorDefinition { id: string; matcher: MonacoFindArguments; foldMatches?: boolean; alwaysBuildOnClose?: boolean; glyphCssClass?: string; weight?: number; proto: { new (): MonacoFieldEditor; }; heightInPixels?: number; } interface MonacoFindArguments { searchString: string; isRegex: boolean; matchWholeWord: boolean; matchCase: boolean; validateRange?: (range: monaco.Range, model: monaco.editor.ITextModel) => monaco.Range; } function registerMonacoFieldEditor(name: string, definition: MonacoFieldEditorDefinition): void; function getMonacoFieldEditor(name: string): MonacoFieldEditorDefinition; } declare namespace pxt.editor { class MonacoReactFieldEditor<U> implements MonacoFieldEditor { private resolver; private rejecter; protected fileType: pxt.editor.FileType; protected editrange: monaco.Range; protected host: MonacoFieldEditorHost; protected fv: pxt.react.FieldEditorView<U>; getId(): string; showEditorAsync(fileType: FileType, editrange: monaco.Range, host: MonacoFieldEditorHost): Promise<TextEdit>; onClosed(): void; dispose(): void; protected initAsync(): Promise<void>; protected textToValue(text: string): U; protected resultToText(result: U): string; protected getFieldEditorId(): string; protected getOptions(): any; } } declare namespace pxt.editor { class MonacoSongEditor extends MonacoReactFieldEditor<pxt.Song> { protected isPython: boolean; protected isAsset: boolean; protected text: string; protected textToValue(text: string): pxt.Song; protected resultToText(result: pxt.Song): string; protected getFieldEditorId(): string; protected getOptions(): any; } const songEditorDefinition: MonacoFieldEditorDefinition; } declare namespace pxt.editor { class MonacoSoundEffectEditor extends MonacoReactFieldEditor<pxt.assets.Sound> { protected value: pxt.assets.Sound; protected textToValue(text: string): pxt.assets.Sound; protected resultToText(result: pxt.assets.Sound): string; protected getFieldEditorId(): string; protected getOptions(): any; } const soundEditorDefinition: MonacoFieldEditorDefinition; } declare namespace pxt.editor { class MonacoSpriteEditor extends MonacoReactFieldEditor<pxt.ProjectImage> { protected isPython: boolean; protected isAsset: boolean; protected textToValue(text: string): pxt.ProjectImage; protected resultToText(result: pxt.ProjectImage): string; protected getFieldEditorId(): string; protected getOptions(): any; } const spriteEditorDefinition: MonacoFieldEditorDefinition; } declare namespace pxt.editor { class MonacoTilemapEditor extends MonacoReactFieldEditor<pxt.ProjectTilemap> { protected isTilemapLiteral: boolean; protected tilemapLiteral: string; protected textToValue(text: string): pxt.ProjectTilemap; protected readTilemap(text: string): pxt.ProjectTilemap; protected resultToText(asset: pxt.ProjectTilemap): string; protected getFieldEditorId(): string; protected getOptions(): any; protected getCreateTilemapRange(): monaco.Range; } const tilemapEditorDefinition: MonacoFieldEditorDefinition; }