@plotdb/chart 0.0.2 → 1.0.3

package/web/src/pug/block/bar/0.0.1/index.ls

@@ -1,274 +0,0 @@
-<-(->it!) _
-
-block-factory =
-  pkg:
-    name: 'bar', version: '0.0.1'
-    extend: {name: "base", version: "0.0.1"}
-    dependencies: []
-    i18n:
-      "zh-TW":
-        "size": "長度"
-  init: ({root, context, t, pubsub}) ->
-    pubsub.fire \init, mod: mod({context, t})
-
-mod = ({context, t}) ->
-  {chart,d3,debounce} = context
-  sample: ->
-    raw: [0 to 10].map (val) ~>
-      ret = {name: val}
-      for i from 1 to 4 => ret["val#i"] = Math.random!
-      return ret
-    binding:
-      size: [1 to 4].map -> {key: "val#it", unit: "amount"}
-      name: {key: "name"}
-  config: {} <<< chart.utils.config.preset.default <<<
-    sort:
-      enabled: type: \boolean
-      dir: type: \choice, values: <[asc desc none]>
-    type: type: \choice, values: <[bar column]>, default: \column
-  dimension:
-    size: {type: \R, multiple: true, name: "size"}
-    name: {type: \NO, name: "name"}
-  init: ->
-    @tint = tint = new chart.utils.tint!
-    [[\multiple, \stack], [\percent, false], [\dancing, true]].map ([k,v]) ~>
-      if !(@cfg[k]?) => @cfg[k] = v
-    @svg.addEventListener \click, ~>
-      if !@cfg.dancing or @cfg.percent => return
-      @align-idx = ((@align-idx or 0) + 1) % (@binding.size.length + 1)
-      @resize!
-      @render!
-    @brush = d3.brushX!
-    @g = Object.fromEntries <[view xaxis yaxis legend]>.map ~> [it, d3.select(@layout.get-group it)]
-    @range = "null"
-    brush = debounce 150, (e) ~>
-      if @cfg.{}brush.enabled? and !@cfg.brush.enabled => return
-      range = e.selection
-      if (_range = JSON.stringify(range)) == @range => return else @range = _range
-      if !range => @filter {name: undefined}, true
-      else
-        domain = @scale.x.domain!
-        bandwidth = @scale.x.bandwidth!
-        range = range.map -> Math.floor(it / bandwidth) >? 0 <? (domain.length - 1)
-        range = [range.0 to range.1].map -> domain[it]
-        @filter {name: {type: 'index', value: range}}, true
-    @brush.on \end, brush
-    @brush.on \brush, brush
-    @scale = scale = {}
-    @yaxis = new chart.utils.axis layout: @layout, name: \yaxis, direction: \left
-    @xaxis = new chart.utils.axis layout: @layout, name: \xaxis, direction: \bottom
-    @legend = new chart.utils.legend do
-      layout: @layout
-      name: \legend
-      root: @root
-      shape: (d) -> d3.select(@).attr \fill, tint.get d.key
-    # d3.brush covers the whole svg element. need to support by calculation. TODO
-    /*
-    @tip = new chart.utils.tip {
-      root: @root
-      accessor: ({evt}) ~>
-        if !(evt.target and data = d3.select(evt.target).datum!) => return null
-        v = if isNaN(data.size) => '-' else "#{data.size.toFixed(2)}#{data.unit or ''}"
-        return {name: "#{data.group or ''} / #{data.name or ''}", value: v}
-      range: ~> @layout.get-node \view .getBoundingClientRect!
-    }
-    */
-
-  destroy: -> if @tip => @tip.destroy!
-
-  filter: (filters, internal = false) -> 
-    @render!
-    if internal => return
-    @brush.move @g.view, if filters.name => filters.name.map ~> @scale.x(it) else null
-  parse: ->
-    @data.map (d) -> d.size = d.size.map -> if isNaN(it) => 0 else it
-    @align-idx = undefined
-  resize: ->
-    @type = @cfg.type or \column
-    #@tip.toggle(if @cfg.{}tip.enabled? => @cfg.tip.enabled else true)
-    @legend.config @cfg.legend
-    @legend.update!
-    @layout.update false
-
-    @max-per-group = @binding.size.map (d,i) ~> Math.max.apply(Math, @data.map -> it.size[i])
-
-    # alternative align base. required for dancing stack
-    if @cfg.align-idx and !@align-idx => @align-idx = @cfg.align-idx
-    align-idx = (if @cfg.percent => 0 else (@align-idx or 0)) <? @binding.size.length
-    @base-offset = @data.map (d) -> [0 til align-idx].reduce(((a,b) -> a + d.size[b]),0) or 0
-    @delta = delta = Math.max.apply(Math, @base-offset)
-    # stack bar
-    if @cfg.multiple == \stack
-      # 100% stack
-      if @cfg.percent => max = 1
-      else
-        max = Math.max.apply(Math,
-          @data.map (d) ~> [align-idx til d.size.length].reduce(((a,b) -> a + d.size[b]),0)
-        ) + (delta or 0)
-    # group bar
-    else if @cfg.multiple == \group
-      max = Math.max.apply(Math, @data.map (d) ~> Math.max.apply(Math, d.size))
-    # split bars
-    else if @cfg.multiple == \split
-      max = @max-per-group.reduce(((a,b) -> a + b),0)
-    @order = @data.map (d,i) -> {key: d._idx, idx: i, name: d.name}
-    @data.map (d,i) -> d.sum = d.size.reduce(((a,b) -> a + b),0)
-    if @cfg.{}sort.enabled =>
-      @order.sort (a,b) ~> (if @cfg.sort.dir == \asc => 1 else -1) * (@data[a.idx].sum - @data[b.idx].sum)
-    console.log @cfg
-    if @cfg.palette => @tint.set(@cfg.palette.colors.map -> it.value or it)
-    # order reversed to make it visually aligned with bar.
-    @legend.data [{
-      key: i, text: @binding.size[i].name or @binding.size[i].key
-    } for i from @binding.size.length - 1 to 0 by -1 ]
-    @layout.update false
-
-    box = @layout.get-box \view
-
-    if @type == \column =>
-      @scale <<<
-        y: d3.scaleLinear!domain([0,max]).range [box.height, 0]
-        x: d3.scaleBand!domain @order.map(->it.name or it.key) .range [0, box.width]
-      max-tick = Math.ceil(@layout.get-box \yaxis .height / 40) >? 2
-      yticks = if @cfg.bump => [1 to ((@parsed.length or 1) >? 1)]
-      else @scale.y.ticks((@cfg.{}yaxis.tick-count or 4) <? max-tick)
-      @yaxis.config @cfg.yaxis
-      v = @binding.size.0 or {}
-      if @binding.size.length > 1 => @yaxis.caption( if v.unit => "#{v.unit}" else '')
-      else @yaxis.caption( (v.name or v.key or '') + if v.unit => "(#{v.unit})" else '')
-      @yaxis.ticks yticks
-      @yaxis.scale @scale.y
-      @xaxis.config @cfg.{}xaxis
-      @xaxis.ticks @data.map -> it.name
-      @xaxis.scale @scale.x
-      @xaxis.caption(
-        (@binding.name.name or @binding.name.key) +
-        if @binding.name.unit => "(#{@binding.name.unit})" else ''
-      )
-    else
-      @scale <<<
-        x: d3.scaleLinear!domain([0,max]).range [box.width, 0]
-        y: d3.scaleBand!domain @order.map(->it.name or it.key) .range [0, box.height]
-      max-tick = Math.ceil(@layout.get-box \xaxis .width / 80) >? 2
-      xticks = if @cfg.bump => [1 to ((@parsed.length or 1) >? 1)]
-      else @scale.x.ticks((@cfg.{}xaxis.tick-count or 4) <? max-tick)
-      @xaxis.config @cfg.xaxis
-      v = @binding.size.0 or {}
-      if @binding.size.length > 1 => @xaxis.caption( if v.unit => "#{v.unit}" else '')
-      else @xaxis.caption( (v.name or v.key or '') + if v.unit => "(#{v.unit})" else '')
-      @xaxis.ticks xticks
-      @xaxis.scale @scale.x
-      @yaxis.config @cfg.{}yaxis
-      @yaxis.ticks @data.map -> it.name
-      @yaxis.scale @scale.y
-      @yaxis.caption(
-        (@binding.name.name or @binding.name.key) +
-        if @binding.name.unit => "(#{@binding.name.unit})" else ''
-      )
-
-    # xaxis and yaxis affect each other and they all affect view.
-    # we may need to update them until stable but for now we simply layout twice.
-    for i from 0 til 2 =>
-      @layout.update false
-      box = @layout.get-box('view')
-      [w,h] = [box.width, box.height]
-      @tint.set @cfg.palette
-      r = @cfg.dot-size or 3
-      @scale.x.range [0, w - r]
-      @scale.y.range [h, r]
-      @xaxis.render!
-      @yaxis.render!
-
-    box = @layout.get-box \view
-    @brush.extent [[0, 1],[box.width, box.height - 1]]
-
-  render: ->
-    {binding, scale, range, delta, base-offset, max-per-group, cfg, tint, data, type} = @
-    @g.view.selectAll \g.bar .data @data
-      ..exit!remove!
-      ..enter!append \g .attr \class, \bar
-    @g.view.selectAll \g.bar
-      .attr \transform, (d,i) ~>
-        if @type == \column => "translate(#{scale.x(d.name)},0)"
-        else "translate(0,#{scale.y(d.name)})"
-      .each (item,j) ->
-        [bars,offset] = [[],0]
-        # alternative align base. required for dancing stack
-        offset = (delta - base-offset[j])
-
-        # use to tweak output size / offset. 1 = no modification
-        sum = 1
-        # and set sum to this for 100% stack bar
-        if cfg.percent == true => sum = item.size.reduce(((a,b) -> a + b),0) >? 1
-
-        for idx from 0 til item.size.length =>
-          size = item.size[idx]
-          key = idx
-          bars.push {
-            size: size / sum
-            offset: offset / sum
-            key: key
-            group: item.name
-            name: binding.size[key].name or binding.size[key].key
-            unit: binding.size[key].unit or ''
-          }
-          # multiple bars
-          if cfg.multiple == \split => offset += max-per-group[idx]
-          # stack bar
-          else if cfg.multiple == \stack => offset += size
-
-
-        d3.select @ .selectAll \rect .data(bars, (d,i) -> d.key)
-          ..exit!remove!
-          ..enter!append \rect
-            ..attr(\width, (d,i) -> (scale.x.bandwidth! - 2) >? 1) if type == \column
-            ..attr(\y, (d,i) -> scale.y(0))                  if type == \column
-            ..attr(\height, (d,i) -> (scale.y.bandwidth! - 2) >? 1) if type != \column
-            ..attr(\x, (d,i) -> scale.x(0))                  if type != \column
-
-        tran = d3.select @ .selectAll \rect
-          .transition!duration 350
-          # group bar
-          .call (sel) ->
-            if cfg.multiple != \group => return
-            sel
-              ..attr(\x, (d,i) -> 1 + i * (scale.x.bandwidth! - 2) / bars.length)    if type == \column
-              ..attr(\width, (d,i) -> (scale.x.bandwidth! - 2) / bars.length)        if type == \column
-              ..attr(\y, (d,i) -> Math.round(Math.min(scale.y(0), scale.y(d.size)))) if type == \column
-
-              ..attr(\y, (d,i) -> 1 + i * (scale.y.bandwidth! - 2) / bars.length)    if type != \column
-              ..attr(\height, (d,i) -> (scale.y.bandwidth! - 2) / bars.length)       if type != \column
-              ..attr(\x, (d,i) -> Math.round(Math.min(scale.x(0), scale.x(d.size)))) if type != \column
-
-          # stack bar
-          .call (sel) ->
-            if cfg.multiple != \stack => return
-            sel
-              ..attr(\x, 1) if type == \column
-              ..attr(\width, (d,i) -> scale.x.bandwidth! - 2) if type == \column
-              ..attr( \y, (d,i) -> Math.round(Math.min(scale.y(d.offset), scale.y(d.offset + d.size)))) if type == \column
-              ..attr(\y, 1) if type != \column
-              ..attr(\height, (d,i) -> scale.y.bandwidth! - 2) if type != \column
-              ..attr( \x, (d,i) -> Math.round(Math.min(scale.x(d.offset), scale.x(d.offset + d.size)))) if type != \column 
-
-        if type == \column =>
-          tran.attr \height, (d,i) -> Math.round(Math.abs(scale.y(0) - scale.y(d.size)))
-        else
-          tran.attr \width, (d,i) -> Math.round(Math.abs(scale.x(0) - scale.x(d.size)))
-        tran
-          .attr \fill, (d,i) ~> tint.get i, (if cfg.color-variant => ((j/data.length) - 0.5) else 0)
-          .attr \fill-opacity, (d,i) ~>
-            if !(binding.name and filter = binding.name.filter) => return 1
-            if !(range = filter.value) => return 1
-            if item.name in range => 1 else 0.2
-
-    if !(@cfg.{}brush.enabled? and !@cfg.brush.enabled) => @g.view.call @brush
-    @g.view.selectAll \rect.selection
-      .attr \shape-rendering, \auto
-    @legend.render!
-    @yaxis.render!
-    @xaxis.render!
-
-  tick: ->
-
-return block-factory

package/web/src/pug/block/bar/0.0.1/index.pug

@@ -1,35 +0,0 @@
-div
-  div(plug="layout")
-    .pdl-layout
-      div(data-type="layout")
-        .pdl-cell(data-name="yaxis")  
-        .pdl-cell(data-name="view")
-        .pdl-cell
-        .pdl-cell(data-name="xaxis")  
-        .pdl-cell(data-name="legend")  
-      div(data-type="render")
-
-  style(type="text/css"): :stylus
-    [data-name=xaxis] { font-size: 0.8em }
-    [data-name=yaxis] { font-size: 0.8em }
-    .pdl-layout > div[data-type=layout]
-      display: grid
-      grid-template-columns: fit-content(2em) 1fr fit-content(10em)
-      grid-template-rows: 1fr fit-content(1em)
-      /* 0.5em for axis label at the boundary */
-      padding: 0 0.5em
-      & > .pdl-cell[data-name=legend]
-        grid-column: 3
-        grid-row: 1 / span 2
-        padding-left: 1em
-
-    .pdl-layout.legend-below > div[data-type=layout]
-      grid-template-columns: 2em 1fr
-      grid-template-rows: 1fr fit-content(2em) fit-content(3em)
-      .pdl-cell[data-name=legend]
-        padding-top: 1em
-        grid-column: 1 / span 2
-        grid-row: 3
-
-
-  script(type="@plotdb/block"): include:lsc index.ls

package/web/src/pug/block/bar-list/0.0.1/index.ls

@@ -1,85 +0,0 @@
-<-(->it!) _
-
-block-factory =
-  pkg:
-    name: 'bar-list', version: '0.0.1'
-    extend: {name: "base", version: "0.0.1"}
-    dependencies: [
-      {url: "/assets/lib/ldview/main/index.min.js"}
-    ]
-  init: ({root, context, t, pubsub}) ->
-    pubsub.fire \init, {
-      mod: mod({root, context, t})
-      prepare-svg: false
-      layout: false
-      data-accessor: -> it._data._raw
-    }
-
-mod = ({root, context, t}) ->
-  {chart,d3,debounce} = context
-  sample: ->
-    raw: [0 to 10].map -> {name: it, value: (Math.random! * 100).toFixed(2)}
-    binding:
-      size: {key: "value"}
-      name: {key: "name"}
-  config: {}
-  dimension:
-    size: {type: \R, name: "size"}
-    name: {type: \NO, name: "name"}
-  init: ->
-    @picked = {}
-    @tint = tint = new chart.utils.tint!
-    @scale = scale = {}
-    @extent = {}
-    get-list = ~>
-      return [[k,v] for k,v of @picked].filter(-> !it.1).map -> it.0
-
-    @view = new ldview do
-      root: root
-      init-render: false
-      action: click:
-        select: ({views, node}) ~>
-          name = node.getAttribute \data-name
-          if name == \none => @parsed.map ~> @picked[it.name] = false
-          else @picked = {}
-          @filter {name: {type: 'exclude', value: get-list!}}, true
-          views.0.render \data
-
-      handler:
-        data:
-          list: ~> @parsed
-          key: -> it._idx
-          action: click: ({views, node, data}) ~>
-            @picked[data.name] = if @picked[data.name]? => !@picked[data.name] else false
-            views.0.render \data, data._idx
-            @filter {name: {type: 'exclude', value: get-list!}}, true
-
-          handler: ({node, data}) ~>
-            nn = node.querySelector('[ld=name]')
-            nb = node.querySelector('[ld=bar]')
-            unit = (@binding.{}size.unit or '')
-            nn.textContent = "#{data.name} / #{data.size}#{unit}"
-            nb.style <<< width: "#{(@scale.x data.size)}%", background: @tint.get 'size'
-            node.style.opacity = if @picked[data.name] == false => 0.3 else 1
-
-  filter: (filters, internal = false)->
-  parse: ->
-    @parsed = @data.map -> it
-    names = @parsed.map -> it.name
-    @parsed ++= [k for k of @picked]
-      .filter -> !(it in names)
-      .map ~> {name: it, size: 0}
-    @parsed.sort (a,b) ~>
-      pb = !(@picked[b.name]?) or @picked[b.name]
-      pa = !(@picked[a.name]?) or @picked[a.name]
-      if pb and !pa => return 1 else if !pb and pa => return -1
-      if b.size - a.size => return that
-      return 0
-    @parsed.map (d,i) -> d._idx = i
-
-  resize: ->
-    @extent = d3.extent @parsed.map -> it.size
-    @scale.x = d3.scaleLinear!domain [0, @extent.1] .range [0, 100]
-  render: -> @view.render!
-
-return block-factory

package/web/src/pug/block/bar-list/0.0.1/index.pug

@@ -1,30 +0,0 @@
-div
-  div(plug="layout")
-    .pdl-layout
-      div(data-type="layout")
-      div(data-type="render")
-        .d-flex
-          .flex-grow-1
-            .data(ld-each="data")
-              div(ld="name")
-              div(ld="bar")
-          div(style="position:sticky;margin-left:1em;margin-right:.25em;" +
-          "cursor:pointer;white-space:nowrap;top:0;right:0;align-self:flex-start;height:auto;")
-            div(ld="select",data-name="all") 全選
-            div(ld="select",data-name="none") 全不選
-
-  style(type="text/css"): :stylus
-    .data
-      padding-bottom: 1em
-    .pdl-layout
-      overflow-y: scroll
-      user-select: none
-      [data-type=render]
-        overflow-y: visible
-        height: auto
-      .data
-        cursor: pointer
-      div[ld=bar]
-        height: .5em
-        border-radius: 2px
-  script(type="@plotdb/block"): include:lsc index.ls

package/web/src/pug/block/bar-race/0.0.1/index.ls

@@ -1,83 +0,0 @@
-<-(->it!) _
-
-block-factory =
-  pkg:
-    name: 'bar-race', version: '0.0.1'
-    extend: {name: "base", version: "0.0.1"}
-    dependencies: []
-    i18n:
-      "zh-TW":
-        "height": "高度"
-  init: ({root, context, t, pubsub}) ->
-    pubsub.fire \init, mod: mod({context, t})
-
-mod = ({context, t}) ->
-  {chart,d3,debounce} = context
-  sample: ->
-    raw: [0 to 100].map (val) ~>
-      [n,o] = [val % 10, Math.floor(val / 10)]
-      ret = {name: n, value: Math.random!, order: o}
-      return ret
-    binding:
-      order: {key: "order"}
-      value: {key: "value"}
-      name: {key: "name"}
-  config: {}
-  dimension:
-    order: {type: \O, name: "order", priority: 1}
-    value: {type: \R, name: "value", priority: 2}
-    name: {type: \N, name: "name"}
-  init: ->
-    @tint = tint = new chart.utils.tint!
-    @g =
-      view: d3.select(@layout.get-group \view)
-      axis: d3.select(@layout.get-group \axis)
-    @scale = scale = {}
-    @axis-bottom = d3.axis-bottom!
-    @legend = new chart.utils.legend do
-      layout: @layout
-      name: \legend
-      root: @root
-      shape: (d) -> d3.select(@).attr \fill, tint.get d.key
-  parse: ->
-    @data.map (d) -> d.value = d.value.map -> if isNaN(it) => 0 else +it
-    @names = Array.from(new Set(@data.map -> it.name))
-  resize: ->
-    @layout.get-node \legend .style.width = if !(@cfg.{}legend.enabled?) or @cfg.legend.enabled => '' else '0'
-    @layout.update false
-
-    @max-per-group = @binding.height.map (d,i) ~> Math.max.apply(Math, @data.map -> it.height[i])
-    @order = @data.map (d,i) -> {key: d._idx, idx: i, name: d.order}
-    @order.sort (a,b) -> if b.name > a.name => 1 else if b.name < a.name => -1 else 0
-
-    @tint.set @cfg.palette
-    @legend.data [{ key: i, text: @names[i] } for i from 0 til @names.length]
-    @layout.update false
-    max = Math.max @data.map -> it.value
-
-    box = @layout.get-box \view
-    @scale <<<
-      y: d3.scaleLinear!domain([0,max]).range [box.width, 0]
-      x: d3.scaleBand!domain @order.map(->it.name or it.key) .range [0, box.height]
-    /*
-    @axis-bottom.scale @scale.x
-      ..ticks(@cfg.tick-count) if @cfg.tick-count?
-      ..tickFormat(d3.format(@cfg.tick-format)) if @cfg.tick-format?
-      ..tickSizeInner @cfg.tick-size-inner if @cfg.tick-size-inner?
-      ..tickSizeOuter @cfg.tick-size-outer if @cfg.tick-size-outer?
-      ..tickPadding @cfg.tick-padding if @cfg.tick-padding?
-    */
-
-  render: ->
-    {binding, scale, range, delta, cfg, tint, data} = @
-    @g.view.selectAll \g.bar .data @data
-      ..exit!remove!
-      ..enter!append \g .attr \class, \bar
-    @g.view.selectAll \g.bar
-      .attr \transform, (d,i) -> "translate(#{scale.x(d.name)},0)"
-
-    @g.axis.call @axis-bottom
-      .attr \font-size, ''
-  tick: ->
-
-return block-factory

package/web/src/pug/block/bar-race/0.0.1/index.pug

@@ -1,21 +0,0 @@
-div
-  div(plug="layout")
-    .pdl-layout
-      div(data-type="layout")
-        .pdl-cell(data-name="view")
-        .pdl-cell(data-name="axis")  
-        .pdl-cell(data-name="legend")  
-      div(data-type="render")
-
-  style(type="text/css"): :stylus
-    g[data-name=axis] { font-size: 11px }
-    .pdl-layout > div[data-type=layout]
-      display: grid
-      grid-template-columns: 1fr fit-content(10em)
-      grid-template-rows: 1fr fit-content(1em)
-      & > .pdl-cell[data-name=legend]
-        grid-column: 2
-        grid-row: 1 / span 2
-        padding-left: 1em
-
-  script(type="@plotdb/block"): include:lsc index.ls

package/web/src/pug/block/base/0.0.1/index.ls

@@ -1,67 +0,0 @@
-
-
-pkg:
-  name: 'base', version: '0.0.1'
-  dependencies: [
-    {name: "d3", version: "4", async: false}
-    {name: "d3-selection", version: "2", async: false}
-    {name: "d3-random", version: "2"}
-    {name: "d3-dispatch", version: "2", async: false}
-    {name: "d3-transition", version: "2"}
-    {name: "d3-format", version: "2"}
-    {name: "d3-array", version: "2", async: false}
-    {name: "d3-color", version: "2"}
-    {name: "d3-path", version: "2"}
-    {name: "d3-shape", version: "2"}
-    {name: "d3-interpolate", version: "2", async: false}
-    {name: "d3-scale-chromatic", version: "1"}
-    {name: "d3-ease", version: "2"}
-    {name: "d3-quadtree", version: "2"}
-    {name: "d3-timer", version: "2"}
-    {name: "d3-force", version: "2", async: false}
-    {name: "d3-hierarchy", version: "2"}
-    {name: "d3-force-boundary", version: "0.0.1"}
-    {name: "d3-drag", version: "2"}
-    {name: "d3-brush", version: "2"}
-    {name: "d3-axis", version: "2"}
-    {name: "@loadingio/debounce.js", version: "main", path: "debounce.min.js"}
-    {name: "wrap-svg-text", version: "main", path: "index.min.js", async: false}
-    {name: "@plotdb/layout", version: "main", path: "index.min.js", async: false}
-    {name: "@plotdb/layout", version: "main", path: "index.min.css", type: \css}
-    {name: "ldcolor", version: "main", path: "ldcolor.min.js", async: false}
-    {name: "@plotdb/chart", version: "main", path: "chart.js", async: false}
-    {name: "@plotdb/chart", version: "main", path: "chart.min.css", type: \css}
-    {name: "@plotdb/chart", version: "main", path: "utils/config.js"}
-    {name: "@plotdb/chart", version: "main", path: "utils/legend.js"}
-    {name: "@plotdb/chart", version: "main", path: "utils/legend.css", type: \css}
-    {name: "@plotdb/chart", version: "main", path: "utils/tint.js"}
-    {name: "@plotdb/chart", version: "main", path: "utils/format.js", async: false}
-    {name: "@plotdb/chart", version: "main", path: "utils/axis.js"}
-    {name: "@plotdb/chart", version: "main", path: "utils/tip.js"}
-  ]
-  i18n:
-    "zh-TW": 
-      "x axis": "X軸"
-      name: "名稱"
-
-init: ({root, context, pubsub, data}) ->
-  {d3,chart} = context
-  pubsub.on \init, (opt = {}) ~>
-    opt = {
-      root: root
-      delay-render: true
-      auto-select: true
-      data-accessor: -> d3.select(it).datum!._raw
-    } <<< opt
-    original-init = opt.mod.init 
-    opt.mod.init = ->
-      @random = d3.randomUniform.source(d3.randomLcg(123))(0, 1)
-      ret = original-init.apply @
-      return Promise.resolve!
-    @chart = c = new chart(opt <<< data)
-    c.init!then -> c
-  @
-
-interface: -> @chart
-
-mod: (root) -> {config: {}, dimension: {}, init: (->), resize: (->), render: (->)}

package/web/src/pug/block/base/0.0.1/index.pug

@@ -1,5 +0,0 @@
-.base(style="width:100%;height:100%")
-  plug(name="layout")
-  style(type="text/css"): :stylus
-    *[plug=layout] { fill: currentColor }
-  script(type="@plotdb/block"): include:lsc index.ls

package/web/src/pug/block/blank/0.0.1/index.ls

@@ -1,25 +0,0 @@
-<-(->it!) _
-
-block-factory =
-  pkg:
-    name: \blank, version: \0.0.1
-    extend: name: \base, version: \0.0.1
-    dependencies: []
-
-  init: ({root, context, pubsub}) ->
-    pubsub.fire \init,
-      mod: mod {context}
-      raw: [0 to 100]
-      binding: {}
-
-mod = ({context}) ->
-  {} = context
-  config: {}
-  dimension: {}
-  init: ->
-  parse: ->
-  resize: ->
-  render: ->
-  tick: ->
-
-return block-factory

package/web/src/pug/block/blank/0.0.1/index.pug

@@ -1 +0,0 @@
-div(style="width:100%;height:100%"): script(type="@plotdb/block"): include:lsc index.ls