github.com/vugu/vugu@v0.3.5/lifecycle.go (about)

     1  package vugu
     2  
     3  // // UnlockRenderer is something that releases a lock and requests a re-render.
     4  // type UnlockRenderer interface {
     5  // 	UnlockRender()
     6  // }
     7  
     8  // InitCtx is the context passed to an Init callback.
     9  type InitCtx interface {
    10  	EventEnv() EventEnv
    11  
    12  	// TODO: decide if we want to do something like this for convenience
    13  	// Lock() UnlockRenderer
    14  }
    15  
    16  type initCtx struct {
    17  	eventEnv EventEnv
    18  }
    19  
    20  // EventEnv implements InitCtx
    21  func (c *initCtx) EventEnv() EventEnv {
    22  	return c.eventEnv
    23  }
    24  
    25  type initer0 interface {
    26  	Init()
    27  }
    28  type initer1 interface {
    29  	Init(ctx InitCtx)
    30  }
    31  
    32  func invokeInit(c interface{}, eventEnv EventEnv) {
    33  	if i, ok := c.(initer0); ok {
    34  		i.Init()
    35  	} else if i, ok := c.(initer1); ok {
    36  		i.Init(&initCtx{eventEnv: eventEnv})
    37  	}
    38  }
    39  
    40  // ComputeCtx is the context passed to a Compute callback.
    41  type ComputeCtx interface {
    42  	EventEnv() EventEnv
    43  }
    44  
    45  type computeCtx struct {
    46  	eventEnv EventEnv
    47  }
    48  
    49  // EventEnv implements ComputeCtx
    50  func (c *computeCtx) EventEnv() EventEnv {
    51  	return c.eventEnv
    52  }
    53  
    54  type computer0 interface {
    55  	Compute()
    56  }
    57  type computer1 interface {
    58  	Compute(ctx ComputeCtx)
    59  }
    60  
    61  func invokeCompute(c interface{}, eventEnv EventEnv) {
    62  	if i, ok := c.(computer0); ok {
    63  		i.Compute()
    64  	} else if i, ok := c.(computer1); ok {
    65  		i.Compute(&computeCtx{eventEnv: eventEnv})
    66  	}
    67  }
    68  
    69  // DestroyCtx is the context passed to a Destroy callback.
    70  type DestroyCtx interface {
    71  	EventEnv() EventEnv
    72  }
    73  
    74  type destroyCtx struct {
    75  	eventEnv EventEnv
    76  }
    77  
    78  // EventEnv implements DestroyCtx
    79  func (c *destroyCtx) EventEnv() EventEnv {
    80  	return c.eventEnv
    81  }
    82  
    83  type destroyer0 interface {
    84  	Destroy()
    85  }
    86  type destroyer1 interface {
    87  	Destroy(ctx DestroyCtx)
    88  }
    89  
    90  func invokeDestroy(c interface{}, eventEnv EventEnv) {
    91  	if i, ok := c.(destroyer0); ok {
    92  		i.Destroy()
    93  	} else if i, ok := c.(destroyer1); ok {
    94  		i.Destroy(&destroyCtx{eventEnv: eventEnv})
    95  	}
    96  }
    97  
    98  // RenderedCtx is the context passed to the Rendered callback.
    99  type RenderedCtx interface {
   100  	EventEnv() EventEnv // in case you need to request re-render
   101  	First() bool        // true the first time this component is rendered
   102  }