pxt-core 13.2.13 → 13.2.15

package/built/pxtcompiler.js

@@ -10247,7 +10247,7 @@ var ts;
                         optstarget = enabled.target;
                     }
                 }
-                pxtc.hexfile.setupFor(optstarget, extinfo || pxtc.emptyExtInfo(), res);
+                pxtc.hexfile.setupFor(optstarget, extinfo || pxtc.emptyExtInfo(pxt.appTarget.compileService), res);
                 pxtc.hexfile.setupInlineAssembly(opts);
             }
             let bin = new Binary();
@@ -17202,7 +17202,7 @@ __flash_checksums:
             const opts0 = pxtc.U.flatClone(opts);
             // normally, this would already have been done, but if the main variant
             // is disabled, another variant may be set up
-            hexfile.setupFor(opts.target, opts.extinfo || pxtc.emptyExtInfo(), cres);
+            hexfile.setupFor(opts.target, opts.extinfo || pxtc.emptyExtInfo(pxt.appTarget.compileService), cres);
             assembleAndPatch(src, bin, opts, cres);
             if (!cres.builtVariants) {
                 cres.builtVariants = [];

package/built/pxtlib.d.ts

@@ -1,11 +1,11 @@
+/// <reference path="../localtypings/pxtarget.d.ts" />
 /// <reference path="../localtypings/pxtpackage.d.ts" />
 /// <reference path="../localtypings/pxtparts.d.ts" />
-/// <reference path="../localtypings/pxtarget.d.ts" />
 /// <reference path="../localtypings/projectheader.d.ts" />
 /// <reference path="../localtypings/dom.d.ts" />
-/// <reference path="../localtypings/dompurify.d.ts" />
 /// <reference path="../localtypings/pxtmusic.d.ts" />
 /// <reference path="../pxtcompiler/ext-typescript/lib/typescriptServices.d.ts" />
+/// <reference path="../localtypings/dompurify.d.ts" />
 /// <reference types="web-bluetooth" />
 declare namespace pxt {
     function aiTrackEvent(id: string, data?: any, measures?: any): void;
@@ -284,6 +284,7 @@ declare namespace ts.pxtc {
 }
 import pxtc = ts.pxtc;
 declare namespace ts.pxtc.Util {
+    function contains(str: string, contains: string): boolean;
     function assert(cond: boolean, msg?: string): void;
     function flatClone<T extends Object>(obj: T): T;
     function clone<T>(v: T): T;
@@ -346,6 +347,39 @@ declare namespace ts.pxtc {
      */
     let encodeBase64: (s: string) => string;
 }
+declare namespace ts.pxtc.Util {
+    function iterMap<T>(m: pxt.Map<T>, f: (k: string, v: T) => void): void;
+    function values<T>(m: pxt.Map<T>): T[];
+    function pushRange<T>(trg: T[], src: ArrayLike<T>): void;
+    function concatArrayLike<T>(arrays: ArrayLike<ArrayLike<T>>): T[];
+    function concat<T>(arrays: T[][]): T[];
+    function jsonMergeFrom(trg: any, src: any): void;
+    function jsonCopyFrom<T>(trg: T, src: T): void;
+    function jsonFlatten(v: any): pxt.Map<any>;
+    function jsonUnFlatten(v: pxt.Map<any>): any;
+    function strcmp(a: string, b: string): 0 | 1 | -1;
+    function endsWith(str: string, suffix: string): boolean;
+    function startsWith(str: string, prefix: string): boolean;
+    function toUTF8(str: string, cesu8?: boolean): string;
+    function toUTF8Array(s: string): Uint8Array;
+}
+declare namespace pxt {
+    export import U = pxtc.Util;
+    export import Util = pxtc.Util;
+}
+declare namespace pxt {
+    /** Resolves compile defaults and a variant without modifying the supplied target. */
+    function getAppTargetVariant(target: TargetBundle, variant: string): TargetBundle;
+    function patchCompileTarget(target: AppTarget): void;
+}
+declare namespace ts.pxtc.Util {
+    function cloneTargetBundle(target: pxt.TargetBundle): pxt.TargetBundle;
+    function cloneApis(byQName: pxt.Map<pxtc.SymbolInfo>): pxt.Map<SymbolInfo>;
+    function cloneSymbolInfo(sym: pxtc.SymbolInfo): pxtc.SymbolInfo;
+}
+declare namespace ts.pxtc.BrowserImpl {
+    function sha256buffer(buf: Uint8Array): string;
+}
 declare namespace ts.pxtc.Util {
     export class CancellationToken {
         private pending;
@@ -374,24 +408,11 @@ declare namespace ts.pxtc.Util {
     export function oops(msg?: string): Error;
     export function reversed<T>(arr: T[]): T[];
     export function arrayEquals<U>(a: U[], b: U[], compare?: (c: U, d: U) => boolean): boolean;
-    export function iterMap<T>(m: pxt.Map<T>, f: (k: string, v: T) => void): void;
     export function mapMap<T, S>(m: pxt.Map<T>, f: (k: string, v: T) => S): pxt.Map<S>;
-    export function values<T>(m: pxt.Map<T>): T[];
-    export function pushRange<T>(trg: T[], src: ArrayLike<T>): void;
-    export function concatArrayLike<T>(arrays: ArrayLike<ArrayLike<T>>): T[];
-    export function concat<T>(arrays: T[][]): T[];
     export function memcpy(trg: Uint8Array, trgOff: number, src: ArrayLike<number>, srcOff?: number, len?: number): void;
     export function uint8ArrayConcat(chunks: Uint8Array[]): Uint8Array;
     export function jsonTryParse(s: string): any;
-    export function jsonMergeFrom(trg: any, src: any): void;
-    export function jsonCopyFrom<T>(trg: T, src: T): void;
-    export function jsonFlatten(v: any): pxt.Map<any>;
-    export function jsonUnFlatten(v: pxt.Map<any>): any;
-    export function strcmp(a: string, b: string): 0 | 1 | -1;
     export function stringMapEq(a: pxt.Map<string>, b: pxt.Map<string>): boolean;
-    export function endsWith(str: string, suffix: string): boolean;
-    export function startsWith(str: string, prefix: string): boolean;
-    export function contains(str: string, contains: string): boolean;
     export function replaceAll(str: string, old: string, new_: string): string;
     export function snakify(s: string): string;
     export function sortObjectFields<T>(o: T): T;
@@ -472,7 +493,6 @@ declare namespace ts.pxtc.Util {
     export function stringToUint8Array(input: string): Uint8Array;
     export function uint8ArrayToString(input: ArrayLike<number>): string;
     export function fromUTF8(binstr: string): string;
-    export function toUTF8(str: string, cesu8?: boolean): string;
     export function toHex(bytes: ArrayLike<number>): string;
     export function fromHex(hex: string): Uint8Array;
     export class PromiseQueue {
@@ -545,10 +565,6 @@ declare namespace ts.pxtc.Util {
     export function decodeBlobAsync(dataURL: string): Promise<Uint8Array>;
     export function parseQueryString(qs: string): pxt.Map<string>;
     export function stringifyQueryString(url: string, qs: any): string;
-    export function cloneTargetBundle(target: pxt.TargetBundle): pxt.TargetBundle;
-    export function cloneApis(byQName: pxt.Map<pxtc.SymbolInfo>): pxt.Map<SymbolInfo>;
-    export function cloneSymbolInfo(sym: pxtc.SymbolInfo): pxtc.SymbolInfo;
-    export function toUTF8Array(s: string): Uint8Array;
     export function fromUTF8Array(s: Uint8Array): string;
     export function getHomeUrl(): string;
     export function isExperienceSupported(experienceId: string): boolean;
@@ -567,7 +583,6 @@ declare namespace ts.pxtc.Util {
     export {};
 }
 declare namespace ts.pxtc.BrowserImpl {
-    function sha256buffer(buf: Uint8Array): string;
     function sha256string(s: string): string;
 }
 declare namespace ts.pxtc.jsonPatch {
@@ -635,8 +650,6 @@ declare namespace pxt.perf {
     };
 }
 declare namespace pxt {
-    export import U = pxtc.Util;
-    export import Util = pxtc.Util;
     interface TCPIO {
         onData: (v: Uint8Array) => void;
         onError: (e: Error) => void;
@@ -650,6 +663,7 @@ declare namespace pxt {
     function setBundledApiInfo(inf: Map<PackageApiInfo>): void;
     function getBundledApiInfo(): Map<PackageApiInfo>;
     function savedAppTheme(): AppTheme;
+    function getUnpatchedAppTarget(): TargetBundle;
     function setCompileSwitch(name: string, value: boolean): void;
     function setCompileSwitches(names: string): void;
     function bundledSvg(id: string): string;
@@ -1161,9 +1175,36 @@ declare namespace Measurements {
     const WebworkerRecvHandler = "webworker recvHandler";
     const NetworkRequest = "network.request";
 }
-declare namespace pxt {
-    function lzmaDecompressAsync(buf: Uint8Array): Promise<string>;
-    function lzmaCompressAsync(text: string): Promise<Uint8Array>;
+declare namespace pxt.packageUtils {
+    function getVersionProtocol(version: string): string;
+    function isVariantDisabled(config: PackageConfig, variant: string): boolean;
+    function getConfigDependencies(config: PackageConfig, includeTests: boolean, includeCpp: boolean, isTestDependencyAvailable: (id: string, version: string) => boolean): Map<string>;
+    /** Evaluates fileDependencies with && taking precedence over ||, without reading target or package globals. */
+    function evaluateDependencyCondition(condition: string, target: Pick<AppTarget, "id" | "platformid">, hasDependency: (id: string) => boolean, onInvalidCondition: (condition: string) => void): boolean;
+    function getConfigFiles(config: PackageConfig, includeTests: boolean, target: Pick<AppTarget, "id" | "platformid">, hasDependency: (id: string) => boolean, onInvalidCondition: (condition: string, filename: string) => void): string[];
+}
+declare namespace ts.pxtc {
+    function parseCommentString(cmt: string): CommentAttrs;
+    function updateBlockDef(attrs: CommentAttrs): void;
+    function parseBlockDefinition(def: string): ParsedBlockDef;
+}
+declare namespace pxt.github {
+    interface ParsedRepo {
+        owner?: string;
+        project?: string;
+        slug: string;
+        fullName: string;
+        tag?: string;
+        fileName?: string;
+    }
+    function parseRepoId(repo: string): ParsedRepo;
+    function stringifyRepo(p: ParsedRepo, ignoreCase?: boolean): string;
+    function join(...parts: string[]): string;
+}
+declare namespace ts.pxtc {
+    const NATIVE_TYPE_THUMB = "thumb";
+    const NATIVE_TYPE_VM = "vm";
+    function emptyExtInfo(compileService: pxt.TargetCompileService): ExtensionInfo;
 }
 declare namespace pxt.cpp {
     function nsWriter(nskw?: string): {
@@ -1176,14 +1217,35 @@ declare namespace pxt.cpp {
     };
     function parseCppInt(v: string): number;
     class PkgConflictError extends Error {
-        pkg0: Package;
-        pkg1: Package;
+        pkg0Id: string;
+        pkg1Id: string;
         settingName: string;
         isUserError: boolean;
         isVersionConflict: boolean;
         constructor(msg: string);
     }
-    function getExtensionInfo(mainPkg: MainPackage): pxtc.ExtensionInfo;
+    interface ExtensionInfoHost {
+        cache: Map<pxtc.ExtensionInfo>;
+        logger: Pick<Logger, "debug" | "log">;
+        perf: {
+            measureStart(name: string): void;
+            measureEnd(name: string): void;
+        };
+    }
+    /**
+     * Generates native extension files from pxt.json and project files, with dependencies
+     * under pxt_modules/<directory>/. Dependencies resolve by directory, pxt.json name,
+     * or their prefix before "---".
+     * The target must not have variant overrides applied.
+     * @example getExtensionInfo({ "pxt.json": config, "main.cpp": source }, target, "v2", host)
+     */
+    function getExtensionInfo(files: Map<string>, target: TargetBundle, variant: string, host: ExtensionInfoHost): pxtc.ExtensionInfo;
+}
+declare namespace pxt {
+    function lzmaDecompressAsync(buf: Uint8Array): Promise<string>;
+    function lzmaCompressAsync(text: string): Promise<Uint8Array>;
+}
+declare namespace pxt.cpp {
     interface HexFileMeta {
         cloudId: string;
         targetVersions?: pxt.TargetVersions;
@@ -1282,87 +1344,6 @@ declare namespace pxt.discourse {
     function extractSharedIdFromPostUrl(url: string): Promise<string>;
     function topicsByTag(apiUrl: string, tag: string): Promise<pxt.CodeCard[]>;
 }
-declare namespace pxt.docs {
-    type MarkedRenderFunction = (src: string, options?: any) => string;
-    interface MarkedRenderer {
-        options?: any;
-        parser: {
-            parse: (tokens: any[], loose?: boolean) => string;
-            parseInline: (tokens: any[]) => string;
-        };
-        code?: (token: any) => string;
-        link?: (token: any) => string;
-        image?: (token: any) => string;
-        listitem?: (token: any) => string;
-        heading?: (token: any) => string;
-    }
-    interface MarkedModule extends MarkedRenderFunction {
-        Renderer: {
-            new (): MarkedRenderer;
-        };
-        lexer: (src: string, options?: any) => any[];
-        setOptions: (options: any) => void;
-        parseInline?: (src: string, options?: any) => string;
-        parse?: (src: string, options?: any) => string;
-    }
-    export function htmlQuote(s: string): string;
-    export function normalizeStaticMarkdown(markdown: string): string;
-    export function html2Quote(s: string): string;
-    export interface BreadcrumbEntry {
-        name: string;
-        href: string;
-    }
-    export let requireMarked: () => MarkedModule | undefined;
-    export let requireDOMSanitizer: () => (html: string) => string;
-    export interface RenderData {
-        html: string;
-        theme: AppTheme;
-        params: Map<string>;
-        filepath?: string;
-        versionPath?: string;
-        ghEditURLs?: string[];
-        finish?: () => string;
-        boxes?: Map<string>;
-        macros?: Map<string>;
-        settings?: Map<string>;
-        TOC?: TOCMenuEntry[];
-    }
-    export function prepTemplate(d: RenderData): void;
-    export interface RenderOptions {
-        template: string;
-        markdown: string;
-        theme?: AppTheme;
-        pubinfo?: Map<string>;
-        filepath?: string;
-        versionPath?: string;
-        locale?: Map<string>;
-        ghEditURLs?: string[];
-        repo?: {
-            name: string;
-            fullName: string;
-            tag?: string;
-        };
-        throwOnError?: boolean;
-        TOC?: TOCMenuEntry[];
-    }
-    export function setupRenderer(renderer: MarkedRenderer, context?: {
-        versionPath?: string;
-    }): void;
-    export function renderConditionalMacros(template: string, pubinfo: Map<string>): string;
-    export function renderMarkdown(opts: RenderOptions): string;
-    export function embedUrl(rootUrl: string, tag: string, id: string, height?: number): string;
-    export function runUrl(url: string, padding: string, id: string): string;
-    export function codeEmbedUrl(rootUrl: string, id: string, height?: number): string;
-    export function translate(html: string, locale: Map<string>): {
-        text: string;
-        missing: Map<string>;
-    };
-    export function buildTOC(summaryMD: string): pxt.TOCMenuEntry[];
-    export function visitTOC(toc: TOCMenuEntry[], fn: (e: TOCMenuEntry) => void): void;
-    export function augmentDocs(baseMd: string, childMd: string): string;
-    export function hydrateYouTubeEmbeds(content: HTMLElement, tickEvent: boolean): void;
-    export {};
-}
 declare namespace pxt.dom {
     function el(name: string, attributes?: pxt.Map<string | number>, children?: string | HTMLElement | (string | HTMLElement)[]): HTMLElement;
 }
@@ -1601,14 +1582,6 @@ declare namespace pxt.github {
         name: string;
         company: string;
     }
-    interface ParsedRepo {
-        owner?: string;
-        project?: string;
-        slug: string;
-        fullName: string;
-        tag?: string;
-        fileName?: string;
-    }
     enum GitRepoStatus {
         Unknown = 0,
         Approved = 1,
@@ -1634,12 +1607,9 @@ declare namespace pxt.github {
     function isRepoHidden(repo: ParsedRepo, config: pxt.PackagesConfig): boolean;
     function repoAsync(repopath: string, config: pxt.PackagesConfig): Promise<GitRepo>;
     function searchAsync(query: string, config: pxt.PackagesConfig): Promise<GitRepo[]>;
-    function parseRepoId(repo: string): ParsedRepo;
     function toGithubDependencyPath(path: string, tag?: string): string;
     function isGithubId(id: string): boolean;
-    function stringifyRepo(p: ParsedRepo, ignoreCase?: boolean): string;
     function normalizeRepoId(id: string, defaultTag?: string, ignoreCase?: boolean): string;
-    function join(...parts: string[]): string;
     function upgradedPackageReferenceAsync(cfg: PackagesConfig, id: string): Promise<string>;
     function upgradedPackageId(cfg: PackagesConfig, id: string): string;
     function latestVersionAsync(repopath: string, config: PackagesConfig, useProxy?: boolean, noCache?: boolean): Promise<string>;
@@ -2137,6 +2107,12 @@ declare namespace pxt.assets.music {
     function getSongInfo(song: pxt.assets.music.Song): SongInfo;
     function getEmptySong(measures: number): pxt.assets.music.Song;
 }
+declare namespace pxt.cpp {
+    interface PkgConflictError {
+        pkg0: Package;
+        pkg1: Package;
+    }
+}
 declare namespace pxt {
     class Package {
         id: string;
@@ -2362,8 +2338,6 @@ declare namespace ts.pxtc {
     const BINARY_PXT64 = "binary.pxt64";
     const BINARY_ESP = "binary.bin";
     const BINARY_SRCMAP = "binary.srcmap";
-    const NATIVE_TYPE_THUMB = "thumb";
-    const NATIVE_TYPE_VM = "vm";
     const BLOCK_TRANSLATION_CACHE_KEY = "_blocks";
     interface BlocksInfo {
         apis: ApisInfo;
@@ -2528,11 +2502,7 @@ declare namespace ts.pxtc {
     let apiLocalizationStrings: pxt.Map<string>;
     function localizeApisAsync(apis: pxtc.ApisInfo, mainPkg: pxt.MainPackage): Promise<pxtc.ApisInfo>;
     function getBlockTranslationsCacheKey(key: string): string | undefined;
-    function emptyExtInfo(): ExtensionInfo;
-    function parseCommentString(cmt: string): CommentAttrs;
     function parameterTypeIsArrowFunction(pr: pxtc.ParameterDesc): boolean;
-    function updateBlockDef(attrs: CommentAttrs): void;
-    function parseBlockDefinition(def: string): ParsedBlockDef;
     interface ChecksumBlock {
         magic: number;
         endMarkerPos: number;
@@ -4192,3 +4162,84 @@ declare namespace pxtmelody {
     }
     const SampleMelodies: MelodyInfo[];
 }
+declare namespace pxt.docs {
+    type MarkedRenderFunction = (src: string, options?: any) => string;
+    interface MarkedRenderer {
+        options?: any;
+        parser: {
+            parse: (tokens: any[], loose?: boolean) => string;
+            parseInline: (tokens: any[]) => string;
+        };
+        code?: (token: any) => string;
+        link?: (token: any) => string;
+        image?: (token: any) => string;
+        listitem?: (token: any) => string;
+        heading?: (token: any) => string;
+    }
+    interface MarkedModule extends MarkedRenderFunction {
+        Renderer: {
+            new (): MarkedRenderer;
+        };
+        lexer: (src: string, options?: any) => any[];
+        setOptions: (options: any) => void;
+        parseInline?: (src: string, options?: any) => string;
+        parse?: (src: string, options?: any) => string;
+    }
+    export function htmlQuote(s: string): string;
+    export function normalizeStaticMarkdown(markdown: string): string;
+    export function html2Quote(s: string): string;
+    export interface BreadcrumbEntry {
+        name: string;
+        href: string;
+    }
+    export let requireMarked: () => MarkedModule | undefined;
+    export let requireDOMSanitizer: () => (html: string) => string;
+    export interface RenderData {
+        html: string;
+        theme: AppTheme;
+        params: Map<string>;
+        filepath?: string;
+        versionPath?: string;
+        ghEditURLs?: string[];
+        finish?: () => string;
+        boxes?: Map<string>;
+        macros?: Map<string>;
+        settings?: Map<string>;
+        TOC?: TOCMenuEntry[];
+    }
+    export function prepTemplate(d: RenderData): void;
+    export interface RenderOptions {
+        template: string;
+        markdown: string;
+        theme?: AppTheme;
+        pubinfo?: Map<string>;
+        filepath?: string;
+        versionPath?: string;
+        locale?: Map<string>;
+        ghEditURLs?: string[];
+        repo?: {
+            name: string;
+            fullName: string;
+            tag?: string;
+        };
+        throwOnError?: boolean;
+        TOC?: TOCMenuEntry[];
+    }
+    export function setupRenderer(renderer: MarkedRenderer, context?: {
+        versionPath?: string;
+    }): void;
+    export function renderConditionalMacros(template: string, pubinfo: Map<string>): string;
+    export function renderMarkdown(opts: RenderOptions): string;
+    export function embedUrl(rootUrl: string, tag: string, id: string, height?: number): string;
+    export function runUrl(url: string, padding: string, id: string): string;
+    export function codeEmbedUrl(rootUrl: string, id: string, height?: number): string;
+    export function translate(html: string, locale: Map<string>): {
+        text: string;
+        missing: Map<string>;
+    };
+    export function buildTOC(summaryMD: string): pxt.TOCMenuEntry[];
+    export function visitTOC(toc: TOCMenuEntry[], fn: (e: TOCMenuEntry) => void): void;
+    export function augmentDocs(baseMd: string, childMd: string): string;
+    export function hydrateYouTubeEmbeds(content: HTMLElement, tickEvent: boolean): void;
+    export {};
+}