aboutsummaryrefslogtreecommitdiff
path: root/src/build.gleam
blob: e85f13abde2969173b36e303232caad79c1cdb83 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
import gleam/io
import gleam/list
import gleam/string
import gleam/result
import gleam/javascript/promise.{type Promise}
import bundle

@external(javascript, "./build_ffi.mjs", "bundle_build")
pub fn bundle_build(entry f: String, outfile o: String) -> Promise(Result(Nil, String))

@external(javascript, "./build_ffi.mjs", "js_build")
pub fn js_build(content c: String, outfile o: String) -> Promise(Result(Nil, String))

@external(javascript, "./build_ffi.mjs", "copy_build")
pub fn copy_build(json f: String, outfile o: String) -> Promise(Result(Nil, String))

@external(javascript, "./build_ffi.mjs", "less_build")
pub fn less_build(less f: String, outfile o: String) -> Promise(Result(Nil, String))

const entry = "./build/dev/javascript/wechat_dev_tools/bundle.mjs"
const app_content = "import { app } from './bundle.mjs'; app()"
const dist = "./dist/"
const src = "./src/app/"

pub type Builder = fn(String, String) -> Promise(Result(Nil, String))

pub type Asset {
    Asset(src: String, dist: String, builder: Builder)
}

fn file_path(path: String, p: String, t: String) -> String {
  string.concat([ path, p, "/", p, ".", t, ])
}

fn index_path(path: String, p: String, t: String) -> String {
  string.concat([ path, p, "/", "index.", t, ])
}

fn page_content(p: String) -> String {
  string.concat([
    "import { pages, page } from '../../bundle.mjs'; page(pages(), \"",
    p,
    "\")",
  ])
}

fn component_content(p: String) -> String {
  string.concat([
    "import { components, component } from '../../bundle.mjs'; component(components(), \"",
    p,
    "\")",
  ])
}

fn bundle_asset() -> List(Asset) {
  [ Asset(entry, dist <> "bundle.mjs", bundle_build) ]
}

fn app_assets() -> List(Asset) {
  [ Asset(app_content, dist <> "app.js", js_build),
    Asset(src <> "app.json", dist <> "app.json", copy_build),
    Asset(src <> "app.less", dist <> "app.wxss", less_build) ]
}

fn page_assets(p: String) -> List(Asset) {
  [ Asset(page_content(p), file_path(dist <> "/pages/", p, "js"), js_build),
    Asset(file_path(src <> "/pages/", p, "json"), file_path(dist <> "/pages/", p, "json"), copy_build),
    Asset(file_path(src <> "/pages/", p, "wxml"), file_path(dist <> "/pages/", p, "wxml"), copy_build),
    Asset(file_path(src <> "/pages/", p, "less"), file_path(dist <> "/pages/", p, "wxss"), less_build) ]
}

fn pages_assets() -> List(Asset) {
  bundle.pages()
  |> list.map(fn(p) { p.0 })
  |> list.flat_map(fn(p) { page_assets(p) })
}

fn component_assets(p: String) -> List(Asset) {
  [ Asset(component_content(p), index_path(dist <> "/components/", p, "js"), js_build),
    Asset(file_path(src <> "/components/", p, "json"), index_path(dist <> "/components/", p, "json"), copy_build),
    Asset(file_path(src <> "/components/", p, "wxml"), index_path(dist <> "/components/", p, "wxml"), copy_build),
    Asset(file_path(src <> "/components/", p, "less"), index_path(dist <> "/components/", p, "wxss"), less_build) ]
}

fn components_assets() -> List(Asset) {
  bundle.components()
  |> list.map(fn(p) { p.0 })
  |> list.flat_map(fn(p) { component_assets(p) })
}

fn fold_result(r0: Result(Nil, String), r: Result(Nil, String)) -> Result(Nil, String) {
  case r0, r {
    Ok(Nil), Ok(Nil)          -> r0
    Error(_), Ok(Nil)         -> r0
    Ok(Nil), Error(_)         -> r
    Error(e1), Error(e2)      -> Error(e1 <> e2)
  }
}

fn build(ass: List(Asset)) -> Promise(Result(Nil, String)) {
  ass
  |> list.map(fn(a) { a.builder(a.src, a.dist) })
  |> promise.await_list
  |> promise.map(fn(ls) {
       ls
       |> list.fold(Ok(Nil), fold_result)
     })
}

pub fn main() {
  use r0 <- promise.await(build(bundle_asset()))
  use r1 <- promise.await(build(app_assets()))
  use r2 <- promise.await(build(pages_assets()))
  use r3 <- promise.await(build(components_assets()))

  [r0, r1, r2, r3]
  |> list.fold(Ok(Nil), fold_result)
  |> result.map_error(fn (e) { io.println_error(e) })
  |> promise.resolve
}