@turbowarp/types 0.0.2 → 0.0.3

package/types/scratch-paint.ts

@@ -0,0 +1,311 @@
+// Type definitions for scratch-paint redux state and events
+// Project: https://github.com/LLK/scratch-paint
+
+/// <reference path="./paper.d.ts" />
+
+declare namespace ScratchPaint {
+  const enum VectorMode {
+    Brush = 'BRUSH',
+    Eraser = 'ERASER',
+    Line = 'LINE',
+    Fill = 'FILL',
+    Select = 'SELECT',
+    Reshape = 'RESHAPE',
+    Oval = 'OVAL',
+    Rectangle = 'RECT',
+    // Unused by scratch-paint but technically exists.
+    RoundedRectangle = 'ROUNDED_RECT',
+    Text = 'TEXT'
+  }
+
+  const enum BitmapMode {
+    Brush = 'BIT_BRUSH',
+    Line = 'BIT_LINE',
+    Oval = 'BIT_OVAL',
+    Rectangle = 'BIT_RECT',
+    Text = 'BIT_TEXT',
+    Fill = 'BIT_FILL',
+    Eraser = 'BIT_ERASER',
+    Select = 'BIT_SELECT'
+  }
+
+  type Mode = VectorMode | BitmapMode;
+
+  const enum GradientType {
+    Solid = 'SOLID',
+    Horizontal = 'HORIZONTAL',
+    Vertical = 'VERTICAL',
+    Radial = 'RADIAL'
+  }
+
+  const enum Cursor {
+    Default = 'default',
+    Grab = 'grab',
+    Grabbing = 'grabbing',
+    None = 'none',
+    ResizeEW = 'ew-resize',
+    ResizeNS = 'ns-resize',
+    ResizeNEWSW = 'nesw-resize',
+    ResizeNWSE = 'nwse-resize'
+  }
+
+  type ColorIndex = 0 | 1;
+
+  type Font = string;
+
+  const enum Format {
+    Bitmap = 'BITMAP',
+    Vector = 'VECTOR',
+    BitmapSkipConvert = 'BITMAP_SKIP_CONVERT',
+    VectorSkipConvert = 'VECTOR_SKIP_CONVERT'
+  }
+
+  const enum Modal {
+    FillColor = 'fillColor',
+    StrokeColor = 'strokeColor'
+  }
+
+  interface ColorStyle {
+    primary: string | null;
+    secondary: string | null;
+    gradientType: GradientType;
+  }
+
+  interface UndoSnapshot {
+    json: unknown[];
+    paintEditorFormat: Format;
+  }
+
+  interface ReduxState {
+    scratchPaint: ScratchPaintState;
+  }
+
+  interface ScratchPaintState {
+    mode: Mode;
+
+    bitBrushSize: number;
+
+    bitEraserSize: number;
+
+    brushMode: {
+      brushSize: number;
+    };
+
+    color: {
+      eyeDropper: {
+        active: boolean;
+        callback: (color: string) => void;
+        previousTool: Mode;
+      };
+
+      fillColor: ColorStyle;
+
+      strokeColor: ColorStyle;
+
+      strokeWidth: number;
+    };
+
+    clipboard: {
+      items: Paper.Base[];
+      pasteOffset: number;
+    };
+
+    cursor: Cursor;
+
+    eraserMode: {
+      brushSize: number;
+    };
+
+    fillBitmapShapes: boolean;
+
+    fillMode: {
+      gradientType: GradientType | null;
+      colorIndex: ColorIndex;
+    };
+
+    font: Font;
+
+    format: Format | null;
+
+    hoveredItemId: number | null;
+
+    layout: {
+      rtl: boolean;
+    };
+
+    modals: Record<Modal, boolean>;
+
+    selectedItems: Paper.Base[];
+
+    textEditTarget: number | null;
+
+    undo:  {
+      stack: UndoSnapshot[];
+      pointer: number;
+    };
+
+    viewBounds: Paper.Matrix;
+
+    zoomLevels: {
+      currentZoomLevelId: string;
+    } & Record<string, Paper.Matrix>;
+  }
+
+  type ReduxEvent =
+    {
+      type: 'scratch-paint/modes/CHANGE_MODE';
+      mode: Mode;
+    } |
+    {
+      type: 'scratch-paint/brush-mode/CHANGE_BIT_BRUSH_SIZE';
+      brushSize: number;
+    } |
+    {
+      type: 'scratch-paint/eraser-mode/CHANGE_BIT_ERASER_SIZE';
+      eraserSize: number;
+    } |
+    {
+      type: 'scratch-paint/brush-mode/CHANGE_BRUSH_SIZE';
+      brushSize: number;
+    } |
+    {
+      type: 'scratch-paint/eye-dropper/ACTIVATE_COLOR_PICKER';
+      callback: ScratchPaintState['color']['eyeDropper']['callback'];
+      previousMode: Mode;
+    } |
+    {
+      type: 'scratch-paint/eye-dropper/DEACTIVATE_COLOR_PICKER';
+    } |
+    {
+      type: 'scratch-paint/fill-style/CHANGE_FILL_COLOR';
+      color: string;
+    } |
+    {
+      type: 'scratch-paint/fill-style/CHANGE_FILL_COLOR_2';
+      color: string;
+    } |
+    {
+      type: 'scratch-paint/fill-style/CHANGE_FILL_GRADIENT_TYPE';
+      gradientType: GradientType;
+    } |
+    {
+      type: 'scratch-paint/fill-style/CLEAR_FILL_GRADIENT';
+    } |
+    {
+      type: 'scratch-paint/stroke-style/CHANGE_STROKE_COLOR';
+      color: string;
+    } |
+    {
+      type: 'scratch-paint/stroke-style/CHANGE_STROKE_COLOR_2';
+      color: string;
+    } |
+    {
+      type: 'scratch-paint/stroke-style/CHANGE_STROKE_GRADIENT_TYPE';
+      gradientType: GradientType;
+    } |
+    {
+      type: 'scratch-paint/stroke-style/CLEAR_STROKE_GRADIENT';
+    } |
+    {
+      type: 'scratch-paint/stroke-width/CHANGE_STROKE_WIDTH';
+      strokeWidth: number;
+    } |
+    {
+      type: 'scratch-paint/clipboard/SET';
+      clipboardItems: ScratchPaintState['clipboard']['items']
+    } |
+    {
+      type: 'scratch-paint/clipboard/INCREMENT_PASTE_OFFSET';
+    } |
+    {
+      type: 'scratch-paint/clipboard/CLEAR_PASTE_OFFSET';
+    } |
+    {
+      type: 'scratch-paint/cursor/CHANGE_CURSOR';
+      cursorString: Cursor;
+    } |
+    {
+      type: 'scratch-paint/eraser-mode/CHANGE_ERASER_SIZE';
+      brushSize: number;
+    } |
+    {
+      type: 'scratch-paint/fill-bitmap-shapes/SET_FILLED';
+      filled: boolean;
+    } |
+    {
+      type: 'scratch-paint/color-index/CHANGE_COLOR_INDEX';
+      index: ColorIndex;
+    } |
+    {
+      type: 'scratch-paint/fonts/CHANGE_FONT';
+      font: Font;
+    } |
+    {
+      type: 'scratch-paint/formats/CHANGE_FORMAT';
+      format: Format;
+    } |
+    {
+      type: 'scratch-paint/hover/CHANGE_HOVERED';
+      hoveredItemId: number | null;
+    } |
+    {
+      type: 'scratch-paint/layout/SET_LAYOUT';
+      layout: 'rtl' | 'ltr';
+    } |
+    {
+      type: 'scratch-paint/modals/OPEN_MODAL';
+      modal: Modal;
+    } |
+    {
+      type: 'scratch-paint/modals/CLOSE_MODAL';
+      modal: Modal;
+    } |
+    {
+      type: 'scratch-paint/select/CHANGE_SELECTED_ITEMS';
+      selectedItems: ScratchPaintState['selectedItems'];
+      bitmapMode: boolean;
+    } |
+    {
+      type: 'scratch-paint/select/REDRAW_SELECTION_BOX';
+    } |
+    {
+      type: 'scratch-paint/text-tool/CHANGE_TEXT_EDIT_TARGET';
+      textEditTargetId: number | null;
+    } |
+    {
+      type: 'scratch-paint/undo/UNDO';
+      /**
+       * VECTOR_SKIP_CONVERT or BITMAP_SKIP_CONVERT
+       */
+       format: Format;
+    } |
+    {
+      type: 'scratch-paint/undo/REDO';
+      /**
+       * VECTOR_SKIP_CONVERT or BITMAP_SKIP_CONVERT
+       */
+      format: Format;
+    } |
+    {
+      type: 'scratch-paint/undo/SNAPSHOT';
+      snapshot: UndoSnapshot;
+    } |
+    {
+      type: 'scratch-paint/undo/CLEAR';
+    } |
+    {
+      type: 'scratch-paint/view/UPDATE_VIEW_BOUNDS';
+      viewBounds: Paper.Matrix;
+    } |
+    {
+      type: 'scratch-paint/zoom-levels/SAVE_ZOOM_LEVEL';
+      zoomLevel: Paper.Matrix;
+    } |
+    {
+      type: 'scratch-paint/zoom-levels/SET_ZOOM_LEVEL_ID';
+      zoomLevelId: string;
+    } |
+    {
+      type: 'scratch-paint/zoom-levels/RESET_ZOOM_LEVELS';
+    };
+}

package/types/scratch-parser.d.ts

@@ -1,6 +1,15 @@
 // Type definitions for scratch-parser
 // Project: https://github.com/LLK/scratch-parser
 
+/// <reference path="./jszip.d.ts" />
+
 declare namespace ScratchParser {
-  // TODO
+
 }
+
+/**
+ * @param input The binary data representing the project or sprite.
+ * @param isSprite True if this is a sprite, false if this is a project.
+ * @param callback
+ */
+declare function ScratchParser(input: ArrayBuffer | string, isSprite: boolean, callback: (error: unknown, unpacked: [unknown, JSZip | null]) => void): void

package/types/scratch-render-fonts.d.ts

@@ -2,5 +2,15 @@
 // Project: https://github.com/LLK/scratch-render-fonts
 
 declare namespace ScratchRenderFonts {
-  // TODO
+  const enum Font {
+    SansSerif = 'Sans Serif',
+    Serif = 'Serif',
+    Handwriting = 'Handwriting',
+    Marker = 'Marker',
+    Curly = 'Curly',
+    Pixel = 'Pixel',
+    Scratch = 'Scratch'
+  }
 }
+
+declare function ScratchRenderFonts(): Record<ScratchRenderFonts.Font, string>;

package/types/scratch-storage.d.ts

@@ -2,13 +2,90 @@
 // Project: https://github.com/LLK/scratch-storage
 
 declare namespace ScratchStorage {
-  interface Asset {
-    // TODO
+  enum DataFormat {
+    JPG = 'jpg',
+    JSON = 'json',
+    MP3 = 'mp3',
+    PNG = 'png',
+    SB2 = 'sb2',
+    SB3 = 'sb3',
+    SVG = 'svg',
+    WAV = 'wav'
+  }
+
+  interface AssetType {
+    contentType: string;
+    name: string;
+    runtimeFormat: DataFormat;
+    immutable: true;
+  }
+  namespace AssetType {
+    const ImageBitmap: AssetType;
+    const ImageVector: AssetType;
+    const Project: AssetType;
+    const Sound: AssetType;
+    const Sprite: AssetType;
+  }
+
+  class Asset {
+    constructor(assetType: AssetType, assetId: string, dataFormat: DataFormat | null, data: ArrayBuffer, generateId?: boolean);
+
+    assetType: AssetType;
+
+    dataFormat: DataFormat;
+
+    /**
+     * MD5 of asset's data.
+     */
+    assetId: string;
+
+    setData(data: ArrayBuffer, dataFormat: DataFormat, generateId?: boolean): void;
+    encodeTextData(text: string, dataFormat: DataFormat, generateId?: boolean): void;
+
+    decodeText(): string;
+    encodeDataURI(contentType?: string): string;
+
+    /**
+     * @deprecated Unused.
+     */
+    dependencies: [];
+  }
+
+  type UrlFunction = (asset: Asset) => string;
+
+  interface Helper {
+    load(assetType: AssetType, assetId: string, dataFormat: DataFormat): Promise<Asset>;
+    store(assetType: AssetType, dataFormat: DataFormat, data: ArrayBuffer, assetId: string): Promise<unknown>;
   }
 }
 
 declare class ScratchStorage {
-  // TODO
+  get Asset(): typeof ScratchStorage.Asset;
+  get AssetType(): typeof ScratchStorage.AssetType;
+  get DataFormat(): typeof ScratchStorage.DataFormat;
+
+  _helpers: ScratchStorage.Helper[];
+  addHelper(helper: ScratchStorage.Helper, priority?: number): void;
+
+  /**
+   * Synchronously get a cached asset.
+   */
+  get(assetId: string): ScratchStorage.Asset | null;
+
+  cache(assetType: ScratchStorage.AssetType, dataFormat: ScratchStorage.DataFormat, data: ArrayBuffer, assetId: string): string;
+
+  load(assetType: ScratchStorage.AssetType, assetId: string, dataFormat: ScratchStorage.DataFormat): Promise<ScratchStorage.Asset | null>;
+
+  store(assetType: ScratchStorage.Asset, dataFormat: ScratchStorage.DataFormat, data: ArrayBuffer, assetId: string): Promise<unknown>;
+
+  createAsset(assetType: ScratchStorage.AssetType, dataFormat: ScratchStorage.DataFormat, data: ArrayBuffer, assetId: string, generateId?: boolean): void;
+
+  addWebStore(types: ScratchStorage.AssetType[], getFunction: ScratchStorage.UrlFunction, createFunction?: ScratchStorage.UrlFunction, updateFunction?: ScratchStorage.UrlFunction): void;
+
+  /**
+   * @deprecated Use addWebStore instead.
+   */
+  addWebSource(types: ScratchStorage.AssetType[], getFunction: ScratchStorage.UrlFunction): void;
 }
 
 /**

package/types/scratch-svg-renderer.d.ts

@@ -2,5 +2,65 @@
 // Project: https://github.com/LLK/scratch-svg-renderer
 
 declare namespace ScratchSVGRenderer {
-  // TODO
+  class BitmapAdapter {
+    constructor(makeImage?: () => HTMLImageElement, makeCanvas?: () => HTMLCanvasElement);
+    resize(image: CanvasImageSource, newWidth: number, newHeight: number): HTMLCanvasElement;
+    convertResolution1Bitmap(dataURI: string, callback: (error: unknown, dataURI: string) => void): void;
+    getResizedWidthHeight(oldWidth: number, oldHeight: number): {
+      width: number;
+      height: number;
+    };
+    importBitmap(fileData: ArrayBuffer | string, contentType: string): Promise<Uint8Array>;
+    convertDataURIToBinary(dataURI: string): Uint8Array;
+    convertBinaryToDataURI(data: ArrayBufferLike, contentType: string): string;
+  }
+
+  function convertFonts(element: SVGElement): void;
+
+  function inlineSvgFonts(svgString: string): string;
+
+  function loadSvgString(svgString: string, fromVersion2?: boolean): SVGSVGElement;
+
+  function serializeSvgToString(svgElement: SVGSVGElement, shouldInjectFonts?: boolean): string;
+
+  class SvgElement {
+    static get svg(): string;
+    static get xmlns(): string;
+    static get xlink(): string;
+    static get attributeNamespace(): Record<string, string>;
+    static create(tag: string, attributes?: Record<string, string | number>, formatter?: (n: number) => string): SVGElement;
+    static set(node: SVGElement, attributes?: Record<string, string | number>, formatter?: (n: number) => string): SVGElement;
+    static get(node: SVGElement, attributeName: string): string | null;
+  }
+
+  /**
+   * @deprecated Use the individual methods instead.
+   */
+  class SvgRenderer {
+    constructor(canvas?: HTMLCanvasElement);
+
+    _canvas: HTMLCanvasElement;
+    get canvas(): HTMLCanvasElement;
+    _context: CanvasRenderingContext2D;
+
+    _measurements: {
+      x: number;
+      y: number;
+      width: number;
+      height: number;
+    };
+    get size(): [number, number];
+    get viewOffset(): [number, number];
+
+    loaded?: boolean;
+    _cachedImage?: HTMLImageElement | null;
+    _svgTag: SVGSVGElement;
+
+    loadString(svgString: string, fromVersion2?: boolean): void;
+    loadSVG(svgString: string, fromVersion2?: boolean, callback?: () => void): void;
+    _createSVGImage(onFinish?: () => void): void;
+    toString(shouldInjectFonts?: boolean): string;
+    draw(scale: number): void;
+    _drawFromImage(scale: number): void;
+  }
 }

package/types/scratch-vm.d.ts

@@ -7,6 +7,7 @@
 /// <reference path="./scratch-render.d.ts" />
 /// <reference path="./scratch-audio.d.ts" />
 /// <reference path="./scratch-storage.d.ts" />
+/// <reference path="./scratch-svg-renderer.d.ts" />
 
 declare namespace VM {
   /**
@@ -236,6 +237,55 @@ declare namespace VM {
     size?: number;
   }
 
+  const enum TextToSpeechVoice {
+    Alto = 'ALTO',
+    Tenor = 'TENOR',
+    Squeak = 'SQUEAK',
+    Giant = 'GIANT',
+    Kitten = 'KITTEN'
+  }
+
+  interface CustomState {
+    'Scratch.looks': {
+      drawableId: null | number;
+      skinId: null | number;
+      onSpriteRight: boolean;
+      text: string;
+      type: RenderWebGL.TextBubbleType;
+    };
+
+    'Scratch.sound': {
+      effects: {
+        pitch: number;
+        pan: number;
+      };
+    };
+
+    'Scratch.music': {
+      currentInstrument: number;
+    };
+
+    'Scratch.pen': {
+      penDown: boolean;
+      color: number;
+      saturation: number;
+      brightness: number;
+      transparency: number;
+      _shade: number;
+      penAttributes: RenderWebGL.PenAttributes;
+    };
+
+    'Scratch.text2speech': {
+      voiceId: TextToSpeechVoice;
+    };
+
+    'Scratch.videoSensing': {
+      motionFrameNumber: number;
+      motionAmount: number;
+      motionDirection: number;
+    };
+  }
+
   interface BaseTarget extends EventEmitter<{}> {
     runtime: Runtime;
 
@@ -247,8 +297,6 @@ declare namespace VM {
 
     comments: Record<string, Comment>;
 
-    _customState: Record<string, unknown>;
-
     /**
      * Called by runtime when the green flag is pressed.
      */
@@ -282,6 +330,15 @@ declare namespace VM {
      */
     createVariable(id: string, name: string, type: VariableType, isCloud?: boolean): void;
 
+    _customState: Partial<CustomState>;
+    getCustomState<T extends keyof CustomState>(name: T): CustomState[T] | undefined;
+    setCustomState<T extends keyof CustomState>(name: T, value: CustomState[T]): void;
+
+    /**
+     * Mirrors custom state.
+     */
+    soundEffects?: CustomState['Scratch.sound']['effects'];
+
     postSpriteInfo(spriteInfo: PostedSpriteInfo): void;
 
     dispose(): void;
@@ -956,6 +1013,10 @@ declare namespace VM {
 
     attachAudioEngine(audioEngine: AudioEngine): void;
 
+    v2BitmapAdapter?: ScratchSVGRenderer.BitmapAdapter;
+
+    attachV2BitmapAdapter(bitmapAdapter: ScratchSVGRenderer.BitmapAdapter): void;
+
     storage: IfGui<GUIScratchStorage, ScratchStorage>;
 
     attachStorage(storage: ScratchStorage): void;
@@ -1214,6 +1275,16 @@ declare class VM extends EventEmitter<VM.VirtualMachineEventMap> {
    */
   attachAudioEngine(audioEngine: AudioEngine): void;
 
+  /**
+   * @deprecated Does nothing.
+   */
+  attachV2SVGAdapter(): void;
+
+  /**
+   * @see {VM.Runtime.attachV2BitmapAdapter}
+   */
+  attachV2BitmapAdapter(bitmapAdapter: ScratchSVGRenderer.BitmapAdapter): void;
+
   /**
    * @see {VM.Runtime.attachStorage}
    */

package/types/scratch-www.ts

@@ -0,0 +1,6 @@
+// Type definitions for scratch-www redux state and events
+// Project: https://github.com/LLK/scratch-www
+
+declare namespace ScratchWWW {
+  // TODO
+}