@rive-app/canvas-advanced 1.0.69 → 1.0.72

package/canvas_advanced.mjs

@@ -96,7 +96,7 @@ Fa;var e=Ia;var f=Ja;var n=function(){return Ga};var g=1}else 4===a&&(d=Ka,e=La,
 readValueFromPointer:Hb,da:function(m){vb(m)}})},L:function(b,a,c,d,e,f){Fb[b]={name:R(a),Ba:Z(c,d),ja:Z(e,f),Na:[]}},I:function(b,a,c,d,e,f,n,g,m,h){Fb[b].Na.push({hb:R(a),nb:c,lb:Z(d,e),mb:f,yb:n,xb:Z(g,m),zb:h})},G:function(b,a){a=R(a);X(b,{qb:!0,name:a,argPackAdvance:0,fromWireType:function(){},toWireType:function(){}})},m:function(b,a,c){b=kb(b);a=Ab(a,"emval::as");var d=[],e=Q(d);J[c>>2]=e;return a.toWireType(d,b)},u:function(b,a,c,d,e){b=qc[b];a=kb(a);c=pc(c);var f=[];J[d>>2]=Q(f);return b(a,
 c,f,e)},e:function(b,a,c,d){b=qc[b];a=kb(a);c=pc(c);b(a,c,null,d)},M:kc,d:function(b,a){var c=sc(b,a),d=c[0];a=d.name+"_$"+c.slice(1).map(function(p){return p.name}).join("_")+"$";var e=tc[a];if(void 0!==e)return e;e=["retType"];for(var f=[d],n="",g=0;g<b-1;++g)n+=(0!==g?", ":"")+"arg"+g,e.push("argType"+g),f.push(c[1+g]);var m="return function "+eb("methodCaller_"+a)+"(handle, name, destructors, args) {\n",h=0;for(g=0;g<b-1;++g)m+="    var arg"+g+" = argType"+g+".readValueFromPointer(args"+(h?"+"+
 h:"")+");\n",h+=c[g+1].argPackAdvance;m+="    var rv = handle[name]("+n+");\n";for(g=0;g<b-1;++g)c[g+1].deleteObject&&(m+="    argType"+g+".deleteObject(arg"+g+");\n");d.qb||(m+="    return retType.toWireType(destructors, rv);\n");e.push(m+"};\n");b=gc(e).apply(null,f);e=rc(b);return tc[a]=e},H:function(b){b=pc(b);return Q(k[b])},J:function(b,a){b=kb(b);a=kb(a);return Q(b[a])},w:function(b){4<b&&(O[b].Ca+=1)},D:function(b){return Q(pc(b))},x:function(b){var a=kb(b);Gb(a);kc(b)},o:function(b,a){b=
-Ab(b,"_emval_take_value");b=b.readValueFromPointer(a);return Q(b)},v:function(){ta("")},p:function(b){var a=D.length;b>>>=0;if(2147483648<b)return!1;for(var c=1;4>=c;c*=2){var d=a*(1+.2/c);d=Math.min(d,b+100663296);d=Math.max(b,d);0<d%65536&&(d+=65536-d%65536);a:{try{za.grow(Math.min(2147483648,d)-Na.byteLength+65535>>>16);Ra();var e=1;break a}catch(f){}e=void 0}if(e)return!0}return!1},B:function(){return 0},y:function(){},C:function(b,a,c,d){for(var e=0,f=0;f<c;f++){var n=J[a>>2],g=J[a+4>>2];a+=
+Ab(b,"_emval_take_value");b=b.readValueFromPointer(a);return Q(b)},v:function(){ta("")},p:function(b){var a=D.length;b>>>=0;if(2147483648<b)return!1;for(var c=1;4>=c;c*=2){var d=a*(1+.2/c);d=Math.min(d,b+100663296);d=Math.max(b,d);0<d%65536&&(d+=65536-d%65536);a:{try{za.grow(Math.min(2147483648,d)-Na.byteLength+65535>>>16);Ra();var e=1;break a}catch(f){}e=void 0}if(e)return!0}return!1},C:function(){return 0},y:function(){},B:function(b,a,c,d){for(var e=0,f=0;f<c;f++){var n=J[a>>2],g=J[a+4>>2];a+=
 8;for(var m=0;m<g;m++){var h=D[n+m],p=uc[b];0===h||10===h?((1===b?ua:va)(Ca(p,0)),p.length=0):p.push(h)}e+=g}J[d>>2]=e;return 0},A:function(){}};
 (function(){function b(e){k.asm=e.exports;za=k.asm.N;Ra();Sa=k.asm.T;Ua.unshift(k.asm.O);Xa--;k.monitorRunDependencies&&k.monitorRunDependencies(Xa);0==Xa&&(null!==Ya&&(clearInterval(Ya),Ya=null),Za&&(e=Za,Za=null,e()))}function a(e){b(e.instance)}function c(e){return cb().then(function(f){return WebAssembly.instantiate(f,d)}).then(function(f){return f}).then(e,function(f){va("failed to asynchronously prepare wasm: "+f);ta(f)})}var d={a:yc};Xa++;k.monitorRunDependencies&&k.monitorRunDependencies(Xa);
 if(k.instantiateWasm)try{return k.instantiateWasm(d,b)}catch(e){return va("Module.instantiateWasm callback failed with error: "+e),!1}(function(){return ya||"function"!==typeof WebAssembly.instantiateStreaming||$a()||M.startsWith("file://")||"function"!==typeof fetch?c(a):fetch(M,{credentials:"same-origin"}).then(function(e){return WebAssembly.instantiateStreaming(e,d).then(a,function(f){va("wasm streaming compile failed: "+f);va("falling back to ArrayBuffer instantiation");return c(a)})})})().catch(ba);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rive-app/canvas-advanced",
-  "version": "1.0.69",
+  "version": "1.0.72",
   "description": "Rive's lightweight low-level canvas based web api.",
   "main": "canvas_advanced.mjs",
   "homepage": "https://rive.app",
@@ -23,8 +23,10 @@
   "license": "MIT",
   "files": [
     "canvas_advanced.mjs",
-    "rive.wasm"
+    "rive.wasm",
+    "rive_advanced.mjs.d.ts"
   ],
+  "types": "rive_advanced.mjs.d.ts",
   "dependencies": {},
   "browser": {
     "fs": false,

package/rive_advanced.mjs.d.ts

@@ -0,0 +1,325 @@
+interface RiveOptions {
+    locateFile(file: string): string
+  }
+  
+  declare function Rive(options?: RiveOptions): Promise<RiveCanvas>;
+  export default Rive;
+  
+  export interface RiveCanvas {
+    Alignment: AlignmentFactory;
+    CanvasRenderer: typeof CanvasRenderer;
+    LinearAnimationInstance: typeof LinearAnimationInstance;
+    StateMachineInstance: typeof StateMachineInstance;
+    Mat2D: typeof Mat2D;
+    Vec2D: typeof Vec2D;
+    AABB: AABB;
+    SMIInput: typeof SMIInput;
+    renderFactory: CanvasRenderFactory;
+  
+    BlendMode: typeof BlendMode;
+    FillRule: typeof FillRule;
+    Fit: typeof Fit;
+    RenderPaintStyle: typeof RenderPaintStyle;
+    StrokeCap: typeof StrokeCap;
+    StrokeJoin: typeof StrokeJoin;
+  
+    load(buffer: Uint8Array): Promise<File>;
+    makeRenderer(canvas: HTMLCanvasElement | OffscreenCanvas, useOffscreenRenderer?: boolean) : CanvasRenderer;
+    computeAlignment(fit: Fit, alignment: Alignment, frame: AABB, content: AABB): Mat2D;
+    mapXY(matrix: Mat2D, canvasPoints: Vec2D): Vec2D;
+    requestAnimationFrame(cb: (timestamp: DOMHighResTimeStamp) => void): number;
+    cancelAnimationFrame(requestID: number): void;
+    enableFPSCounter(cb: (fps: number) => void): void;
+    disableFPSCounter(): void;
+  }
+  
+  //////////////
+  // RENDERER //
+  //////////////
+  
+  export declare class RendererWrapper {
+    save(): void;
+    restore(): void;
+    transform(tranform: Mat2D): void;
+    drawPath(path: RenderPath, paint: RenderPaint): void;
+    clipPath(path: RenderPath): void;
+    clear(): void;
+    flush(): void;
+    translate(x: number, y: number): void;
+    rotate(angle: number): void;
+  }
+  
+  export declare class RenderPathWrapper {
+    reset(): void;
+    addPath(path: CommandPath, transform: Mat2D): void;
+    fillRule(value: FillRule): void;
+    moveTo(x: number, y: number): void
+    lineTo(x: number, y: number): void
+    cubicTo(ox: number, oy: number, ix: number, iy: number, x: number, y: number): void;
+    close(): void;
+  }
+  
+  export declare class RenderPaintWrapper {
+    color(value: number): void;
+    thickness(value: number): void;
+    join(value: StrokeJoin): void;
+    cap(value: StrokeCap): void;
+    blendMode(value: BlendMode): void;
+    style(value: RenderPaintStyle): void;
+    linearGradient(sx: number, sy: number, ex: number, ey: number): void;
+    radialGradient(sx: number, sy: number, ex: number, ey: number): void;
+    addStop(color: number, stop: number): void;
+    completeGradient(): void;
+  }
+  
+  export declare class Renderer extends RendererWrapper {
+    align(fit: Fit, alignment: Alignment, frame: AABB, content: AABB): void
+  }
+  
+  export declare class CommandPath { }
+  
+  export declare class RenderPath extends RenderPathWrapper { }
+  
+  export declare class RenderPaint extends RenderPaintWrapper { }
+  
+  
+  /////////////////////
+  // CANVAS RENDERER //
+  /////////////////////
+  
+  export declare class CanvasRenderer extends Renderer {
+    constructor(ctx: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D);
+  }
+  
+  export declare class CanvasRenderPaint extends RenderPaint {
+    draw(ctx: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D, path: RenderPath): void;
+  }
+  
+  export declare class CanvasRenderPath extends RenderPath { }
+  
+  export interface CanvasRenderFactory {
+    makeRenderPaint(): CanvasRenderPaint;
+    makeRenderPath(): CanvasRenderPath;
+  }
+  
+  //////////
+  // File //
+  //////////
+  export declare class File {
+    defaultArtboard(): Artboard;              // rive::ArtboardInstance
+    artboardByName(name: string): Artboard;   // rive::ArtboardInstance
+    artboardByIndex(index: number): Artboard; // rive::ArtboardInstance
+    artboardCount(): number;
+  }
+
+  // This wraps rive::ArtboardInstance*
+  export declare class Artboard {
+    get name(): string;
+    get bounds(): AABB;
+    get frameOrigin(): boolean;
+    set frameOrigin(val: boolean);
+    // Deletes the backing wasm artboard instance
+    delete(): void;
+    advance(sec: number): any;
+    draw(renderer: CanvasRenderer): void;
+    animationByName(name: string): LinearAnimationInstance;
+    animationByIndex(index: number): LinearAnimationInstance;
+    animationCount(): number;
+    stateMachineByName(name: string): StateMachineInstance;
+    stateMachineByIndex(index: number): StateMachineInstance;
+    stateMachineCount(): number;
+    bone(name: string): Bone;
+    node(name: string): Node;
+    rootBone(name: string): RootBone;
+    transformComponent(name: string): TransformComponent;
+  }
+  
+  export declare class Bone extends TransformComponent {
+    length: number;
+  }
+  
+  export declare class RootBone extends Bone {
+    x: number;
+    y: number;
+  }
+  
+  export declare class Node extends TransformComponent {
+    x: number;
+    y: number;
+  }
+  
+  export declare class TransformComponent {
+    rotation: number;
+    scaleX: number;
+    scaleY: number;
+    worldTransform(): Mat2D;
+    parentWorldTransform(result: Mat2D): void;
+  }
+  
+  ///////////////
+  // Animation //
+  ///////////////
+  export declare class LinearAnimationInstance {
+    constructor(animation: LinearAnimationInstance, artboard: Artboard);
+    get name(): string;
+    get duration(): number;
+    get fps(): number;
+    get workStart(): number;
+    get workEnd(): number;
+    get loopValue(): number;
+    get speed(): number;
+    /** Time of the animation in seconds */
+    time: number;
+    didLoop: boolean;
+    advance(sec: number): any;
+    /**
+     * Apply animation on the artboard
+     * @param mix 0-1 the strength of the animation in the animations mix.
+     */
+    apply(mix: number): any;
+    // Deletes the backing Wasm animation instance
+    delete(): void;
+  }
+  
+  export declare class StateMachineInstance {
+    constructor(stateMachine: StateMachineInstance, artboard: Artboard);
+    get name(): string;
+    inputCount(): number;
+    input(i: number): SMIInput; 
+    advance(sec: number): any;
+    stateChangedCount(): number;
+    stateChangedNameByIndex(i: number): string;
+
+    // Call with coordinates in Artboard space
+    pointerDown(x: number, y: number): void;
+    pointerMove(x: number, y: number): void;
+    pointerUp(x: number, y: number): void;
+  
+    // Deletes the backing Wasm state machine instance
+    delete(): void;
+  }
+  
+  export declare class SMIInput {
+    static bool: number;
+    static number: number;
+    static trigger: number;
+  
+    get name(): string;
+    get type(): number;
+    get value(): boolean | number | undefined;
+    set value(val: boolean | number | undefined);
+    fire(): void;
+    asBool(): SMIInput;
+    asNumber(): SMIInput;
+    asTrigger(): SMIInput;
+  }
+  
+  export declare class SMIBool {
+  
+  }
+  
+  export declare class SMINumber {
+    
+  }
+  
+  export declare class SMITrigger {
+    
+  }
+  
+  ///////////
+  // ENUMS //
+  ///////////
+  
+  export enum Fit {
+    fill,
+    contain,
+    cover,
+    fitWidth,
+    fitHeight,
+    none,
+    scaleDown,
+  }
+  
+  export enum RenderPaintStyle {
+    fill,
+    stroke,
+  }
+  
+  export enum FillRule {
+    nonZero,
+    evenOdd,
+  }
+  
+  export enum StrokeCap {
+    butt,
+    round,
+    square,
+  }
+  export enum StrokeJoin {
+    miter,
+    round,
+    bevel,
+  }
+  
+  export enum BlendMode {
+    srcOver = 3,
+    screen = 14,
+    overlay = 15,
+    darken = 16,
+    lighten = 17,
+    colorDodge = 18,
+    colorBurn = 19,
+    hardLight = 20,
+    softLight = 21,
+    difference = 22,
+    exclusion = 23,
+    multiply = 24,
+    hue = 25,
+    saturation = 26,
+    color = 27,
+    luminosity = 28,
+  }
+  
+  ///////////
+  // UTILS //
+  ///////////
+  
+  export declare class Alignment {
+    get x(): number;
+    get y(): number;
+  }
+  
+  export declare class AlignmentFactory {
+    get topLeft(): Alignment;
+    get topCenter(): Alignment;
+    get topRight(): Alignment;
+    get centerLeft(): Alignment;
+    get center(): Alignment;
+    get centerRight(): Alignment;
+    get bottomLeft(): Alignment;
+    get bottomCenter(): Alignment;
+    get bottomRight(): Alignment;
+  }
+  
+  export interface AABB {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+  }
+  
+  export declare class Mat2D {
+    xx: number;
+    xy: number;
+    yx: number;
+    yy: number;
+    tx: number;
+    ty: number;
+    invert(mat: Mat2D): boolean;
+  }
+
+  export declare class Vec2D {
+    x(): void;
+    y(): void;
+  }
+