pxt-core 8.4.1 → 8.4.3

package/built/pxtlib.d.ts

@@ -99,6 +99,7 @@ declare namespace pxt.auth {
         protected abstract onProfileDeleted(userId: string): Promise<void>;
         protected abstract onApiError(err: any): Promise<void>;
         protected abstract onStateCleared(): Promise<void>;
+        authTokenAsync(): Promise<string>;
         /**
          * Starts the process of authenticating the user against the given identity
          * provider. Upon success the backend will write an http-only session cookie
@@ -177,6 +178,7 @@ declare namespace pxt.auth {
     function hasIdentity(): boolean;
     function enableAuth(enabled?: boolean): void;
     function userName(user: pxt.auth.UserProfile): string;
+    function firstName(user: pxt.auth.UserProfile): string;
     function userInitials(user: pxt.auth.UserProfile): string;
     function generateUserProfilePicDataUrl(profile: pxt.auth.UserProfile): void;
     /**
@@ -554,6 +556,7 @@ declare namespace pxt {
         asseteditorUrl?: string;
         skillmapUrl?: string;
         authcodeUrl?: string;
+        multiplayerUrl?: string;
         isStatic?: boolean;
         verprefix?: string;
     }
@@ -1613,6 +1616,8 @@ declare namespace pxt.sprite {
     const IMAGE_PREFIX = "image";
     const ANIMATION_NAMESPACE = "myAnimations";
     const ANIMATION_PREFIX = "anim";
+    const SONG_NAMESPACE = "mySongs";
+    const SONG_PREFIX = "song";
     interface Coord {
         x: number;
         y: number;
@@ -1764,6 +1769,66 @@ declare namespace pxt.storage.shared {
     function setAsync(container: string, key: string, val: any): Promise<void>;
     function delAsync(container: string, key: string): Promise<void>;
 }
+declare namespace pxt.assets.music {
+    interface Instrument {
+        waveform: number;
+        ampEnvelope: Envelope;
+        pitchEnvelope?: Envelope;
+        ampLFO?: LFO;
+        pitchLFO?: LFO;
+        octave?: number;
+    }
+    interface Envelope {
+        attack: number;
+        decay: number;
+        sustain: number;
+        release: number;
+        amplitude: number;
+    }
+    interface LFO {
+        frequency: number;
+        amplitude: number;
+    }
+    interface Song {
+        measures: number;
+        beatsPerMeasure: number;
+        beatsPerMinute: number;
+        ticksPerBeat: number;
+        tracks: Track[];
+    }
+    interface Track {
+        instrument: Instrument;
+        id: number;
+        name?: string;
+        iconURI?: string;
+        drums?: DrumInstrument[];
+        notes: NoteEvent[];
+    }
+    interface NoteEvent {
+        notes: number[];
+        startTick: number;
+        endTick: number;
+    }
+    interface DrumSoundStep {
+        waveform: number;
+        frequency: number;
+        volume: number;
+        duration: number;
+    }
+    interface DrumInstrument {
+        startFrequency: number;
+        startVolume: number;
+        steps: DrumSoundStep[];
+    }
+    function renderInstrument(instrument: Instrument, noteFrequency: number, gateLength: number, volume: number): Uint8Array;
+    function renderDrumInstrument(sound: DrumInstrument, volume: number): Uint8Array;
+    function encodeSongToHex(song: Song): string;
+    function decodeSongFromHex(hex: string): Song;
+    function cloneSong(song: Song): Song;
+    function songEquals(a: Song, b: Song): boolean;
+    function inflateSong(song: pxt.assets.music.Song): void;
+    function getEmptySong(measures: number): pxt.assets.music.Song;
+}
 declare namespace pxt {
     class Package {
         id: string;
@@ -2607,11 +2672,13 @@ declare namespace pxt {
     export const IMAGE_MIME_TYPE = "image/x-mkcd-f4";
     export const TILEMAP_MIME_TYPE = "application/mkcd-tilemap";
     export const ANIMATION_MIME_TYPE = "application/mkcd-animation";
+    export const SONG_MIME_TYPE = "application/mkcd-song";
     export const enum AssetType {
         Image = "image",
         Tile = "tile",
         Tilemap = "tilemap",
-        Animation = "animation"
+        Animation = "animation",
+        Song = "song"
     }
     export interface AssetMetadata {
         displayName?: string;
@@ -2623,7 +2690,7 @@ declare namespace pxt {
         blockId: string;
         fieldName: string;
     }
-    export type Asset = ProjectImage | Tile | Animation | ProjectTilemap;
+    export type Asset = ProjectImage | Tile | Animation | ProjectTilemap | Song;
     export interface BaseAsset {
         internalID: number;
         id: string;
@@ -2661,6 +2728,10 @@ declare namespace pxt {
         type: AssetType.Tilemap;
         data: pxt.sprite.TilemapData;
     }
+    export interface Song extends BaseAsset {
+        type: AssetType.Song;
+        song: assets.music.Song;
+    }
     export interface TilemapSnapshot {
         revision: number;
         projectTilemaps?: ProjectTilemap[];
@@ -2674,6 +2745,7 @@ declare namespace pxt {
         tilemaps: AssetCollection<ProjectTilemap>;
         images: AssetCollection<ProjectImage>;
         animations: AssetCollection<Animation>;
+        songs: AssetCollection<Song>;
     }
     interface AssetSnapshotDiff {
         beforeRevision: number;
@@ -2682,6 +2754,7 @@ declare namespace pxt {
         tilemaps: AssetCollectionDiff<ProjectTilemap>;
         images: AssetCollectionDiff<ProjectImage>;
         animations: AssetCollectionDiff<Animation>;
+        songs: AssetCollectionDiff<Song>;
     }
     interface AssetUpdateListener {
         internalID: number;
@@ -2734,6 +2807,7 @@ declare namespace pxt {
         getProjectTiles(tileWidth: number, createIfMissing: boolean): TileSet | null;
         createNewTile(data: pxt.sprite.BitmapData, id?: string, displayName?: string): Tile;
         createNewProjectImage(data: pxt.sprite.BitmapData, displayName?: string): ProjectImage;
+        createNewSong(data: pxt.assets.music.Song, displayName?: string): Song;
         updateTile(tile: pxt.Tile): Tile;
         deleteTile(id: string): void;
         getProjectTilesetJRes(): Map<any>;
@@ -2775,6 +2849,10 @@ declare namespace pxt {
          * assets.animation`shortId`
          * assets.animation`displayName`
          *
+         * SONGS:
+         * assets.song`shortId`
+         * assets.song`displayName`
+         *
          * TILEMAPS:
          * tilemap`shortId`
          *
@@ -2787,36 +2865,43 @@ declare namespace pxt {
         lookupAsset(assetType: AssetType.Tile, name: string): Tile;
         lookupAsset(assetType: AssetType.Tilemap, name: string): ProjectTilemap;
         lookupAsset(assetType: AssetType.Animation, name: string): Animation;
+        lookupAsset(assetType: AssetType.Song, name: string): Song;
         lookupAsset(assetType: AssetType, name: string): Asset;
         lookupAssetByName(assetType: AssetType.Image, name: string): ProjectImage;
         lookupAssetByName(assetType: AssetType.Tile, name: string): Tile;
         lookupAssetByName(assetType: AssetType.Tilemap, name: string): ProjectTilemap;
         lookupAssetByName(assetType: AssetType.Animation, name: string): Animation;
+        lookupAssetByName(assetType: AssetType.Song, name: string): Song;
         lookupAssetByName(assetType: AssetType, name: string): Asset;
         getAssets(type: AssetType.Image): ProjectImage[];
         getAssets(type: AssetType.Tile): Tile[];
         getAssets(type: AssetType.Tilemap): ProjectTilemap[];
         getAssets(type: AssetType.Animation): Animation[];
+        getAssets(type: AssetType.Song): Song[];
         getAssets(type: AssetType): Asset[];
         getGalleryAssets(type: AssetType.Image): ProjectImage[];
         getGalleryAssets(type: AssetType.Tile): Tile[];
         getGalleryAssets(type: AssetType.Tilemap): ProjectTilemap[];
         getGalleryAssets(type: AssetType.Animation): Animation[];
+        getGalleryAssets(type: AssetType.Song): Song[];
         getGalleryAssets(type: AssetType): Asset[];
         lookupBlockAsset(assetType: AssetType.Image, blockID: string): ProjectImage;
         lookupBlockAsset(assetType: AssetType.Tile, blockID: string): Tile;
         lookupBlockAsset(assetType: AssetType.Tilemap, blockID: string): ProjectTilemap;
         lookupBlockAsset(assetType: AssetType.Animation, blockID: string): Animation;
+        lookupBlockAsset(assetType: AssetType.Song, blockID: string): Song;
         lookupBlockAsset(assetType: AssetType, blockID: string): Asset;
         updateAsset(asset: ProjectImage): ProjectImage;
         updateAsset(asset: Tile): Tile;
         updateAsset(asset: ProjectTilemap): ProjectTilemap;
         updateAsset(asset: Animation): Animation;
+        updateAsset(asset: Song): Song;
         updateAsset(asset: Asset): Asset;
         duplicateAsset(asset: ProjectImage, displayName?: string): ProjectImage;
         duplicateAsset(asset: Tile, displayName?: string): Tile;
         duplicateAsset(asset: ProjectTilemap, displayName?: string): ProjectTilemap;
         duplicateAsset(asset: Animation, displayName?: string): Animation;
+        duplicateAsset(asset: Song, displayName?: string): Song;
         duplicateAsset(asset: Asset, displayName?: string): Asset;
         removeAsset(asset: Asset): void;
         addChangeListener(asset: Asset, listener: () => void): void;
@@ -2827,12 +2912,13 @@ declare namespace pxt {
         removeInactiveBlockAssets(activeBlockIDs: string[]): void;
         protected generateImage(entry: JRes, type: AssetType.Image): ProjectImage;
         protected generateImage(entry: JRes, type: AssetType.Tile): Tile;
+        protected generateSong(entry: JRes): Song;
         protected generateAnimation(entry: JRes): [Animation, boolean];
-        protected inflateAnimation(animation: Animation, assets: (Tile | ProjectImage | Animation)[]): Animation;
+        protected inflateAnimation(animation: Animation, assets: (Tile | ProjectImage | Animation | Song)[]): Animation;
         generateNewID(type: AssetType): string;
         protected generateNewIDInternal(type: AssetType, varPrefix: string, namespaceString?: string): string;
         protected onChange(): void;
-        protected readImages(allJRes: Map<JRes>, isProjectFile?: boolean): (Tile | ProjectImage | Animation)[];
+        protected readImages(allJRes: Map<JRes>, isProjectFile?: boolean): (Tile | ProjectImage | Animation | Song)[];
         protected cleanupTemporaryAssets(): void;
     }
     export function emitTilemapsFromJRes(jres: pxt.Map<JRes>): string;
@@ -2845,7 +2931,7 @@ declare namespace pxt {
         type: string;
         name: string;
     };
-    export function lookupProjectAssetByTSReference(ts: string, project: TilemapProject): Tile | ProjectImage | Animation | ProjectTilemap;
+    export function lookupProjectAssetByTSReference(ts: string, project: TilemapProject): Tile | ProjectImage | Animation | ProjectTilemap | Song;
     export function getDefaultAssetDisplayName(type: pxt.AssetType): string;
     export function getShortIDForAsset(asset: pxt.Asset): string;
     export {};