pxt-core 7.5.32 → 7.5.35

package/built/pxt.js

@@ -101518,6 +101518,7 @@ var pxt;
                     shadowBlockId: def.shadowBlockId,
                     type: fn.namespace,
                     defaultValue: defaultValue,
+                    definitionIndex: defParameters.indexOf(def),
                     // Normally we pass ths actual parameter name, but the "this" parameter doesn't have one
                     fieldEditor: fieldEditor(defName, THIS_NAME),
                     fieldOptions: fieldOptions(defName, THIS_NAME),
@@ -101547,6 +101548,7 @@ var pxt;
                             type: p.type,
                             defaultValue: isVarOrArray ? (def.varName || p.default) : p.default,
                             definitionName: defName,
+                            definitionIndex: def ? defParameters.indexOf(def) : i,
                             shadowBlockId: def && def.shadowBlockId,
                             isOptional: defParameters ? defParameters.indexOf(def) >= optionalStart : false,
                             fieldEditor: fieldEditor(defName, p.name),
@@ -114378,7 +114380,11 @@ var pxt;
         assets.MAX_FREQUENCY = 5000;
         assets.MAX_VOLUME = 255;
         function renderSoundPath(sound, width, height) {
-            const { startFrequency, endFrequency, startVolume, endVolume, wave, interpolation } = sound;
+            let { startFrequency, endFrequency, startVolume, endVolume, wave, interpolation } = sound;
+            startFrequency = Math.max(Math.min(startFrequency, assets.MAX_FREQUENCY), 1);
+            endFrequency = Math.max(Math.min(endFrequency, assets.MAX_FREQUENCY), 1);
+            startVolume = Math.max(Math.min(startVolume, assets.MAX_VOLUME), 0);
+            endVolume = Math.max(Math.min(endVolume, assets.MAX_VOLUME), 0);
             // To make the graph appear consistent with the implementation, use a seeded random for the noise waveform.
             // The numbers are still nonsense but at least this reflects that it's deterministic.
             const random = new SeededRandom(startFrequency + endFrequency + 1);
@@ -114419,6 +114425,7 @@ var pxt;
             const random = new SeededRandom(frequency);
             if (wave === "noise")
                 frequency = random.randomRange(500, 5000);
+            frequency = Math.max(Math.min(frequency, assets.MAX_FREQUENCY), 1);
             const amplitude = (volume / assets.MAX_VOLUME) * (height - 2) / 2;
             const waveHalfWidth = (width / (frequency * timeBase / 1000)) / 2;
             let numSegments = Math.ceil(width / (waveHalfWidth * 2));
@@ -125440,29 +125447,7 @@ ${output}</xml>`;
                 }
                 function emitValueNode(n) {
                     write(`<value name="${n.name}">`);
-                    let emitShadowOnly = false;
-                    if (n.value.kind === "expr") {
-                        const value = n.value;
-                        if (value.type === numberType && n.shadowType === minmaxNumberType) {
-                            value.type = minmaxNumberType;
-                            value.fields[0].name = 'SLIDER';
-                            value.mutation = n.shadowMutation;
-                        }
-                        emitShadowOnly = value.type === n.shadowType;
-                        if (!emitShadowOnly) {
-                            switch (value.type) {
-                                case "math_number":
-                                case "math_number_minmax":
-                                case "math_integer":
-                                case "math_whole_number":
-                                case "logic_boolean":
-                                case "text":
-                                    emitShadowOnly = !n.shadowType;
-                                    break;
-                            }
-                        }
-                    }
-                    if (emitShadowOnly) {
+                    if (shouldEmitShadowOnly(n)) {
                         emitOutputNode(n.value, true);
                     }
                     else {
@@ -126646,7 +126631,6 @@ ${output}</xml>`;
                         switch (e.kind) {
                             case SK.FunctionExpression:
                             case SK.ArrowFunction:
-                                let expBody = e.body;
                                 const m = getDestructuringMutation(e);
                                 let mustPopLocalScope = false;
                                 if (m) {
@@ -126774,7 +126758,20 @@ ${output}</xml>`;
                         if (!r.mutation)
                             r.mutation = {};
                         if (attributes.compileHiddenArguments) {
-                            r.mutation["_expanded"] = "0";
+                            // Only expand the optional arguments that do not map to shadow blocks
+                            let nonOptional = 0;
+                            let expandCount = 0;
+                            for (const arg of args) {
+                                const aName = pxtc.U.htmlEscape(arg.param.definitionName);
+                                const input = r.inputs.find(i => i.name === aName);
+                                if (!arg.param.isOptional) {
+                                    nonOptional++;
+                                }
+                                else if (input && !shouldEmitShadowOnly(input)) {
+                                    expandCount = Math.max(arg.param.definitionIndex - nonOptional + 1, expandCount);
+                                }
+                            }
+                            r.mutation["_expanded"] = expandCount.toString();
                         }
                         else {
                             r.mutation["_expanded"] = optionalCount.toString();
@@ -128178,6 +128175,31 @@ ${output}</xml>`;
                     }
                 }
             }
+            function shouldEmitShadowOnly(n) {
+                let emitShadowOnly = false;
+                if (n.value.kind === "expr") {
+                    const value = n.value;
+                    if (value.type === numberType && n.shadowType === minmaxNumberType) {
+                        value.type = minmaxNumberType;
+                        value.fields[0].name = 'SLIDER';
+                        value.mutation = n.shadowMutation;
+                    }
+                    emitShadowOnly = value.type === n.shadowType;
+                    if (!emitShadowOnly) {
+                        switch (value.type) {
+                            case "math_number":
+                            case "math_number_minmax":
+                            case "math_integer":
+                            case "math_whole_number":
+                            case "logic_boolean":
+                            case "text":
+                                emitShadowOnly = !n.shadowType;
+                                break;
+                        }
+                    }
+                }
+                return emitShadowOnly;
+            }
         })(decompiler = pxtc.decompiler || (pxtc.decompiler = {}));
     })(pxtc = ts.pxtc || (ts.pxtc = {}));
 })(ts || (ts = {}));
@@ -152908,6 +152930,7 @@ var pxsim;
             frame.frameBorder = "0";
             frame.dataset['runid'] = this.runId;
             frame.dataset['origin'] = new URL(furl).origin || "*";
+            frame.dataset['hidesimbuttons'] = this._runOptions.hideSimButtons ? "true" : "false";
             wrapper.appendChild(frame);
             const i = document.createElement("i");
             i.className = "videoplay xicon icon";

package/built/pxtblockly.js

@@ -7559,11 +7559,10 @@ var pxt;
                 block.appendChild(createShadowValue(info, t, t.shadowBlockId || "variables_get", t.defaultValue || t.definitionName));
             }
             if (fn.parameters) {
-                comp.parameters.filter(pr => !pr.isOptional &&
-                    (primitiveTypeRegex.test(pr.type)
-                        || primitiveTypeRegex.test(isArrayType(pr.type))
-                        || pr.shadowBlockId
-                        || pr.defaultValue))
+                comp.parameters.filter(pr => primitiveTypeRegex.test(pr.type)
+                    || primitiveTypeRegex.test(isArrayType(pr.type))
+                    || pr.shadowBlockId
+                    || pr.defaultValue)
                     .forEach(pr => {
                     block.appendChild(createShadowValue(info, pr));
                 });

package/built/pxtblocks.js

@@ -3997,11 +3997,10 @@ var pxt;
                 block.appendChild(createShadowValue(info, t, t.shadowBlockId || "variables_get", t.defaultValue || t.definitionName));
             }
             if (fn.parameters) {
-                comp.parameters.filter(pr => !pr.isOptional &&
-                    (primitiveTypeRegex.test(pr.type)
-                        || primitiveTypeRegex.test(isArrayType(pr.type))
-                        || pr.shadowBlockId
-                        || pr.defaultValue))
+                comp.parameters.filter(pr => primitiveTypeRegex.test(pr.type)
+                    || primitiveTypeRegex.test(isArrayType(pr.type))
+                    || pr.shadowBlockId
+                    || pr.defaultValue)
                     .forEach(pr => {
                     block.appendChild(createShadowValue(info, pr));
                 });

package/built/pxtcompiler.js

@@ -4485,29 +4485,7 @@ ${output}</xml>`;
                 }
                 function emitValueNode(n) {
                     write(`<value name="${n.name}">`);
-                    let emitShadowOnly = false;
-                    if (n.value.kind === "expr") {
-                        const value = n.value;
-                        if (value.type === numberType && n.shadowType === minmaxNumberType) {
-                            value.type = minmaxNumberType;
-                            value.fields[0].name = 'SLIDER';
-                            value.mutation = n.shadowMutation;
-                        }
-                        emitShadowOnly = value.type === n.shadowType;
-                        if (!emitShadowOnly) {
-                            switch (value.type) {
-                                case "math_number":
-                                case "math_number_minmax":
-                                case "math_integer":
-                                case "math_whole_number":
-                                case "logic_boolean":
-                                case "text":
-                                    emitShadowOnly = !n.shadowType;
-                                    break;
-                            }
-                        }
-                    }
-                    if (emitShadowOnly) {
+                    if (shouldEmitShadowOnly(n)) {
                         emitOutputNode(n.value, true);
                     }
                     else {
@@ -5691,7 +5669,6 @@ ${output}</xml>`;
                         switch (e.kind) {
                             case SK.FunctionExpression:
                             case SK.ArrowFunction:
-                                let expBody = e.body;
                                 const m = getDestructuringMutation(e);
                                 let mustPopLocalScope = false;
                                 if (m) {
@@ -5819,7 +5796,20 @@ ${output}</xml>`;
                         if (!r.mutation)
                             r.mutation = {};
                         if (attributes.compileHiddenArguments) {
-                            r.mutation["_expanded"] = "0";
+                            // Only expand the optional arguments that do not map to shadow blocks
+                            let nonOptional = 0;
+                            let expandCount = 0;
+                            for (const arg of args) {
+                                const aName = pxtc.U.htmlEscape(arg.param.definitionName);
+                                const input = r.inputs.find(i => i.name === aName);
+                                if (!arg.param.isOptional) {
+                                    nonOptional++;
+                                }
+                                else if (input && !shouldEmitShadowOnly(input)) {
+                                    expandCount = Math.max(arg.param.definitionIndex - nonOptional + 1, expandCount);
+                                }
+                            }
+                            r.mutation["_expanded"] = expandCount.toString();
                         }
                         else {
                             r.mutation["_expanded"] = optionalCount.toString();
@@ -7223,6 +7213,31 @@ ${output}</xml>`;
                     }
                 }
             }
+            function shouldEmitShadowOnly(n) {
+                let emitShadowOnly = false;
+                if (n.value.kind === "expr") {
+                    const value = n.value;
+                    if (value.type === numberType && n.shadowType === minmaxNumberType) {
+                        value.type = minmaxNumberType;
+                        value.fields[0].name = 'SLIDER';
+                        value.mutation = n.shadowMutation;
+                    }
+                    emitShadowOnly = value.type === n.shadowType;
+                    if (!emitShadowOnly) {
+                        switch (value.type) {
+                            case "math_number":
+                            case "math_number_minmax":
+                            case "math_integer":
+                            case "math_whole_number":
+                            case "logic_boolean":
+                            case "text":
+                                emitShadowOnly = !n.shadowType;
+                                break;
+                        }
+                    }
+                }
+                return emitShadowOnly;
+            }
         })(decompiler = pxtc.decompiler || (pxtc.decompiler = {}));
     })(pxtc = ts.pxtc || (ts.pxtc = {}));
 })(ts || (ts = {}));

package/built/pxtlib.d.ts

@@ -627,6 +627,7 @@ declare namespace pxt.blocks {
         actualName: string;
         type?: string;
         definitionName: string;
+        definitionIndex?: number;
         shadowBlockId?: string;
         defaultValue?: string;
         isOptional?: boolean;

package/built/pxtlib.js

@@ -3832,6 +3832,7 @@ var pxt;
                     shadowBlockId: def.shadowBlockId,
                     type: fn.namespace,
                     defaultValue: defaultValue,
+                    definitionIndex: defParameters.indexOf(def),
                     // Normally we pass ths actual parameter name, but the "this" parameter doesn't have one
                     fieldEditor: fieldEditor(defName, THIS_NAME),
                     fieldOptions: fieldOptions(defName, THIS_NAME),
@@ -3861,6 +3862,7 @@ var pxt;
                             type: p.type,
                             defaultValue: isVarOrArray ? (def.varName || p.default) : p.default,
                             definitionName: defName,
+                            definitionIndex: def ? defParameters.indexOf(def) : i,
                             shadowBlockId: def && def.shadowBlockId,
                             isOptional: defParameters ? defParameters.indexOf(def) >= optionalStart : false,
                             fieldEditor: fieldEditor(defName, p.name),
@@ -16692,7 +16694,11 @@ var pxt;
         assets.MAX_FREQUENCY = 5000;
         assets.MAX_VOLUME = 255;
         function renderSoundPath(sound, width, height) {
-            const { startFrequency, endFrequency, startVolume, endVolume, wave, interpolation } = sound;
+            let { startFrequency, endFrequency, startVolume, endVolume, wave, interpolation } = sound;
+            startFrequency = Math.max(Math.min(startFrequency, assets.MAX_FREQUENCY), 1);
+            endFrequency = Math.max(Math.min(endFrequency, assets.MAX_FREQUENCY), 1);
+            startVolume = Math.max(Math.min(startVolume, assets.MAX_VOLUME), 0);
+            endVolume = Math.max(Math.min(endVolume, assets.MAX_VOLUME), 0);
             // To make the graph appear consistent with the implementation, use a seeded random for the noise waveform.
             // The numbers are still nonsense but at least this reflects that it's deterministic.
             const random = new SeededRandom(startFrequency + endFrequency + 1);
@@ -16733,6 +16739,7 @@ var pxt;
             const random = new SeededRandom(frequency);
             if (wave === "noise")
                 frequency = random.randomRange(500, 5000);
+            frequency = Math.max(Math.min(frequency, assets.MAX_FREQUENCY), 1);
             const amplitude = (volume / assets.MAX_VOLUME) * (height - 2) / 2;
             const waveHalfWidth = (width / (frequency * timeBase / 1000)) / 2;
             let numSegments = Math.ceil(width / (waveHalfWidth * 2));

package/built/pxtrunner.d.ts

@@ -91,6 +91,7 @@ declare namespace pxt.runner {
         id?: string;
         code?: string;
         assets?: string;
+        hideSimButtons?: boolean;
         highContrast?: boolean;
         light?: boolean;
         fullScreen?: boolean;

package/built/pxtrunner.js

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

package/built/pxtsim.d.ts

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

package/built/pxtsim.js

@@ -6308,6 +6308,7 @@ var pxsim;
             frame.frameBorder = "0";
             frame.dataset['runid'] = this.runId;
             frame.dataset['origin'] = new URL(furl).origin || "*";
+            frame.dataset['hidesimbuttons'] = this._runOptions.hideSimButtons ? "true" : "false";
             wrapper.appendChild(frame);
             const i = document.createElement("i");
             i.className = "videoplay xicon icon";