pxt-core 8.0.3 → 8.1.2

package/built/backendutils.js

@@ -689,13 +689,20 @@ var pxt;
         docs.prepTemplate = prepTemplate;
         function setupRenderer(renderer) {
             renderer.image = function (href, title, text) {
-                let out = '<img class="ui image" src="' + href + '" alt="' + text + '"';
-                if (title) {
-                    out += ' title="' + title + '"';
+                if (href.startsWith("youtube:")) {
+                    let out = '<div class="tutorial-video-embed"><iframe src="https://www.youtube.com/embed/' + href.split(":").pop()
+                        + '" title="' + title + '" frameborder="0" ' + 'allowFullScreen ' + 'allow="autoplay; picture-in-picture"></iframe></div>';
+                    return out;
+                }
+                else {
+                    let out = '<img class="ui image" src="' + href + '" alt="' + text + '"';
+                    if (title) {
+                        out += ' title="' + title + '"';
+                    }
+                    out += ' loading="lazy"';
+                    out += this.options.xhtml ? '/>' : '>';
+                    return out;
                 }
-                out += ' loading="lazy"';
-                out += this.options.xhtml ? '/>' : '>';
-                return out;
             };
             renderer.listitem = function (text) {
                 const m = /^\s*\[( |x)\]/i.exec(text);

package/built/pxt.js

@@ -106384,13 +106384,20 @@ var pxt;
         docs.prepTemplate = prepTemplate;
         function setupRenderer(renderer) {
             renderer.image = function (href, title, text) {
-                let out = '<img class="ui image" src="' + href + '" alt="' + text + '"';
-                if (title) {
-                    out += ' title="' + title + '"';
+                if (href.startsWith("youtube:")) {
+                    let out = '<div class="tutorial-video-embed"><iframe src="https://www.youtube.com/embed/' + href.split(":").pop()
+                        + '" title="' + title + '" frameborder="0" ' + 'allowFullScreen ' + 'allow="autoplay; picture-in-picture"></iframe></div>';
+                    return out;
+                }
+                else {
+                    let out = '<img class="ui image" src="' + href + '" alt="' + text + '"';
+                    if (title) {
+                        out += ' title="' + title + '"';
+                    }
+                    out += ' loading="lazy"';
+                    out += this.options.xhtml ? '/>' : '>';
+                    return out;
                 }
-                out += ' loading="lazy"';
-                out += this.options.xhtml ? '/>' : '>';
-                return out;
             };
             renderer.listitem = function (text) {
                 const m = /^\s*\[( |x)\]/i.exec(text);
@@ -115688,7 +115695,7 @@ var pxt;
                 id,
                 type: "tilemap" /* Tilemap */,
                 meta: {
-                    displayName: id
+                    displayName: name || id
                 },
                 data: data
             });
@@ -139471,6 +139478,7 @@ var ts;
                 let snippet;
                 if (preDefinedSnippet) {
                     snippet = [preDefinedSnippet];
+                    snippetPrefix = undefined;
                 }
                 else {
                     snippet = [fnName];
@@ -153186,6 +153194,8 @@ var pxsim;
             frame.frameBorder = "0";
             frame.dataset['runid'] = this.runId;
             frame.dataset['origin'] = new URL(furl).origin || "*";
+            if (this._runOptions.autofocus)
+                frame.setAttribute("autofocus", "true");
             wrapper.appendChild(frame);
             const i = document.createElement("i");
             i.className = "videoplay xicon icon";
@@ -153439,11 +153449,14 @@ var pxsim;
             return true;
         }
         handleMessage(msg, source) {
+            var _a;
             switch (msg.type || '') {
                 case 'ready': {
                     const frameid = msg.frameid;
                     const frame = document.getElementById(frameid);
                     if (frame) {
+                        if ((_a = this._runOptions) === null || _a === void 0 ? void 0 : _a.autofocus)
+                            frame.focus();
                         this.startFrame(frame);
                         if (this.options.revealElement)
                             this.options.revealElement(frame);

package/built/pxtblockly.js

@@ -15502,6 +15502,8 @@ var pxtblockly;
                 getScaledBBox: () => bbox
             };
             Blockly.WidgetDiv.show(widgetOwner, this.sourceBlock_.RTL, () => {
+                if (document.activeElement && document.activeElement.tagName === "INPUT")
+                    document.activeElement.blur();
                 fv.hide();
                 widgetDiv.classList.remove("sound-effect-editor-widget");
                 widgetDiv.style.transform = "";

package/built/pxtblocks.js

@@ -11940,6 +11940,8 @@ var pxtblockly;
                 getScaledBBox: () => bbox
             };
             Blockly.WidgetDiv.show(widgetOwner, this.sourceBlock_.RTL, () => {
+                if (document.activeElement && document.activeElement.tagName === "INPUT")
+                    document.activeElement.blur();
                 fv.hide();
                 widgetDiv.classList.remove("sound-effect-editor-widget");
                 widgetDiv.style.transform = "";

package/built/pxtcompiler.js

@@ -18441,6 +18441,7 @@ var ts;
                 let snippet;
                 if (preDefinedSnippet) {
                     snippet = [preDefinedSnippet];
+                    snippetPrefix = undefined;
                 }
                 else {
                     snippet = [fnName];

package/built/pxteditor.d.ts

@@ -1045,6 +1045,7 @@ declare namespace pxt.editor {
         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;
@@ -1068,6 +1069,16 @@ declare namespace pxt.editor {
         protected getOptions(): any;
     }
 }
+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;

package/built/pxteditor.js

@@ -930,6 +930,203 @@ var pxt;
 /// <reference path="./monacoFieldEditor.ts" />
 /// <reference path="./field_react.ts" />
 var pxt;
+(function (pxt) {
+    var editor;
+    (function (editor) {
+        const fieldEditorId = "soundeffect-editor";
+        // music.createSoundEffect(WaveShape.Sine, 5000, 0, 255, 0, 500, SoundExpressionEffect.None, InterpolationCurve.Linear
+        class MonacoSoundEffectEditor extends editor.MonacoReactFieldEditor {
+            textToValue(text) {
+                const out = defaultSound();
+                this.value = out;
+                const argMatch = /\(([^)]*)\)/.exec(text);
+                const args = argMatch[1].split(",").map(a => a.replace(/\s/g, ""));
+                if (args.length !== 8)
+                    return out;
+                switch (args[0]) {
+                    case "WaveShape.Sawtooth":
+                        out.wave = "sawtooth";
+                        break;
+                    case "WaveShape.Square":
+                        out.wave = "square";
+                        break;
+                    case "WaveShape.Noise":
+                        out.wave = "noise";
+                        break;
+                    case "WaveShape.Triangle":
+                        out.wave = "triangle";
+                        break;
+                    case "WaveShape.Sine":
+                    default:
+                        out.wave = "sine";
+                        break;
+                }
+                const withDefault = (val, def) => {
+                    return isNaN(val) ? def : val;
+                };
+                out.startFrequency = withDefault(parseInt(args[1]), out.startFrequency);
+                out.endFrequency = withDefault(parseInt(args[2]), out.endFrequency);
+                out.startVolume = withDefault(parseInt(args[3]), out.startVolume);
+                out.endVolume = withDefault(parseInt(args[4]), out.endVolume);
+                out.duration = withDefault(parseInt(args[5]), out.duration);
+                switch (args[6]) {
+                    case "SoundExpressionEffect.Vibrato":
+                        out.effect = "vibrato";
+                        break;
+                    case "SoundExpressionEffect.Tremolo":
+                        out.effect = "tremolo";
+                        break;
+                    case "SoundExpressionEffect.Warble":
+                        out.effect = "warble";
+                        break;
+                    case "SoundExpressionEffect.None":
+                    default:
+                        out.effect = "none";
+                        break;
+                }
+                switch (args[7]) {
+                    case "InterpolationCurve.Logarithmic":
+                        out.interpolation = "logarithmic";
+                        break;
+                    case "InterpolationCurve.Curve":
+                        out.interpolation = "curve";
+                        break;
+                    case "InterpolationCurve.Linear":
+                    default:
+                        out.interpolation = "linear";
+                        break;
+                }
+                return out;
+            }
+            resultToText(result) {
+                result = this.value;
+                let waveShape;
+                switch (result.wave) {
+                    case "sine":
+                        waveShape = "WaveShape.Sine";
+                        break;
+                    case "square":
+                        waveShape = "WaveShape.Square";
+                        break;
+                    case "triangle":
+                        waveShape = "WaveShape.Triangle";
+                        break;
+                    case "noise":
+                        waveShape = "WaveShape.Noise";
+                        break;
+                    case "sawtooth":
+                        waveShape = "WaveShape.Sawtooth";
+                        break;
+                }
+                let effect;
+                switch (result.effect) {
+                    case "vibrato":
+                        effect = "SoundExpressionEffect.Vibrato";
+                        break;
+                    case "tremolo":
+                        effect = "SoundExpressionEffect.Tremolo";
+                        break;
+                    case "warble":
+                        effect = "SoundExpressionEffect.Warble";
+                        break;
+                    case "none":
+                        effect = "SoundExpressionEffect.None";
+                        break;
+                }
+                let interpolation;
+                switch (result.interpolation) {
+                    case "curve":
+                        interpolation = "InterpolationCurve.Curve";
+                        break;
+                    case "linear":
+                        interpolation = "InterpolationCurve.Linear";
+                        break;
+                    case "logarithmic":
+                        interpolation = "InterpolationCurve.Logarithmic";
+                        break;
+                }
+                return `music.createSoundEffect(${waveShape}, ${Math.round(result.startFrequency)}, ${Math.round(result.endFrequency)}, ${Math.round(result.startVolume)}, ${Math.round(result.endVolume)}, ${Math.round(result.duration)}, ${effect}, ${interpolation})`;
+            }
+            getFieldEditorId() {
+                return fieldEditorId;
+            }
+            getOptions() {
+                return {
+                    onClose: () => this.fv.hide(),
+                    onSoundChange: (newValue) => this.value = newValue,
+                    initialSound: this.value,
+                    useFlex: true
+                };
+            }
+        }
+        editor.MonacoSoundEffectEditor = MonacoSoundEffectEditor;
+        function validateRange(range, model) {
+            let currentLine = range.startLineNumber;
+            let currentColumn = 0;
+            let foundStart = false;
+            let parenCount = 0;
+            const methodName = "createSoundEffect";
+            const totalLines = model.getLineCount();
+            while (currentLine < totalLines) {
+                const lineContent = model.getLineContent(currentLine);
+                const startIndex = lineContent.indexOf(methodName);
+                if (startIndex !== -1) {
+                    foundStart = true;
+                    currentColumn = startIndex + methodName.length;
+                }
+                if (foundStart) {
+                    while (currentColumn < lineContent.length) {
+                        const currentChar = lineContent.charAt(currentColumn);
+                        if (currentChar === "(") {
+                            parenCount++;
+                        }
+                        else if (currentChar === ")") {
+                            parenCount--;
+                            if (parenCount === 0) {
+                                return new monaco.Range(range.startLineNumber, range.startColumn, currentLine, currentColumn + model.getLineMinColumn(currentLine) + 1);
+                            }
+                        }
+                        currentColumn++;
+                    }
+                }
+                currentColumn = 0;
+                currentLine++;
+            }
+            return undefined;
+        }
+        function defaultSound() {
+            return {
+                wave: "sine",
+                startFrequency: 5000,
+                endFrequency: 0,
+                startVolume: 255,
+                endVolume: 0,
+                duration: 500,
+                effect: "none",
+                interpolation: "linear"
+            };
+        }
+        editor.soundEditorDefinition = {
+            id: fieldEditorId,
+            foldMatches: true,
+            glyphCssClass: "fas fa-music sprite-focus-hover",
+            heightInPixels: 510,
+            matcher: {
+                // match both JS and python
+                searchString: "music\\s*\\.\\s*createSoundEffect\\s*\\(",
+                isRegex: true,
+                matchCase: true,
+                matchWholeWord: false,
+                validateRange
+            },
+            proto: MonacoSoundEffectEditor
+        };
+        editor.registerMonacoFieldEditor(fieldEditorId, editor.soundEditorDefinition);
+    })(editor = pxt.editor || (pxt.editor = {}));
+})(pxt || (pxt = {}));
+/// <reference path="./monacoFieldEditor.ts" />
+/// <reference path="./field_react.ts" />
+var pxt;
 (function (pxt) {
     var editor;
     (function (editor) {
@@ -1048,8 +1245,8 @@ var pxt;
                 let proj;
                 let id;
                 if (name) {
-                    let id = ts.pxtc.escapeIdentifier(name);
-                    proj = project.getTilemap(id);
+                    id = ts.pxtc.escapeIdentifier(name);
+                    proj = project.getTilemap(id) || project.lookupAssetByName("tilemap" /* Tilemap */, name);
                 }
                 if (!proj) {
                     let tileWidth = 16;

package/built/pxtlib.js

@@ -8698,13 +8698,20 @@ var pxt;
         docs.prepTemplate = prepTemplate;
         function setupRenderer(renderer) {
             renderer.image = function (href, title, text) {
-                let out = '<img class="ui image" src="' + href + '" alt="' + text + '"';
-                if (title) {
-                    out += ' title="' + title + '"';
+                if (href.startsWith("youtube:")) {
+                    let out = '<div class="tutorial-video-embed"><iframe src="https://www.youtube.com/embed/' + href.split(":").pop()
+                        + '" title="' + title + '" frameborder="0" ' + 'allowFullScreen ' + 'allow="autoplay; picture-in-picture"></iframe></div>';
+                    return out;
+                }
+                else {
+                    let out = '<img class="ui image" src="' + href + '" alt="' + text + '"';
+                    if (title) {
+                        out += ' title="' + title + '"';
+                    }
+                    out += ' loading="lazy"';
+                    out += this.options.xhtml ? '/>' : '>';
+                    return out;
                 }
-                out += ' loading="lazy"';
-                out += this.options.xhtml ? '/>' : '>';
-                return out;
             };
             renderer.listitem = function (text) {
                 const m = /^\s*\[( |x)\]/i.exec(text);
@@ -18002,7 +18009,7 @@ var pxt;
                 id,
                 type: "tilemap" /* Tilemap */,
                 meta: {
-                    displayName: id
+                    displayName: name || id
                 },
                 data: data
             });

package/built/pxtrunner.d.ts

@@ -97,6 +97,7 @@ declare namespace pxt.runner {
         dependencies?: string[];
         builtJsInfo?: pxtc.BuiltSimJsInfo;
         single?: boolean;
+        autofocus?: boolean;
     }
     let mainPkg: pxt.MainPackage;
     function initFooter(footer: HTMLElement, shareId?: string): void;

package/built/pxtrunner.js

@@ -1749,7 +1749,8 @@ var pxt;
                 highContrast: simOptions.highContrast,
                 storedState: storedState,
                 light: simOptions.light,
-                single: simOptions.single
+                single: simOptions.single,
+                autofocus: simOptions.autofocus
             };
             if (pxt.appTarget.simulator && !simOptions.fullScreen)
                 runOptions.aspectRatio = parts.length && pxt.appTarget.simulator.partsAspectRatio

package/built/pxtsim.d.ts

@@ -1268,6 +1268,7 @@ declare namespace pxsim {
         ipc?: boolean;
         dependencies?: Map<string>;
         single?: boolean;
+        autofocus?: boolean;
     }
     interface HwDebugger {
         postMessage: (msg: pxsim.SimulatorMessage) => void;

package/built/pxtsim.js

@@ -6309,6 +6309,8 @@ var pxsim;
             frame.frameBorder = "0";
             frame.dataset['runid'] = this.runId;
             frame.dataset['origin'] = new URL(furl).origin || "*";
+            if (this._runOptions.autofocus)
+                frame.setAttribute("autofocus", "true");
             wrapper.appendChild(frame);
             const i = document.createElement("i");
             i.className = "videoplay xicon icon";
@@ -6562,11 +6564,14 @@ var pxsim;
             return true;
         }
         handleMessage(msg, source) {
+            var _a;
             switch (msg.type || '') {
                 case 'ready': {
                     const frameid = msg.frameid;
                     const frame = document.getElementById(frameid);
                     if (frame) {
+                        if ((_a = this._runOptions) === null || _a === void 0 ? void 0 : _a.autofocus)
+                            frame.focus();
                         this.startFrame(frame);
                         if (this.options.revealElement)
                             this.options.revealElement(frame);

package/built/server.js

@@ -1026,7 +1026,7 @@ function serveAsync(options) {
             return;
         }
         let publicDir = path.join(nodeutil.pxtCoreDir, "webapp/public");
-        if (pathname == "/--embed") {
+        if (pathname == "/--embed" || pathname === "/---embed") {
             sendFile(path.join(publicDir, 'embed.js'));
             return;
         }