pxt-core 10.0.14 → 10.0.15

package/built/pxt.js

@@ -100259,6 +100259,14 @@ var ts;
                 return (n || "").split(/(?=[A-Z])/g).join(" ").toLowerCase();
             }
             Util.uncapitalize = uncapitalize;
+            function camelCaseToLowercaseWithSpaces(n) {
+                return n.replace(/([A-Z])/gm, ' $1').toLocaleLowerCase().trim();
+            }
+            Util.camelCaseToLowercaseWithSpaces = camelCaseToLowercaseWithSpaces;
+            function snakeCaseToLowercaseWithSpaces(n) {
+                return n.replace(/_/g, ' ').toLocaleLowerCase().trim();
+            }
+            Util.snakeCaseToLowercaseWithSpaces = snakeCaseToLowercaseWithSpaces;
             function range(len) {
                 let r = [];
                 for (let i = 0; i < len; ++i)
@@ -159069,6 +159077,11 @@ var pxsim;
             highlightBoardPin(pinNm) {
                 this.boardView.highlightPin(pinNm);
             }
+            removeEventListeners() {
+                if (this.boardView.removeEventListeners) {
+                    this.boardView.removeEventListeners();
+                }
+            }
             highlightBreadboardPin(rowCol) {
                 this.breadboard.highlightLoc(rowCol);
             }

package/built/pxtlib.d.ts

@@ -432,6 +432,8 @@ declare namespace ts.pxtc.Util {
     export let getRandomBuf: (buf: Uint8Array) => void;
     export function capitalize(n: string): string;
     export function uncapitalize(n: string): string;
+    export function camelCaseToLowercaseWithSpaces(n: string): string;
+    export function snakeCaseToLowercaseWithSpaces(n: string): string;
     export function range(len: number): number[];
     export function multipartPostAsync(uri: string, data?: any, filename?: string, filecontents?: string): Promise<HttpResponse>;
     export function toDataUri(data: string, mimetype?: string): string;

package/built/pxtlib.js

@@ -2573,6 +2573,14 @@ var ts;
                 return (n || "").split(/(?=[A-Z])/g).join(" ").toLowerCase();
             }
             Util.uncapitalize = uncapitalize;
+            function camelCaseToLowercaseWithSpaces(n) {
+                return n.replace(/([A-Z])/gm, ' $1').toLocaleLowerCase().trim();
+            }
+            Util.camelCaseToLowercaseWithSpaces = camelCaseToLowercaseWithSpaces;
+            function snakeCaseToLowercaseWithSpaces(n) {
+                return n.replace(/_/g, ' ').toLocaleLowerCase().trim();
+            }
+            Util.snakeCaseToLowercaseWithSpaces = snakeCaseToLowercaseWithSpaces;
             function range(len) {
                 let r = [];
                 for (let i = 0; i < len; ++i)

package/built/pxtservices/assetEditorDriver.d.ts

@@ -0,0 +1,11 @@
+import { IframeDriver } from "./iframeDriver";
+export declare class AssetEditorDriver extends IframeDriver {
+    constructor(frame: HTMLIFrameElement);
+    openAsset(assetId: string, assetType: pxt.AssetType, files: pxt.Map<string>, palette?: string[]): Promise<void>;
+    createAsset(assetType: pxt.AssetType, files: pxt.Map<string>, displayName?: string, palette?: string[]): Promise<void>;
+    saveAsset(): Promise<pxt.Map<string>>;
+    duplicateAsset(assetId: string, assetType: pxt.AssetType, files: pxt.Map<string>, palette?: string[]): Promise<void>;
+    addEventListener(event: "ready", handler: (ev: pxt.editor.AssetEditorReadyEvent) => void): void;
+    addEventListener(event: "done-clicked", handler: (ev: pxt.editor.AssetEditorRequestSaveEvent) => void): void;
+    protected handleMessage(event: MessageEvent<any>): void;
+}

package/built/pxtservices/editorDriver.d.ts

@@ -0,0 +1,76 @@
+/// <reference path="../../localtypings/pxteditor.d.ts" />
+import { IframeDriver } from "./iframeDriver";
+declare const MessageReceivedEvent = "message";
+declare const MessageSentEvent = "sent";
+export interface IframeWorkspaceStatus {
+    projects: pxt.workspace.Project[];
+    editor?: pxt.editor.EditorSyncState;
+    controllerId?: string;
+}
+export interface IFrameWorkspaceHost {
+    saveProject(project: pxt.workspace.Project): Promise<void>;
+    getWorkspaceProjects(): Promise<IframeWorkspaceStatus>;
+    resetWorkspace(): Promise<void>;
+    onWorkspaceLoaded?(): Promise<void>;
+}
+/**
+ * Manages communication with the editor iframe.
+ */
+export declare class EditorDriver extends IframeDriver {
+    iframe: HTMLIFrameElement;
+    host?: IFrameWorkspaceHost;
+    constructor(iframe: HTMLIFrameElement, host?: IFrameWorkspaceHost);
+    switchEditorLanguage(lang: "typescript" | "blocks" | "python"): Promise<void>;
+    setLanguageRestriction(restriction: pxt.editor.LanguageRestriction): Promise<void>;
+    startSimulator(): Promise<void>;
+    stopSimulator(unload?: boolean): Promise<void>;
+    restartSimulator(): Promise<void>;
+    hideSimulator(): Promise<void>;
+    showSimulator(): Promise<void>;
+    setSimulatorFullscreen(on: boolean): Promise<void>;
+    closeFlyout(): Promise<void>;
+    unloadProject(): Promise<void>;
+    saveProject(): Promise<void>;
+    undo(): Promise<void>;
+    redo(): Promise<void>;
+    setHighContrast(on: boolean): Promise<void>;
+    toggleHighContrast(): Promise<void>;
+    toggleGreenScreen(): Promise<void>;
+    toggleSloMo(intervalSpeed?: number): Promise<void>;
+    setSloMoEnabled(enabled: boolean, intervalSpeed?: number): Promise<void>;
+    printProject(): Promise<void>;
+    getInfo(): Promise<pxt.editor.InfoMessage>;
+    newProject(options: pxt.editor.ProjectCreationOptions): Promise<void>;
+    importProject(project: pxt.workspace.Project, filters?: pxt.editor.ProjectFilters, searchBar?: boolean): Promise<void>;
+    openHeader(headerId: string): Promise<void>;
+    shareHeader(headerId: string, projectName: string): Promise<pxt.editor.ShareData>;
+    startActivity(activityType: "tutorial" | "example" | "recipe", path: string, title?: string, previousProjectHeaderId?: string, carryoverPreviousCode?: boolean): Promise<void>;
+    importTutorial(markdown: string): Promise<void>;
+    pair(): Promise<void>;
+    decompileToBlocks(ts: string, snippetMode?: boolean, layout?: pxt.editor.BlockLayout): Promise<pxt.editor.EditorMessageRenderBlocksResponse>;
+    decompileToPython(ts: string): Promise<string>;
+    renderXml(xml: string): Promise<any>;
+    renderByBlockId(blockId: string): Promise<any>;
+    getToolboxCategories(advanced?: boolean): Promise<pxt.editor.ToolboxCategoryDefinition[]>;
+    runValidatorPlan(validatorPlan: pxt.blocks.ValidatorPlan, planLib: pxt.blocks.ValidatorPlan[]): Promise<pxt.blocks.EvaluationResult>;
+    saveLocalProjectsToCloud(headerIds: string[]): Promise<pxt.editor.EditorMessageSaveLocalProjectsToCloudResponse>;
+    convertCloudProjectsToLocal(userId: string): Promise<void>;
+    requestProjectCloudStatus(headerIds: string[]): Promise<void>;
+    addEventListener(event: typeof MessageSentEvent, handler: (ev: pxt.editor.EditorMessage) => void): void;
+    addEventListener(event: typeof MessageReceivedEvent, handler: (ev: pxt.editor.EditorMessage) => void): void;
+    addEventListener(event: "event", handler: (ev: pxt.editor.EditorMessageEventRequest) => void): void;
+    addEventListener(event: "simevent", handler: (ev: pxt.editor.EditorSimulatorEvent) => void): void;
+    addEventListener(event: "tutorialevent", handler: (ev: pxt.editor.EditorMessageTutorialEventRequest) => void): void;
+    addEventListener(event: "workspacesave", handler: (ev: pxt.editor.EditorWorkspaceSaveRequest) => void): void;
+    addEventListener(event: "workspaceevent", handler: (ev: pxt.editor.EditorWorkspaceEvent) => void): void;
+    addEventListener(event: "workspacereset", handler: (ev: pxt.editor.EditorWorkspaceSyncRequest) => void): void;
+    addEventListener(event: "workspacesync", handler: (ev: pxt.editor.EditorWorkspaceSyncRequest) => void): void;
+    addEventListener(event: "workspaceloaded", handler: (ev: pxt.editor.EditorWorkspaceSyncRequest) => void): void;
+    addEventListener(event: "workspacediagnostics", handler: (ev: pxt.editor.EditorWorkspaceDiagnostics) => void): void;
+    addEventListener(event: "editorcontentloaded", handler: (ev: pxt.editor.EditorContentLoadedRequest) => void): void;
+    addEventListener(event: "projectcloudstatus", handler: (ev: pxt.editor.EditorMessageProjectCloudStatus) => void): void;
+    sendMessage(message: pxt.editor.EditorMessageRequest): Promise<pxt.editor.EditorMessageResponse>;
+    protected handleMessage(event: MessageEvent): void;
+    protected handleWorkspaceSync(event: pxt.editor.EditorWorkspaceSyncRequest | pxt.editor.EditorWorkspaceSaveRequest): Promise<void>;
+}
+export {};

package/built/pxtservices/iframeDriver.d.ts

@@ -0,0 +1,37 @@
+/// <reference path="../../localtypings/pxteditor.d.ts" />
+declare type MessageHandler = (response: any) => void;
+interface PendingMessage {
+    original: pxt.editor.EditorMessageRequest;
+    resolve: MessageHandler;
+    reject: MessageHandler;
+}
+/**
+ * Abstract class for driving communication with an embedded iframe
+ */
+export declare abstract class IframeDriver {
+    iframe: HTMLIFrameElement;
+    protected readyForMessages: boolean;
+    protected messageQueue: pxt.editor.EditorMessageRequest[];
+    protected nextId: number;
+    protected pendingMessages: {
+        [index: string]: PendingMessage;
+    };
+    protected editorEventListeners: {
+        [index: string]: MessageHandler[];
+    };
+    protected port: MessagePort;
+    protected portRequestPending: boolean;
+    protected frameId: string;
+    constructor(iframe: HTMLIFrameElement);
+    protected abstract handleMessage(message: MessageEvent): void;
+    dispose(): void;
+    addEventListener(event: string, handler: (ev: any) => void): void;
+    removeEventListener(event: string, handler: (ev: any) => void): void;
+    protected onMessageReceived: (event: MessageEvent) => void;
+    protected resolvePendingMessage(event: MessageEvent): void;
+    protected fireEvent(event: string, data: any): void;
+    protected sendRequest(message: any): Promise<unknown>;
+    protected sendMessageCore(message?: any): void;
+    protected createMessagePort(): void;
+}
+export {};

package/built/pxtservices/iframeEmbeddedClient.d.ts

@@ -0,0 +1,19 @@
+declare type IframeClientSetMessagePortRequest = {
+    type: "iframeclientsetmessageport";
+};
+declare type IFrameClientReadyMessage = {
+    type: "iframeclientready";
+};
+export declare type IframeClientMessage = IframeClientSetMessagePortRequest | IFrameClientReadyMessage;
+export declare class IFrameEmbeddedClient {
+    protected messageHandler: (message: MessageEvent) => void;
+    protected frameId: string | undefined;
+    protected port: MessagePort;
+    constructor(messageHandler: (message: MessageEvent) => void);
+    dispose(): void;
+    postMessage(message: any): void;
+    protected onMessageReceived: (event: MessageEvent) => void;
+    protected postMessageCore(message: any): void;
+    protected sendReadyMessage(): void;
+}
+export {};

package/built/pxtsim.d.ts

@@ -1588,6 +1588,7 @@ declare namespace pxsim.visuals {
         getCoord(pinNm: string): Coord;
         getPinDist(): number;
         highlightPin(pinNm: string): void;
+        removeEventListeners?(): void;
     }
     function rgbToHsl(rgb: [number, number, number]): [number, number, number];
 }
@@ -1995,6 +1996,7 @@ declare namespace pxsim.visuals {
         private state;
         constructor(view: BoardView, opts: BoardHostOpts);
         highlightBoardPin(pinNm: string): void;
+        removeEventListeners(): void;
         highlightBreadboardPin(rowCol: BBLoc): void;
         highlightWire(wire: Wire): void;
         getView(): SVGElement;

package/built/pxtsim.js

@@ -9804,6 +9804,11 @@ var pxsim;
             highlightBoardPin(pinNm) {
                 this.boardView.highlightPin(pinNm);
             }
+            removeEventListeners() {
+                if (this.boardView.removeEventListeners) {
+                    this.boardView.removeEventListeners();
+                }
+            }
             highlightBreadboardPin(rowCol) {
                 this.breadboard.highlightLoc(rowCol);
             }

package/built/react-common/components/controls/LazyImage.d.ts

@@ -1,7 +1,9 @@
+/// <reference types="react" />
 import { ControlProps } from "../util";
 export interface LazyImageProps extends ControlProps {
     src: string;
     alt: string;
     title?: string;
+    loadingElement?: JSX.Element;
 }
 export declare const LazyImage: (props: LazyImageProps) => JSX.Element;