d307cd4...master · purescript-indexed-DB

git.iko.soy/purescript-indexed-DB

on master help sign in

dev/deploy.shdeleted−6

since splitsnapshots

unifiedsplit

@@ -1,6 +0,0 @@

1−#!/bin/sh

2−

3−git stash save

4−git clean -df

5−yes | pulp publish --no-push

6−git stash pop

dev/test.shdeleted−8

@@ -1,8 +0,0 @@

1−#!/bin/sh

2−

3−set -e

4−

5−spago bundle-app -m Test.Main --to test.js

6−

7−xdg-open test.html

8−

index.jsnew file+4

@@ -0,0 +1,4 @@

1+import "fake-indexeddb/auto";

2+import * as Main from './output/Test.Main/index.js';

4+Main.main();

package.jsonnew file+15

@@ -0,0 +1,15 @@

1+{

2+ "name": "purescript-indexed-DB",

3+ "version": "1.0.0",

4+ "main": "index.js",

5+ "repository": "https://github.com/ilyakooo0/purescript-indexed-DB.git",

6+ "author": "iko <mail@iko.soy>",

7+ "license": "MIT",

8+ "scripts": {

9+ "test": "spago build && node index.js"

10+ },

11+ "dependencies": {

12+ "fake-indexeddb": "^4.0.1"

13+ },

14+ "type": "module"

15+}

packages.dhall−15

@@ -102,19 +102,4 @@ in upstream

102let upstream =

103 https://github.com/purescript/package-sets/releases/download/psc-0.15.4-20221124/packages.dhall

104 sha256:792255bbd8e2141468d967325f3e78246cb7e500bf3ab6d76d5b22dffbb09d49

105−

106− with spec-mocha =

107− { repo =

108− "https://github.com/ilyakooo0/purescript-spec-mocha"

109− , version = "v4.0.2", dependencies =

110− [ "aff"

111− , "datetime"

112− , "effect"

113− , "either"

114− , "foldable-traversable"

115− , "maybe"

116− , "prelude"

117− , "spec"

118− ]

119− }

120in upstream

105in upstream

spago.dhall+1−2

@@ -10,7 +10,7 @@ When creating a new Spago project, you can use

10`spago init --no-comments` or `spago init -C`

11to generate this file without the comments in this block.

12-}

13−{ name = "indexeddb"

13+{ name = "indexed-db"

14, dependencies =

15 [ "aff"

16 , "arrays"

@@ -34,7 +34,6 @@ to generate this file without the comments in this block.

34 , "prelude"

35 , "read"

36 , "spec"

37− , "spec-mocha"

38 , "transformers"

37 , "transformers"

39 , "tuples"

38 , "tuples"

40 ]

39 ]

test.htmldeleted−25

@@ -1,25 +0,0 @@

1−<!DOCTYPE html>

2−<html lang="en">

3−

4−<head>

5− <meta charset="UTF-8">

6− <meta http-equiv="X-UA-Compatible" content="IE=edge">

7− <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">

8− <link rel="stylesheet" href="https://unpkg.com/mocha/mocha.css">

9−</head>

10−

11−<body>

12− <div id="mocha"></div>

13− <script src="https://unpkg.com/chai/chai.js"></script>

14− <script src="https://unpkg.com/mocha/mocha.js"></script>

15− <script class="mocha-init">

16− mocha.setup('bdd');

17− mocha.checkLeaks();

18− </script>

19− <script src="test.js"></script>

20− <script>

21− mocha.run()

22− </script>

23−</body>

24−

25−</html>

test/Main.purs+1049−1048

@@ -31,7 +31,8 @@ import Effect.Exception (name)

31import Effect.Now (now)

32import Test.Spec (describe, it)

33import Test.Spec.Assertions (shouldEqual, fail)

34−import Test.Spec.Mocha (runMocha)

34+import Test.Spec.Reporter (consoleReporter)

35+import Test.Spec.Runner (runSpec)

36infixr 7 Tuple as :+:

37infixr 7 Tuple as :+:

@@ -45,1096 +46,1096 @@ modifyAVar fn v = do

45 AVar.put (fn val) v

46 AVar.put (fn val) v

47main :: Effect Unit

48main :: Effect Unit

48−main =

49+main = do

49− runMocha

50+ launchAff_ $ runSpec [ consoleReporter ] $ do

50− do

51+ describe "IDBFactory" do

51− describe "IDBFactory" do

52− let

52+ let

53− tearDown name version db = do

53+ tearDown name version db = do

54− IDBDatabase.close db

54+ IDBDatabase.close db

55− version' <- IDBFactory.deleteDatabase name

55+ version' <- IDBFactory.deleteDatabase name

56− liftEffect $ log $ show version'

56+ liftEffect $ log $ show version'

57− version' `shouldEqual` version

58−

59− it "open default" do

60− let

61− name = "db-default"

62− version = 1

57+ version' `shouldEqual` version

63− db <- IDBFactory.open name Nothing

64− { onUpgradeNeeded: Nothing

65− , onBlocked: Nothing

66− }

67− IDBDatabase.name db `shouldEqual` name

68− tearDown name version db

59+ it "open default" do

60+ let

61+ name = "db-default"

62+ version = 1

63+ db <- IDBFactory.open name Nothing

64+ { onUpgradeNeeded: Nothing

65+ , onBlocked: Nothing

66+ }

67+ IDBDatabase.name db `shouldEqual` name

68+ tearDown name version db

69+

70− it "open specific version" do

70+ it "open specific version" do

71− let

71+ let

72− name = "db-specific"

72+ name = "db-specific"

73− version = 14

73+ version = 14

74+ db <- IDBFactory.open name (Just version)

75+ { onUpgradeNeeded: Nothing

76+ , onBlocked: Nothing

77+ }

78+ IDBDatabase.name db `shouldEqual` name

79+ tearDown name version db

80+

81+ it "open specific version -> close -> open latest" do

82+ let

83+ name = "db-latest"

84+ version = 14

74− db <- IDBFactory.open name (Just version)

85+ db01 <- IDBFactory.open name (Just version)

75− { onUpgradeNeeded: Nothing

86+ { onUpgradeNeeded: Nothing

76− , onBlocked: Nothing

87+ , onBlocked: Nothing

77− }

88+ }

78− IDBDatabase.name db `shouldEqual` name

89+ IDBDatabase.name db01 `shouldEqual` name

90+ IDBDatabase.close db01

91+ db02 <- IDBFactory.open name Nothing

92+ { onUpgradeNeeded: Nothing

93+ , onBlocked: Nothing

94+ }

79− tearDown name version db

95+ tearDown name version db02

96+

97+ it "open + onUpgradeNeed" do

98+ let

99+ name = "db-upgrade-needed"

100+ version = 1

101+ callback (Tuple varName varVersion) db _ { oldVersion } = do

102+ _ <- launchAff $ modifyAVar (const $ IDBDatabase.name db) varName

103+ _ <- launchAff $ modifyAVar (const $ oldVersion) varVersion

104+ pure unit

105+ varName <- AVar.new "-"

106+ varVersion <- AVar.new (-1)

107+ db <- IDBFactory.open name Nothing

108+ { onUpgradeNeeded: Just (callback (Tuple varName varVersion))

109+ , onBlocked: Nothing

110+ }

111+ name' <- AVar.read varName

112+ version' <- AVar.read varVersion

113+ name' `shouldEqual` name

114+ version' `shouldEqual` 0

115+ tearDown name version db

116+

117+ it "open + onBlocked" do

118+ let

119+ name = "db-blocked"

120+ version = 14

121+ callback var = do

122+ _ <- launchAff $ modifyAVar (const $ "db-blocked") var

123+ pure unit

124

81− it "open specific version -> close -> open latest" do

125+ var <- AVar.new "-"

82− let

83− name = "db-latest"

84− version = 14

85− db01 <- IDBFactory.open name (Just version)

126+ db01 <- IDBFactory.open name Nothing

86− { onUpgradeNeeded: Nothing

127+ { onUpgradeNeeded: Nothing

87− , onBlocked: Nothing

128+ , onBlocked: Nothing

88− }

129+ }

89− IDBDatabase.name db01 `shouldEqual` name

130+ _ <- forkAff do

131+ delay (Milliseconds 100.0)

90 IDBDatabase.close db01

132 IDBDatabase.close db01

91− db02 <- IDBFactory.open name Nothing

92− { onUpgradeNeeded: Nothing

93− , onBlocked: Nothing

94− }

95− tearDown name version db02

96−

97− it "open + onUpgradeNeed" do

98− let

99− name = "db-upgrade-needed"

100− version = 1

101− callback (Tuple varName varVersion) db _ { oldVersion } = do

102− _ <- launchAff $ modifyAVar (const $ IDBDatabase.name db) varName

103− _ <- launchAff $ modifyAVar (const $ oldVersion) varVersion

104− pure unit

105− varName <- AVar.new "-"

106− varVersion <- AVar.new (-1)

107− db <- IDBFactory.open name Nothing

108− { onUpgradeNeeded: Just (callback (Tuple varName varVersion))

109− , onBlocked: Nothing

110− }

111− name' <- AVar.read varName

112− version' <- AVar.read varVersion

113− name' `shouldEqual` name

114− version' `shouldEqual` 0

115− tearDown name version db

116

133

117− it "open + onBlocked" do

134+ db02 <- IDBFactory.open name (Just version)

118− let

135+ { onUpgradeNeeded: Nothing

119− name = "db-blocked"

120− version = 14

121− callback var = do

136+ , onBlocked: Just (callback var)

122− _ <- launchAff $ modifyAVar (const $ "db-blocked") var

137+ }

123− pure unit

138+ name' <- AVar.read var

139+ name' `shouldEqual` name

140+ tearDown name version db02

124

141

125− var <- AVar.new "-"

142+ describe "IDBKeyRange" do

126− db01 <- IDBFactory.open name Nothing

127− { onUpgradeNeeded: Nothing

128− , onBlocked: Nothing

129− }

130− _ <- forkAff do

131− delay (Milliseconds 100.0)

132− IDBDatabase.close db01

133−

134− db02 <- IDBFactory.open name (Just version)

135− { onUpgradeNeeded: Nothing

136− , onBlocked: Just (callback var)

137− }

138− name' <- AVar.read var

139− name' `shouldEqual` name

140− tearDown name version db02

141−

142− describe "IDBKeyRange" do

143− it "only(int)" do

143+ it "only(int)" do

144− let

144+ let

145− key = 14

145+ key = 14

146− range = IDBKeyRange.only key

147− IDBKeyRange.includes range (toKey key) `shouldEqual` true

148−

149− it "only(string)" do

150− let

151− key = "patate"

152− range = IDBKeyRange.only key

146+ range = IDBKeyRange.only key

153− IDBKeyRange.includes range (toKey key) `shouldEqual` true

147+ IDBKeyRange.includes range (toKey key) `shouldEqual` true

154

148

155− it "only(float)" do

149+ it "only(string)" do

156− let

150+ let

157− key = 14.42

151+ key = "patate"

158− range = IDBKeyRange.only key

152+ range = IDBKeyRange.only key

159− IDBKeyRange.includes range (toKey key) `shouldEqual` true

153+ IDBKeyRange.includes range (toKey key) `shouldEqual` true

160

154

161− it "only(date)" do

155+ it "only(float)" do

162− let

156+ let

163− mkey = DateTime

164− <$> (Date.canonicalDate <$> toEnum 2017 <*> toEnum 6 <*> toEnum 23)

165− <*> (Time <$> toEnum 17 <*> toEnum 59 <*> toEnum 34 <*> toEnum 42)

166−

167− case mkey of

168− Nothing ->

169− fail "unable to create datetime"

170− Just key -> do

171− let range = IDBKeyRange.only key

172− IDBKeyRange.includes range (toKey key) `shouldEqual` true

173−

174− it "only([int])" do

175− let

176− key = [ 14, 42 ]

157+ key = 14.42

177− range = IDBKeyRange.only key

158+ range = IDBKeyRange.only key

178− IDBKeyRange.includes range (toKey key) `shouldEqual` true

159+ IDBKeyRange.includes range (toKey key) `shouldEqual` true

179

160

161+ it "only(date)" do

162+ let

163+ mkey = DateTime

164+ <$> (Date.canonicalDate <$> toEnum 2017 <*> toEnum 6 <*> toEnum 23)

165+ <*> (Time <$> toEnum 17 <*> toEnum 59 <*> toEnum 34 <*> toEnum 42)

166+

167+ case mkey of

168+ Nothing ->

169+ fail "unable to create datetime"

170+ Just key -> do

171+ let range = IDBKeyRange.only key

172+ IDBKeyRange.includes range (toKey key) `shouldEqual` true

173+

180− it "only([string])" do

174+ it "only([int])" do

181− let

175+ let

182− key = [ "patate", "autruche" ]

176+ key = [ 14, 42 ]

183− range = IDBKeyRange.only key

177+ range = IDBKeyRange.only key

184− IDBKeyRange.includes range (toKey key) `shouldEqual` true

178+ IDBKeyRange.includes range (toKey key) `shouldEqual` true

185

179

186− it "lowerBound(14, open)" do

180+ it "only([string])" do

187− let

188− key = 14

189− open = true

190− range = IDBKeyRange.lowerBound key open

191− IDBKeyRange.includes range (toKey (key + 1)) `shouldEqual` true

192− IDBKeyRange.includes range (toKey key) `shouldEqual` (not open)

193− IDBKeyRange.includes range (toKey (key - 1)) `shouldEqual` false

194−

195− it "lowerBound(14, close)" do

196− let

197− key = 14

198− open = false

199− range = IDBKeyRange.lowerBound key open

200− IDBKeyRange.includes range (toKey (key + 1)) `shouldEqual` true

201− IDBKeyRange.includes range (toKey key) `shouldEqual` (not open)

202− IDBKeyRange.includes range (toKey (key - 1)) `shouldEqual` false

203−

204− it "upperBound(14, open)" do

205− let

206− key = 14

207− open = true

208− range = IDBKeyRange.upperBound key open

209− IDBKeyRange.includes range (toKey (key + 1)) `shouldEqual` false

210− IDBKeyRange.includes range (toKey key) `shouldEqual` (not open)

211− IDBKeyRange.includes range (toKey (key - 1)) `shouldEqual` true

212−

213− it "upperBound(14, close)" do

214− let

215− key = 14

216− open = false

217− range = IDBKeyRange.upperBound key open

218− IDBKeyRange.includes range (toKey (key + 1)) `shouldEqual` false

219− IDBKeyRange.includes range (toKey key) `shouldEqual` (not open)

220− IDBKeyRange.includes range (toKey (key - 1)) `shouldEqual` true

221−

222− it "bound(42, 14, open, open) => Nothing" do

223− let

224− lower = 42

225− upper = 14

226− lowerOpen = true

227− upperOpen = true

228− mrange = IDBKeyRange.bound { lower, upper, lowerOpen, upperOpen }

229− isNothing mrange `shouldEqual` true

230−

231− it "bound(14, 42, open, open)" do

232− let

233− lower = 14

234− upper = 42

235− lowerOpen = true

236− upperOpen = true

237− mrange = IDBKeyRange.bound { lower, upper, lowerOpen, upperOpen }

238− case mrange of

239− Nothing ->

240− fail "invalid range provided"

241− Just range -> do

242− IDBKeyRange.includes range (toKey (lower + 1)) `shouldEqual` true

243− IDBKeyRange.includes range (toKey (upper - 1)) `shouldEqual` true

244− IDBKeyRange.includes range (toKey (lower - 1)) `shouldEqual` false

245− IDBKeyRange.includes range (toKey (upper + 1)) `shouldEqual` false

246− IDBKeyRange.includes range (toKey lower) `shouldEqual` (not lowerOpen)

247− IDBKeyRange.includes range (toKey upper) `shouldEqual` (not upperOpen)

248−

249− it "bound(14, 42, open, close)" do

250− let

251− lower = 14

252− upper = 42

253− lowerOpen = true

254− upperOpen = false

255− mrange = IDBKeyRange.bound { lower, upper, lowerOpen, upperOpen }

256− case mrange of

257− Nothing ->

258− fail "invalid range provided"

259− Just range -> do

260− IDBKeyRange.includes range (toKey (lower + 1)) `shouldEqual` true

261− IDBKeyRange.includes range (toKey (upper - 1)) `shouldEqual` true

262− IDBKeyRange.includes range (toKey (lower - 1)) `shouldEqual` false

263− IDBKeyRange.includes range (toKey (upper + 1)) `shouldEqual` false

264− IDBKeyRange.includes range (toKey lower) `shouldEqual` (not lowerOpen)

265− IDBKeyRange.includes range (toKey upper) `shouldEqual` (not upperOpen)

266−

267− it "bound(14, 42, close, open)" do

268− let

269− lower = 14

270− upper = 42

271− lowerOpen = false

272− upperOpen = true

273− mrange = IDBKeyRange.bound { lower, upper, lowerOpen, upperOpen }

274− case mrange of

275− Nothing ->

276− fail "invalid range provided"

277− Just range -> do

278− IDBKeyRange.includes range (toKey (lower + 1)) `shouldEqual` true

279− IDBKeyRange.includes range (toKey (upper - 1)) `shouldEqual` true

280− IDBKeyRange.includes range (toKey (lower - 1)) `shouldEqual` false

281− IDBKeyRange.includes range (toKey (upper + 1)) `shouldEqual` false

282− IDBKeyRange.includes range (toKey lower) `shouldEqual` (not lowerOpen)

283− IDBKeyRange.includes range (toKey upper) `shouldEqual` (not upperOpen)

284−

285− it "bound(14, 42, close, close)" do

286− let

287− lower = 14

288− upper = 42

289− lowerOpen = false

290− upperOpen = false

291− mrange = IDBKeyRange.bound { lower, upper, lowerOpen, upperOpen }

292− case mrange of

293− Nothing ->

294− fail "invalid range provided"

295− Just range -> do

296− IDBKeyRange.includes range (toKey (lower + 1)) `shouldEqual` true

297− IDBKeyRange.includes range (toKey (upper - 1)) `shouldEqual` true

298− IDBKeyRange.includes range (toKey (lower - 1)) `shouldEqual` false

299− IDBKeyRange.includes range (toKey (upper + 1)) `shouldEqual` false

300− IDBKeyRange.includes range (toKey lower) `shouldEqual` (not lowerOpen)

301− IDBKeyRange.includes range (toKey upper) `shouldEqual` (not upperOpen)

302−

303− it "can access attributes of a range" do

304− let range = IDBKeyRange.lowerBound 14 false

305− IDBKeyRange.lower range `shouldEqual` (Just $ toKey 14)

306− IDBKeyRange.upper range `shouldEqual` none

307− IDBKeyRange.lowerOpen range `shouldEqual` false

308− IDBKeyRange.upperOpen range `shouldEqual` true

309−

310− describe "IDBDatabase" do

311 let

181 let

312− tearDown db = do

182+ key = [ "patate", "autruche" ]

313− IDBDatabase.close db

183+ range = IDBKeyRange.only key

314− _ <- IDBFactory.deleteDatabase (IDBDatabase.name db)

184+ IDBKeyRange.includes range (toKey key) `shouldEqual` true

315− pure unit

316

185

317− setup storeParams = do

186+ it "lowerBound(14, open)" do

318− let

187+ let

319− onUpgradeNeeded var db _ _ = launchAff' do

188+ key = 14

320− store <- IDBDatabase.createObjectStore db "store" storeParams

189+ open = true

321− _ <- AVar.put { db, store } var

190+ range = IDBKeyRange.lowerBound key open

191+ IDBKeyRange.includes range (toKey (key + 1)) `shouldEqual` true

192+ IDBKeyRange.includes range (toKey key) `shouldEqual` (not open)

193+ IDBKeyRange.includes range (toKey (key - 1)) `shouldEqual` false

194+

195+ it "lowerBound(14, close)" do

196+ let

197+ key = 14

198+ open = false

199+ range = IDBKeyRange.lowerBound key open

200+ IDBKeyRange.includes range (toKey (key + 1)) `shouldEqual` true

201+ IDBKeyRange.includes range (toKey key) `shouldEqual` (not open)

202+ IDBKeyRange.includes range (toKey (key - 1)) `shouldEqual` false

203+

204+ it "upperBound(14, open)" do

205+ let

206+ key = 14

207+ open = true

208+ range = IDBKeyRange.upperBound key open

209+ IDBKeyRange.includes range (toKey (key + 1)) `shouldEqual` false

210+ IDBKeyRange.includes range (toKey key) `shouldEqual` (not open)

211+ IDBKeyRange.includes range (toKey (key - 1)) `shouldEqual` true

212+

213+ it "upperBound(14, close)" do

214+ let

215+ key = 14

216+ open = false

217+ range = IDBKeyRange.upperBound key open

218+ IDBKeyRange.includes range (toKey (key + 1)) `shouldEqual` false

219+ IDBKeyRange.includes range (toKey key) `shouldEqual` (not open)

220+ IDBKeyRange.includes range (toKey (key - 1)) `shouldEqual` true

221+

222+ it "bound(42, 14, open, open) => Nothing" do

223+ let

224+ lower = 42

225+ upper = 14

226+ lowerOpen = true

227+ upperOpen = true

228+ mrange = IDBKeyRange.bound { lower, upper, lowerOpen, upperOpen }

229+ isNothing mrange `shouldEqual` true

230+

231+ it "bound(14, 42, open, open)" do

232+ let

233+ lower = 14

234+ upper = 42

235+ lowerOpen = true

236+ upperOpen = true

237+ mrange = IDBKeyRange.bound { lower, upper, lowerOpen, upperOpen }

238+ case mrange of

239+ Nothing ->

240+ fail "invalid range provided"

241+ Just range -> do

242+ IDBKeyRange.includes range (toKey (lower + 1)) `shouldEqual` true

243+ IDBKeyRange.includes range (toKey (upper - 1)) `shouldEqual` true

244+ IDBKeyRange.includes range (toKey (lower - 1)) `shouldEqual` false

245+ IDBKeyRange.includes range (toKey (upper + 1)) `shouldEqual` false

246+ IDBKeyRange.includes range (toKey lower) `shouldEqual` (not lowerOpen)

247+ IDBKeyRange.includes range (toKey upper) `shouldEqual` (not upperOpen)

248+

249+ it "bound(14, 42, open, close)" do

250+ let

251+ lower = 14

252+ upper = 42

253+ lowerOpen = true

254+ upperOpen = false

255+ mrange = IDBKeyRange.bound { lower, upper, lowerOpen, upperOpen }

256+ case mrange of

257+ Nothing ->

258+ fail "invalid range provided"

259+ Just range -> do

260+ IDBKeyRange.includes range (toKey (lower + 1)) `shouldEqual` true

261+ IDBKeyRange.includes range (toKey (upper - 1)) `shouldEqual` true

262+ IDBKeyRange.includes range (toKey (lower - 1)) `shouldEqual` false

263+ IDBKeyRange.includes range (toKey (upper + 1)) `shouldEqual` false

264+ IDBKeyRange.includes range (toKey lower) `shouldEqual` (not lowerOpen)

265+ IDBKeyRange.includes range (toKey upper) `shouldEqual` (not upperOpen)

266+

267+ it "bound(14, 42, close, open)" do

268+ let

269+ lower = 14

270+ upper = 42

271+ lowerOpen = false

272+ upperOpen = true

273+ mrange = IDBKeyRange.bound { lower, upper, lowerOpen, upperOpen }

274+ case mrange of

275+ Nothing ->

276+ fail "invalid range provided"

277+ Just range -> do

278+ IDBKeyRange.includes range (toKey (lower + 1)) `shouldEqual` true

279+ IDBKeyRange.includes range (toKey (upper - 1)) `shouldEqual` true

280+ IDBKeyRange.includes range (toKey (lower - 1)) `shouldEqual` false

281+ IDBKeyRange.includes range (toKey (upper + 1)) `shouldEqual` false

282+ IDBKeyRange.includes range (toKey lower) `shouldEqual` (not lowerOpen)

283+ IDBKeyRange.includes range (toKey upper) `shouldEqual` (not upperOpen)

284+

285+ it "bound(14, 42, close, close)" do

286+ let

287+ lower = 14

288+ upper = 42

289+ lowerOpen = false

290+ upperOpen = false

291+ mrange = IDBKeyRange.bound { lower, upper, lowerOpen, upperOpen }

292+ case mrange of

293+ Nothing ->

294+ fail "invalid range provided"

295+ Just range -> do

296+ IDBKeyRange.includes range (toKey (lower + 1)) `shouldEqual` true

297+ IDBKeyRange.includes range (toKey (upper - 1)) `shouldEqual` true

298+ IDBKeyRange.includes range (toKey (lower - 1)) `shouldEqual` false

299+ IDBKeyRange.includes range (toKey (upper + 1)) `shouldEqual` false

300+ IDBKeyRange.includes range (toKey lower) `shouldEqual` (not lowerOpen)

301+ IDBKeyRange.includes range (toKey upper) `shouldEqual` (not upperOpen)

302+

303+ it "can access attributes of a range" do

304+ let range = IDBKeyRange.lowerBound 14 false

305+ IDBKeyRange.lower range `shouldEqual` (Just $ toKey 14)

306+ IDBKeyRange.upper range `shouldEqual` none

307+ IDBKeyRange.lowerOpen range `shouldEqual` false

308+ IDBKeyRange.upperOpen range `shouldEqual` true

309+

310+ describe "IDBDatabase" do

311+ let

312+ tearDown db = do

313+ IDBDatabase.close db

314+ _ <- IDBFactory.deleteDatabase (IDBDatabase.name db)

322− pure unit

315+ pure unit

323−

324− var <- AVar.empty

325− _ <- IDBFactory.open "db" Nothing

326− { onUpgradeNeeded: Just (onUpgradeNeeded var)

327− , onBlocked: Nothing

328− }

329

316

330− AVar.take var

317+ setup storeParams = do

331−

332− it "createObjectStore (keyPath: [], autoIncrement: true)" do

333− { db, store } <- setup { keyPath: [], autoIncrement: true }

334− IDBObjectStore.name store `shouldEqual` "store"

335− IDBObjectStore.keyPath store `shouldEqual` []

336− IDBObjectStore.autoIncrement store `shouldEqual` true

337− IDBObjectStore.indexNames store `shouldEqual` []

338− tearDown db

339−

340− it "createObjectStore (keyPath: [\"patate\"], autoIncrement: true)" do

341− { db, store } <- setup { keyPath: [ "patate" ], autoIncrement: true }

342− IDBObjectStore.name store `shouldEqual` "store"

343− IDBObjectStore.keyPath store `shouldEqual` [ "patate" ]

344− IDBObjectStore.autoIncrement store `shouldEqual` true

345− IDBObjectStore.indexNames store `shouldEqual` []

346− tearDown db

347−

348− it "createObjectStore (keyPath: [\"a\", \"b\"], autoIncrement: false)" do

349− { db, store } <- setup { keyPath: [ "patate", "autruche" ], autoIncrement: false }

350− IDBObjectStore.name store `shouldEqual` "store"

351− IDBObjectStore.keyPath store `shouldEqual` [ "patate", "autruche" ]

352− IDBObjectStore.autoIncrement store `shouldEqual` false

353− IDBObjectStore.indexNames store `shouldEqual` []

354− tearDown db

355−

356− it "deleteObjectStore" do

357 let

318 let

358 onUpgradeNeeded var db _ _ = launchAff' do

319 onUpgradeNeeded var db _ _ = launchAff' do

359− _ <- IDBDatabase.deleteObjectStore db "store"

320+ store <- IDBDatabase.createObjectStore db "store" storeParams

360− AVar.put true var

321+ _ <- AVar.put { db, store } var

322+ pure unit

361

323

362 var <- AVar.empty

324 var <- AVar.empty

363− { db } <- setup IDBDatabase.defaultParameters

364− IDBDatabase.close db

365− db' <- IDBFactory.open "db" (Just 999)

325+ _ <- IDBFactory.open "db" Nothing

366 { onUpgradeNeeded: Just (onUpgradeNeeded var)

326 { onUpgradeNeeded: Just (onUpgradeNeeded var)

367 , onBlocked: Nothing

327 , onBlocked: Nothing

368 }

328 }

369− deleted <- AVar.take var

370− deleted `shouldEqual` true

371− tearDown db'

372

329

330+ AVar.take var

331+

332+ it "createObjectStore (keyPath: [], autoIncrement: true)" do

333+ { db, store } <- setup { keyPath: [], autoIncrement: true }

334+ IDBObjectStore.name store `shouldEqual` "store"

335+ IDBObjectStore.keyPath store `shouldEqual` []

336+ IDBObjectStore.autoIncrement store `shouldEqual` true

337+ IDBObjectStore.indexNames store `shouldEqual` []

338+ tearDown db

339+

340+ it "createObjectStore (keyPath: [\"patate\"], autoIncrement: true)" do

341+ { db, store } <- setup { keyPath: [ "patate" ], autoIncrement: true }

342+ IDBObjectStore.name store `shouldEqual` "store"

343+ IDBObjectStore.keyPath store `shouldEqual` [ "patate" ]

344+ IDBObjectStore.autoIncrement store `shouldEqual` true

345+ IDBObjectStore.indexNames store `shouldEqual` []

346+ tearDown db

347+

348+ it "createObjectStore (keyPath: [\"a\", \"b\"], autoIncrement: false)" do

349+ { db, store } <- setup { keyPath: [ "patate", "autruche" ], autoIncrement: false }

350+ IDBObjectStore.name store `shouldEqual` "store"

351+ IDBObjectStore.keyPath store `shouldEqual` [ "patate", "autruche" ]

352+ IDBObjectStore.autoIncrement store `shouldEqual` false

373− describe "IDBObjectStore" do

353+ IDBObjectStore.indexNames store `shouldEqual` []

354+ tearDown db

355+

356+ it "deleteObjectStore" do

374 let

357 let

375− tearDown db = do

376− IDBDatabase.close db

377− _ <- IDBFactory.deleteDatabase (IDBDatabase.name db)

378− pure unit

379−

380− setup { storeParams, onUpgradeNeeded } = do

381− let

382− onUpgradeNeeded' var db _ _ = launchAff' do

358+ onUpgradeNeeded var db _ _ = launchAff' do

383− store <- IDBDatabase.createObjectStore db "store" storeParams

359+ _ <- IDBDatabase.deleteObjectStore db "store"

384− liftEffect $ maybe (pure unit) identity (onUpgradeNeeded <*> pure db <*> pure store)

385− AVar.put { db, store } var

360+ AVar.put true var

386−

361+

387− var <- AVar.empty

362+ var <- AVar.empty

363+ { db } <- setup IDBDatabase.defaultParameters

364+ IDBDatabase.close db

388− _ <- IDBFactory.open "db" Nothing

365+ db' <- IDBFactory.open "db" (Just 999)

389− { onUpgradeNeeded: Just (onUpgradeNeeded' var)

366+ { onUpgradeNeeded: Just (onUpgradeNeeded var)

390− , onBlocked: Nothing

367+ , onBlocked: Nothing

391− }

368+ }

392−

393− AVar.take var

369+ deleted <- AVar.take var

394−

370+ deleted `shouldEqual` true

395− it "add()" do

371+ tearDown db'

396− date <- liftEffect $ toDateTime <$> now

372+

397− { db } <- setup

398− { storeParams: { autoIncrement: true, keyPath: [] }

399− , onUpgradeNeeded: Just $ \_ store -> launchAff' do

400− -- no key

401− key <- IDBObjectStore.add store "patate" none

402− (toKey 1) `shouldEqual` key

403−

404− -- int key

405− key' <- IDBObjectStore.add store "patate" (Just 14)

373+ describe "IDBObjectStore" do

406− (toKey 14) `shouldEqual` key'

374+ let

407−

375+ tearDown db = do

408− -- number key

376+ IDBDatabase.close db

409− key'' <- IDBObjectStore.add store "patate" (Just 14.42)

377+ _ <- IDBFactory.deleteDatabase (IDBDatabase.name db)

410− (toKey 14.42) `shouldEqual` key''

378+ pure unit

411−

412− -- string key

413− key''' <- IDBObjectStore.add store "patate" (Just "key")

414− (toKey "key") `shouldEqual` key'''

415

379

416− -- date key

380+ setup { storeParams, onUpgradeNeeded } = do

417− key'''' <- IDBObjectStore.add store "patate" (Just date)

381+ let

418− (toKey date) `shouldEqual` key''''

382+ onUpgradeNeeded' var db _ _ = launchAff' do

383+ store <- IDBDatabase.createObjectStore db "store" storeParams

384+ liftEffect $ maybe (pure unit) identity (onUpgradeNeeded <*> pure db <*> pure store)

385+ AVar.put { db, store } var

419

386

420− -- array key

387+ var <- AVar.empty

421− key''''' <- IDBObjectStore.add store "patate" (Just $ toKey [ 14, 42 ])

388+ _ <- IDBFactory.open "db" Nothing

422− (toKey [ 14, 42 ]) `shouldEqual` key'''''

423− }

424− tearDown db

425−

426− it "clear()" do

427− { db } <- setup

428− { storeParams: IDBDatabase.defaultParameters

429− , onUpgradeNeeded: Just $ \_ store -> launchAff' do

430− key <- IDBObjectStore.add store "patate" (Just 14)

431− _ <- IDBObjectStore.clear store

432− val <- IDBObjectStore.get store (IDBKeyRange.only key)

433− val `shouldEqual` (Nothing :: Maybe String)

434− }

435− tearDown db

436−

437− it "count()" do

438− { db } <- setup

439− { storeParams: IDBDatabase.defaultParameters

440− , onUpgradeNeeded: Just $ \_ store -> launchAff' do

389+ { onUpgradeNeeded: Just (onUpgradeNeeded' var)

441− _ <- IDBObjectStore.add store "patate" (Just 14)

390+ , onBlocked: Nothing

442− _ <- IDBObjectStore.add store "autruche" (Just 42)

443− n <- IDBObjectStore.count store Nothing

444− n `shouldEqual` 2

445− }

446− tearDown db

447−

448− it "getKey()" do

449− { db } <- setup

450− { storeParams: IDBDatabase.defaultParameters

451− , onUpgradeNeeded: Just $ \_ store -> launchAff' do

452− key <- IDBObjectStore.add store "patate" (Just 14)

453− mkey <- IDBObjectStore.getKey store (IDBKeyRange.only 14)

454− mkey `shouldEqual` (Just key)

455−

456− mkey' <- IDBObjectStore.getKey store (IDBKeyRange.only 42)

457− mkey' `shouldEqual` none

458− }

459− tearDown db

460−

461− it "getAllKeys()" do

462− { db } <- setup

463− { storeParams: IDBDatabase.defaultParameters

464− , onUpgradeNeeded: Just $ \_ store -> launchAff' do

465− key1 <- IDBObjectStore.add store "patate" (Just 14)

466− key2 <- IDBObjectStore.add store "autruche" (Just 42)

467− key3 <- IDBObjectStore.add store 14 (Just 1337)

468−

469− -- no bounds

470− keys <- IDBObjectStore.getAllKeys store Nothing Nothing

471− keys `shouldEqual` [ key1, key2, key3 ]

472−

473− -- lower bound

474− keys' <- IDBObjectStore.getAllKeys store (Just $ IDBKeyRange.lowerBound 14 true) Nothing

475− keys' `shouldEqual` [ key2, key3 ]

476−

477− -- upper bound

478− keys'' <- IDBObjectStore.getAllKeys store (Just $ IDBKeyRange.upperBound 42 false) Nothing

479− keys'' `shouldEqual` [ key1, key2 ]

480−

481− -- count

482− keys''' <- IDBObjectStore.getAllKeys store (Just $ IDBKeyRange.lowerBound 1 true) (Just 2)

483− keys''' `shouldEqual` [ key1, key2 ]

484 }

391 }

485− tearDown db

486

392

487− it "openCursor()" do

393+ AVar.take var

394+

395+ it "add()" do

396+ date <- liftEffect $ toDateTime <$> now

397+ { db } <- setup

398+ { storeParams: { autoIncrement: true, keyPath: [] }

399+ , onUpgradeNeeded: Just $ \_ store -> launchAff' do

400+ -- no key

401+ key <- IDBObjectStore.add store "patate" none

402+ (toKey 1) `shouldEqual` key

403+

404+ -- int key

405+ key' <- IDBObjectStore.add store "patate" (Just 14)

406+ (toKey 14) `shouldEqual` key'

407+

408+ -- number key

409+ key'' <- IDBObjectStore.add store "patate" (Just 14.42)

410+ (toKey 14.42) `shouldEqual` key''

411+

412+ -- string key

413+ key''' <- IDBObjectStore.add store "patate" (Just "key")

414+ (toKey "key") `shouldEqual` key'''

415+

416+ -- date key

417+ key'''' <- IDBObjectStore.add store "patate" (Just date)

418+ (toKey date) `shouldEqual` key''''

419+

420+ -- array key

421+ key''''' <- IDBObjectStore.add store "patate" (Just $ toKey [ 14, 42 ])

422+ (toKey [ 14, 42 ]) `shouldEqual` key'''''

423+ }

424+ tearDown db

425+

426+ it "clear()" do

427+ { db } <- setup

428+ { storeParams: IDBDatabase.defaultParameters

429+ , onUpgradeNeeded: Just $ \_ store -> launchAff' do

430+ key <- IDBObjectStore.add store "patate" (Just 14)

431+ _ <- IDBObjectStore.clear store

432+ val <- IDBObjectStore.get store (IDBKeyRange.only key)

433+ val `shouldEqual` (Nothing :: Maybe String)

434+ }

435+ tearDown db

436+

437+ it "count()" do

438+ { db } <- setup

439+ { storeParams: IDBDatabase.defaultParameters

440+ , onUpgradeNeeded: Just $ \_ store -> launchAff' do

441+ _ <- IDBObjectStore.add store "patate" (Just 14)

442+ _ <- IDBObjectStore.add store "autruche" (Just 42)

443+ n <- IDBObjectStore.count store Nothing

444+ n `shouldEqual` 2

445+ }

446+ tearDown db

447+

448+ it "getKey()" do

449+ { db } <- setup

450+ { storeParams: IDBDatabase.defaultParameters

451+ , onUpgradeNeeded: Just $ \_ store -> launchAff' do

452+ key <- IDBObjectStore.add store "patate" (Just 14)

453+ mkey <- IDBObjectStore.getKey store (IDBKeyRange.only 14)

454+ mkey `shouldEqual` (Just key)

455+

456+ mkey' <- IDBObjectStore.getKey store (IDBKeyRange.only 42)

457+ mkey' `shouldEqual` none

458+ }

459+ tearDown db

460+

461+ it "getAllKeys()" do

462+ { db } <- setup

463+ { storeParams: IDBDatabase.defaultParameters

464+ , onUpgradeNeeded: Just $ \_ store -> launchAff' do

465+ key1 <- IDBObjectStore.add store "patate" (Just 14)

466+ key2 <- IDBObjectStore.add store "autruche" (Just 42)

467+ key3 <- IDBObjectStore.add store 14 (Just 1337)

468+

469+ -- no bounds

470+ keys <- IDBObjectStore.getAllKeys store Nothing Nothing

471+ keys `shouldEqual` [ key1, key2, key3 ]

472+

473+ -- lower bound

474+ keys' <- IDBObjectStore.getAllKeys store (Just $ IDBKeyRange.lowerBound 14 true) Nothing

475+ keys' `shouldEqual` [ key2, key3 ]

476+

477+ -- upper bound

478+ keys'' <- IDBObjectStore.getAllKeys store (Just $ IDBKeyRange.upperBound 42 false) Nothing

479+ keys'' `shouldEqual` [ key1, key2 ]

480+

481+ -- count

482+ keys''' <- IDBObjectStore.getAllKeys store (Just $ IDBKeyRange.lowerBound 1 true) (Just 2)

483+ keys''' `shouldEqual` [ key1, key2 ]

484+ }

485+ tearDown db

486+

487+ it "openCursor()" do

488− let

488+ let

489− cb =

489+ cb =

490− { onSuccess: const $ pure unit

490+ { onSuccess: const $ pure unit

491− , onError: show >>> fail >>> launchAff'

491+ , onError: show >>> fail >>> launchAff'

492− , onComplete: pure unit

492+ , onComplete: pure unit

493− }

494− { db } <- setup

495− { storeParams: IDBDatabase.defaultParameters

496− , onUpgradeNeeded: Just $ \_ store -> launchAff' do

497− _ <- IDBObjectStore.openCursor store Nothing Next cb

498− _ <- IDBObjectStore.openCursor store Nothing NextUnique cb

499− _ <- IDBObjectStore.openCursor store Nothing Prev cb

500− _ <- IDBObjectStore.openCursor store Nothing PrevUnique cb

501− _ <- IDBObjectStore.openCursor store (Just $ IDBKeyRange.upperBound 1 true) Next cb

502− pure unit

503 }

493 }

494+ { db } <- setup

495+ { storeParams: IDBDatabase.defaultParameters

496+ , onUpgradeNeeded: Just $ \_ store -> launchAff' do

497+ _ <- IDBObjectStore.openCursor store Nothing Next cb

498+ _ <- IDBObjectStore.openCursor store Nothing NextUnique cb

499+ _ <- IDBObjectStore.openCursor store Nothing Prev cb

500+ _ <- IDBObjectStore.openCursor store Nothing PrevUnique cb

501+ _ <- IDBObjectStore.openCursor store (Just $ IDBKeyRange.upperBound 1 true) Next cb

502+ pure unit

503+ }

504− tearDown db

504+ tearDown db

505

506− it "openKeyCursor()" do

506+ it "openKeyCursor()" do

507− let

507+ let

508− cb =

508+ cb =

509− { onSuccess: const $ pure unit

509+ { onSuccess: const $ pure unit

510− , onError: show >>> fail >>> launchAff'

510+ , onError: show >>> fail >>> launchAff'

511− , onComplete: pure unit

511+ , onComplete: pure unit

512− }

513− { db } <- setup

514− { storeParams: IDBDatabase.defaultParameters

515− , onUpgradeNeeded: Just $ \_ store -> launchAff' do

516− _ <- IDBObjectStore.openKeyCursor store Nothing Next cb

517− _ <- IDBObjectStore.openKeyCursor store Nothing NextUnique cb

518− _ <- IDBObjectStore.openKeyCursor store Nothing Prev cb

519− _ <- IDBObjectStore.openKeyCursor store Nothing PrevUnique cb

520− _ <- IDBObjectStore.openKeyCursor store (Just $ IDBKeyRange.lowerBound 1 true) Next cb

521− pure unit

522 }

512 }

513+ { db } <- setup

514+ { storeParams: IDBDatabase.defaultParameters

515+ , onUpgradeNeeded: Just $ \_ store -> launchAff' do

516+ _ <- IDBObjectStore.openKeyCursor store Nothing Next cb

517+ _ <- IDBObjectStore.openKeyCursor store Nothing NextUnique cb

518+ _ <- IDBObjectStore.openKeyCursor store Nothing Prev cb

519+ _ <- IDBObjectStore.openKeyCursor store Nothing PrevUnique cb

520+ _ <- IDBObjectStore.openKeyCursor store (Just $ IDBKeyRange.lowerBound 1 true) Next cb

521+ pure unit

522+ }

523− tearDown db

523+ tearDown db

524

525− describe "IDBIndex" do

525+ describe "IDBIndex" do

526− let

526+ let

527− tearDown db = do

527+ tearDown db = do

528− IDBDatabase.close db

528+ IDBDatabase.close db

529− _ <- IDBFactory.deleteDatabase (IDBDatabase.name db)

529+ _ <- IDBFactory.deleteDatabase (IDBDatabase.name db)

530− pure unit

530+ pure unit

531+

532+ setup

533+ :: forall value

534+ . { storeParams :: { keyPath :: Array String, autoIncrement :: Boolean }

535+ , indexParams :: { unique :: Boolean, multiEntry :: Boolean }

536+ , values :: Array (Tuple value (Maybe Key))

537+ , keyPath :: Array String

538+ , onUpgradeNeeded :: Maybe (Database -> Transaction -> Index -> Effect Unit)

539+ }

540+ -> Aff { db :: Database, index :: Index, store :: ObjectStore }

541+ setup { storeParams, indexParams, values, keyPath, onUpgradeNeeded } = do

542+ let

543+ onUpgradeNeeded' var db tx _ = launchAff' do

544+ store <- IDBDatabase.createObjectStore db "store" storeParams

545+ _ <- traverse (uncurry (IDBObjectStore.add store)) values

546+ index <- IDBObjectStore.createIndex store "index" keyPath indexParams

547+ liftEffect $ maybe (pure unit) identity (onUpgradeNeeded <*> pure db <*> pure tx <*> pure index)

548+ AVar.put { db, index, store } var

531

549

532− setup

533− :: forall value

534− . { storeParams :: { keyPath :: Array String, autoIncrement :: Boolean }

535− , indexParams :: { unique :: Boolean, multiEntry :: Boolean }

536− , values :: Array (Tuple value (Maybe Key))

537− , keyPath :: Array String

538− , onUpgradeNeeded :: Maybe (Database -> Transaction -> Index -> Effect Unit)

539− }

540− -> Aff { db :: Database, index :: Index, store :: ObjectStore }

541− setup { storeParams, indexParams, values, keyPath, onUpgradeNeeded } = do

542− let

543− onUpgradeNeeded' var db tx _ = launchAff' do

544− store <- IDBDatabase.createObjectStore db "store" storeParams

545− _ <- traverse (uncurry (IDBObjectStore.add store)) values

546− index <- IDBObjectStore.createIndex store "index" keyPath indexParams

547− liftEffect $ maybe (pure unit) identity (onUpgradeNeeded <*> pure db <*> pure tx <*> pure index)

548− AVar.put { db, index, store } var

549−

550− var <- AVar.empty

550+ var <- AVar.empty

551− _ <- IDBFactory.open "db" Nothing

551+ _ <- IDBFactory.open "db" Nothing

552− { onUpgradeNeeded: Just (onUpgradeNeeded' var)

552+ { onUpgradeNeeded: Just (onUpgradeNeeded' var)

553− , onBlocked: Nothing

553+ , onBlocked: Nothing

554− }

555− AVar.take var

556−

557− it "returns an IDBIndex and the properties are set correctly" do

558− { db, index } <- setup

559− { storeParams: IDBDatabase.defaultParameters

560− , indexParams: IDBObjectStore.defaultParameters

561− , onUpgradeNeeded: Nothing

562− , keyPath: []

563− , values: []

564− }

565− IDBIndex.name index `shouldEqual` "index"

566− IDBIndex.keyPath index `shouldEqual` []

567− IDBIndex.unique index `shouldEqual` IDBObjectStore.defaultParameters.unique

568− IDBIndex.multiEntry index `shouldEqual` IDBObjectStore.defaultParameters.multiEntry

569− tearDown db

570−

571− it "attempt to create an index that requires unique values on an object store already contains duplicates" do

572− let onAbort var = launchAff' (AVar.put true var)

573− txVar <- AVar.empty

574− dbVar <- AVar.empty

575− res <- attempt $ setup

576− { storeParams: IDBDatabase.defaultParameters

577− , indexParams:

578− { unique: true

579− , multiEntry: false

580− }

581− , keyPath: [ "indexedProperty" ]

582− , values:

583− [ { indexedProperty: "bar" } :+: (Just $ toKey 1)

584− , { indexedProperty: "bar" } :+: (Just $ toKey 2)

585− ]

586− , onUpgradeNeeded: Just $ \db tx _ -> launchAff' do

587− IDBTransaction.onAbort tx (onAbort txVar)

588− IDBDatabase.onAbort db (onAbort dbVar)

589− }

590− case res of

591− Right _ ->

592− fail "expected abort"

593− _ -> do

594− shouldEqual true =<< AVar.take txVar

595− shouldEqual true =<< AVar.take dbVar

596−

597− it "the index is usable right after being made" do

598− { db } <- setup

599− { storeParams:

600− { keyPath: [ "key" ]

601− , autoIncrement: false

602− }

603− , indexParams: IDBObjectStore.defaultParameters

604− , keyPath: [ "indexedProperty" ]

605− , values:

606− [ { key: "key1", indexedProperty: "indexed_1" } :+: Nothing

607− , { key: "key2", indexedProperty: "indexed_2" } :+: Nothing

608− , { key: "key3", indexedProperty: "indexed_3" } :+: Nothing

609− ]

610− , onUpgradeNeeded: Just $ \_ _ index -> launchAff' do

611− val <- IDBIndex.get index (IDBKeyRange.only "indexed_2")

612− ((\r -> r.key) <$> val) `shouldEqual` (Just $ toKey "key2")

613− }

614− tearDown db

615−

616− it "empty keyPath" do

617− { db } <- setup

618− { storeParams: IDBDatabase.defaultParameters

619− , indexParams: IDBObjectStore.defaultParameters

620− , keyPath: []

621− , values:

622− [ "object_1" :+: (Just $ toKey 1)

623− , "object_2" :+: (Just $ toKey 2)

624− , "object_3" :+: (Just $ toKey 3)

625− ]

626− , onUpgradeNeeded: Just $ \_ _ index -> launchAff' do

627− val <- IDBIndex.get index (IDBKeyRange.only "object_3")

628− val `shouldEqual` (Just "object_3")

629− }

630− tearDown db

631−

632− it "index can be valid keys [date]" do

633− date <- liftEffect $ toDateTime <$> now

634− { db } <- setup

635− { storeParams:

636− { keyPath: [ "key" ]

637− , autoIncrement: false

638− }

639− , indexParams: IDBObjectStore.defaultParameters

640− , keyPath: [ "i" ]

641− , values:

642− [ { key: "date", i: (toKey date) } :+: Nothing

643− ]

644− , onUpgradeNeeded: Just $ \_ _ index -> launchAff' do

645− val <- IDBIndex.get index (IDBKeyRange.only date)

646− ((\r -> r.key) <$> val) `shouldEqual` (Just "date")

647− }

648− tearDown db

649−

650− it "index can be valid keys [num]" do

651− let num = 14

652− { db } <- setup

653− { storeParams:

654− { keyPath: [ "key" ]

655− , autoIncrement: false

656− }

657− , indexParams: IDBObjectStore.defaultParameters

658− , keyPath: [ "i" ]

659− , values:

660− [ { key: "num", i: (toKey num) } :+: Nothing

661− ]

662− , onUpgradeNeeded: Just $ \_ _ index -> launchAff' do

663− val <- IDBIndex.get index (IDBKeyRange.only num)

664− ((\r -> r.key) <$> val) `shouldEqual` (Just "num")

665− }

666− tearDown db

667−

668− it "index can be valid keys [array]" do

669− let array = [ "patate", "autruche" ]

670− { db } <- setup

671− { storeParams:

672− { keyPath: [ "key" ]

673− , autoIncrement: false

674− }

675− , indexParams: IDBObjectStore.defaultParameters

676− , keyPath: [ "i" ]

677− , values:

678− [ { key: "array", i: (toKey array) } :+: Nothing

679− ]

680− , onUpgradeNeeded: Just $ \_ _ index -> launchAff' do

681− val <- IDBIndex.get index (IDBKeyRange.only array)

682− ((\r -> r.key) <$> val) `shouldEqual` (Just "array")

683− }

684− tearDown db

685−

686− it "openKeyCursor() - throw InvalidStateError on index deleted by aborted upgrade" do

687− res <- attempt $ setup

688− { storeParams: { keyPath: [ "key" ], autoIncrement: false }

689− , indexParams: IDBObjectStore.defaultParameters

690− , keyPath: [ "indexedProperty" ]

691− , values:

692− [ { key: 14, indexedProperty: "patate" } :+: Nothing

693− ]

694− , onUpgradeNeeded: Just $ \db tx index -> launchAff' do

695− let

696− cb =

697− { onSuccess: const $ pure unit

698− , onError: show >>> fail >>> launchAff'

699− , onComplete: pure unit

700− }

701− IDBTransaction.onAbort tx (pure unit)

702− IDBDatabase.onAbort db (pure unit)

703− IDBTransaction.abort tx

704− cursor <- attempt $ IDBIndex.openKeyCursor index Nothing Next cb

705− case cursor of

706− Right _ -> fail "expected InvalidStateError"

707− Left err -> name err `shouldEqual` "InvalidStateError"

708− }

709− case res of

710− Right _ -> fail "expected InvalidStateError"

711− _ -> pure unit

712−

713− it "openKeyCursor() - throw TransactionInactiveError on aborted transaction" do

714− { db } <- setup

715− { storeParams: { keyPath: [ "key" ], autoIncrement: false }

716− , indexParams: IDBObjectStore.defaultParameters

717− , keyPath: [ "indexedProperty" ]

718− , values:

719− [ { key: 14, indexedProperty: "patate" } :+: Nothing

720− ]

721− , onUpgradeNeeded: Nothing

722 }

554 }

723− let

555+ AVar.take var

724− cb =

556+

725− { onSuccess: const $ pure unit

557+ it "returns an IDBIndex and the properties are set correctly" do

726− , onError: show >>> fail >>> launchAff'

558+ { db, index } <- setup

727− , onComplete: pure unit

559+ { storeParams: IDBDatabase.defaultParameters

560+ , indexParams: IDBObjectStore.defaultParameters

561+ , onUpgradeNeeded: Nothing

562+ , keyPath: []

563+ , values: []

564+ }

565+ IDBIndex.name index `shouldEqual` "index"

566+ IDBIndex.keyPath index `shouldEqual` []

567+ IDBIndex.unique index `shouldEqual` IDBObjectStore.defaultParameters.unique

568+ IDBIndex.multiEntry index `shouldEqual` IDBObjectStore.defaultParameters.multiEntry

569+ tearDown db

570+

571+ it "attempt to create an index that requires unique values on an object store already contains duplicates" do

572+ let onAbort var = launchAff' (AVar.put true var)

573+ txVar <- AVar.empty

574+ dbVar <- AVar.empty

575+ res <- attempt $ setup

576+ { storeParams: IDBDatabase.defaultParameters

577+ , indexParams:

578+ { unique: true

579+ , multiEntry: false

728 }

580 }

729− tx <- IDBDatabase.transaction db [ "store" ] ReadOnly

581+ , keyPath: [ "indexedProperty" ]

730− store <- IDBTransaction.objectStore tx "store"

582+ , values:

731− index <- IDBObjectStore.index store "index"

583+ [ { indexedProperty: "bar" } :+: (Just $ toKey 1)

732− IDBTransaction.onAbort tx (pure unit)

584+ , { indexedProperty: "bar" } :+: (Just $ toKey 2)

733− IDBTransaction.abort tx

585+ ]

734− cursor <- attempt $ IDBIndex.openKeyCursor index Nothing Next cb

586+ , onUpgradeNeeded: Just $ \db tx _ -> launchAff' do

587+ IDBTransaction.onAbort tx (onAbort txVar)

588+ IDBDatabase.onAbort db (onAbort dbVar)

589+ }

735− case cursor of

590+ case res of

591+ Right _ ->

736− Right _ -> fail "expected TransactionInactiveError"

592+ fail "expected abort"

737− Left err -> name err `shouldEqual` "TransactionInactiveError"

593+ _ -> do

738−

594+ shouldEqual true =<< AVar.take txVar

739− tearDown db

595+ shouldEqual true =<< AVar.take dbVar

740−

596+

741− it "openKeyCursor() - throw InvalidStateError when the index is deleted" do

597+ it "the index is usable right after being made" do

742− { db } <- setup

598+ { db } <- setup

599+ { storeParams:

600+ { keyPath: [ "key" ]

743− { storeParams: { keyPath: [ "key" ], autoIncrement: false }

601+ , autoIncrement: false

602+ }

744− , indexParams: IDBObjectStore.defaultParameters

603+ , indexParams: IDBObjectStore.defaultParameters

745− , keyPath: [ "indexedProperty" ]

604+ , keyPath: [ "indexedProperty" ]

746− , values:

605+ , values:

747− [ { key: 14, indexedProperty: "patate" } :+: Nothing

606+ [ { key: "key1", indexedProperty: "indexed_1" } :+: Nothing

748− ]

607+ , { key: "key2", indexedProperty: "indexed_2" } :+: Nothing

749− , onUpgradeNeeded: Just $ \_ tx index -> launchAff' do

608+ , { key: "key3", indexedProperty: "indexed_3" } :+: Nothing

750− let

609+ ]

751− cb =

610+ , onUpgradeNeeded: Just $ \_ _ index -> launchAff' do

752− { onSuccess: const $ pure unit

611+ val <- IDBIndex.get index (IDBKeyRange.only "indexed_2")

753− , onError: show >>> fail >>> launchAff'

612+ ((\r -> r.key) <$> val) `shouldEqual` (Just $ toKey "key2")

754− , onComplete: pure unit

755− }

756− store <- IDBTransaction.objectStore tx "store"

757− IDBObjectStore.deleteIndex store "index"

758− cursor <- attempt $ IDBIndex.openKeyCursor index Nothing Next cb

759− case cursor of

760− Right _ -> fail "expected InvalidStateError"

761− Left err -> name err `shouldEqual` "InvalidStateError"

762− }

613+ }

763−

764− tearDown db

614+ tearDown db

765−

615+

616+ it "empty keyPath" do

617+ { db } <- setup

618+ { storeParams: IDBDatabase.defaultParameters

619+ , indexParams: IDBObjectStore.defaultParameters

620+ , keyPath: []

621+ , values:

622+ [ "object_1" :+: (Just $ toKey 1)

623+ , "object_2" :+: (Just $ toKey 2)

624+ , "object_3" :+: (Just $ toKey 3)

625+ ]

626+ , onUpgradeNeeded: Just $ \_ _ index -> launchAff' do

627+ val <- IDBIndex.get index (IDBKeyRange.only "object_3")

628+ val `shouldEqual` (Just "object_3")

629+ }

630+ tearDown db

631+

632+ it "index can be valid keys [date]" do

633+ date <- liftEffect $ toDateTime <$> now

634+ { db } <- setup

635+ { storeParams:

636+ { keyPath: [ "key" ]

637+ , autoIncrement: false

638+ }

639+ , indexParams: IDBObjectStore.defaultParameters

640+ , keyPath: [ "i" ]

641+ , values:

642+ [ { key: "date", i: (toKey date) } :+: Nothing

643+ ]

644+ , onUpgradeNeeded: Just $ \_ _ index -> launchAff' do

645+ val <- IDBIndex.get index (IDBKeyRange.only date)

646+ ((\r -> r.key) <$> val) `shouldEqual` (Just "date")

647+ }

648+ tearDown db

649+

650+ it "index can be valid keys [num]" do

651+ let num = 14

652+ { db } <- setup

653+ { storeParams:

654+ { keyPath: [ "key" ]

655+ , autoIncrement: false

656+ }

657+ , indexParams: IDBObjectStore.defaultParameters

658+ , keyPath: [ "i" ]

659+ , values:

660+ [ { key: "num", i: (toKey num) } :+: Nothing

661+ ]

662+ , onUpgradeNeeded: Just $ \_ _ index -> launchAff' do

663+ val <- IDBIndex.get index (IDBKeyRange.only num)

664+ ((\r -> r.key) <$> val) `shouldEqual` (Just "num")

665+ }

666+ tearDown db

667+

668+ it "index can be valid keys [array]" do

669+ let array = [ "patate", "autruche" ]

670+ { db } <- setup

671+ { storeParams:

672+ { keyPath: [ "key" ]

673+ , autoIncrement: false

674+ }

675+ , indexParams: IDBObjectStore.defaultParameters

676+ , keyPath: [ "i" ]

677+ , values:

678+ [ { key: "array", i: (toKey array) } :+: Nothing

679+ ]

680+ , onUpgradeNeeded: Just $ \_ _ index -> launchAff' do

681+ val <- IDBIndex.get index (IDBKeyRange.only array)

682+ ((\r -> r.key) <$> val) `shouldEqual` (Just "array")

683+ }

684+ tearDown db

685+

766− it "openCursor() - throw InvalidStateError on index deleted by aborted upgrade" do

686+ it "openKeyCursor() - throw InvalidStateError on index deleted by aborted upgrade" do

767− res <- attempt $ setup

687+ res <- attempt $ setup

768− { storeParams: { keyPath: [ "key" ], autoIncrement: false }

688+ { storeParams: { keyPath: [ "key" ], autoIncrement: false }

769− , indexParams: IDBObjectStore.defaultParameters

689+ , indexParams: IDBObjectStore.defaultParameters

770− , keyPath: [ "indexedProperty" ]

690+ , keyPath: [ "indexedProperty" ]

771− , values:

691+ , values:

772− [ { key: 14, indexedProperty: "patate" } :+: Nothing

692+ [ { key: 14, indexedProperty: "patate" } :+: Nothing

773− ]

693+ ]

774− , onUpgradeNeeded: Just $ \db tx index -> launchAff' do

694+ , onUpgradeNeeded: Just $ \db tx index -> launchAff' do

775− let

695+ let

776− cb =

696+ cb =

777− { onSuccess: const $ pure unit

697+ { onSuccess: const $ pure unit

778− , onError: show >>> fail >>> launchAff'

698+ , onError: show >>> fail >>> launchAff'

779− , onComplete: pure unit

699+ , onComplete: pure unit

780− }

700+ }

781− IDBTransaction.onAbort tx (pure unit)

701+ IDBTransaction.onAbort tx (pure unit)

782− IDBDatabase.onAbort db (pure unit)

702+ IDBDatabase.onAbort db (pure unit)

783− IDBTransaction.abort tx

703+ IDBTransaction.abort tx

784− cursor <- attempt $ IDBIndex.openCursor index Nothing Next cb

704+ cursor <- attempt $ IDBIndex.openKeyCursor index Nothing Next cb

785− case cursor of

705+ case cursor of

786− Right _ -> fail "expected InvalidStateError"

706+ Right _ -> fail "expected InvalidStateError"

787− Left err -> name err `shouldEqual` "InvalidStateError"

707+ Left err -> name err `shouldEqual` "InvalidStateError"

708+ }

709+ case res of

710+ Right _ -> fail "expected InvalidStateError"

711+ _ -> pure unit

712+

713+ it "openKeyCursor() - throw TransactionInactiveError on aborted transaction" do

714+ { db } <- setup

715+ { storeParams: { keyPath: [ "key" ], autoIncrement: false }

716+ , indexParams: IDBObjectStore.defaultParameters

717+ , keyPath: [ "indexedProperty" ]

718+ , values:

719+ [ { key: 14, indexedProperty: "patate" } :+: Nothing

720+ ]

721+ , onUpgradeNeeded: Nothing

722+ }

723+ let

724+ cb =

725+ { onSuccess: const $ pure unit

726+ , onError: show >>> fail >>> launchAff'

727+ , onComplete: pure unit

788 }

728 }

729+ tx <- IDBDatabase.transaction db [ "store" ] ReadOnly

730+ store <- IDBTransaction.objectStore tx "store"

731+ index <- IDBObjectStore.index store "index"

732+ IDBTransaction.onAbort tx (pure unit)

733+ IDBTransaction.abort tx

734+ cursor <- attempt $ IDBIndex.openKeyCursor index Nothing Next cb

735+ case cursor of

736+ Right _ -> fail "expected TransactionInactiveError"

737+ Left err -> name err `shouldEqual` "TransactionInactiveError"

738+

739+ tearDown db

740+

741+ it "openKeyCursor() - throw InvalidStateError when the index is deleted" do

742+ { db } <- setup

743+ { storeParams: { keyPath: [ "key" ], autoIncrement: false }

744+ , indexParams: IDBObjectStore.defaultParameters

745+ , keyPath: [ "indexedProperty" ]

746+ , values:

747+ [ { key: 14, indexedProperty: "patate" } :+: Nothing

748+ ]

749+ , onUpgradeNeeded: Just $ \_ tx index -> launchAff' do

750+ let

751+ cb =

752+ { onSuccess: const $ pure unit

753+ , onError: show >>> fail >>> launchAff'

754+ , onComplete: pure unit

755+ }

756+ store <- IDBTransaction.objectStore tx "store"

757+ IDBObjectStore.deleteIndex store "index"

758+ cursor <- attempt $ IDBIndex.openKeyCursor index Nothing Next cb

759+ case cursor of

760+ Right _ -> fail "expected InvalidStateError"

761+ Left err -> name err `shouldEqual` "InvalidStateError"

762+ }

763+

764+ tearDown db

765+

766+ it "openCursor() - throw InvalidStateError on index deleted by aborted upgrade" do

767+ res <- attempt $ setup

768+ { storeParams: { keyPath: [ "key" ], autoIncrement: false }

769+ , indexParams: IDBObjectStore.defaultParameters

770+ , keyPath: [ "indexedProperty" ]

771+ , values:

772+ [ { key: 14, indexedProperty: "patate" } :+: Nothing

773+ ]

774+ , onUpgradeNeeded: Just $ \db tx index -> launchAff' do

775+ let

776+ cb =

777+ { onSuccess: const $ pure unit

778+ , onError: show >>> fail >>> launchAff'

779+ , onComplete: pure unit

780+ }

781+ IDBTransaction.onAbort tx (pure unit)

782+ IDBDatabase.onAbort db (pure unit)

783+ IDBTransaction.abort tx

784+ cursor <- attempt $ IDBIndex.openCursor index Nothing Next cb

785+ case cursor of

786+ Right _ -> fail "expected InvalidStateError"

787+ Left err -> name err `shouldEqual` "InvalidStateError"

788+ }

789− case res of

789+ case res of

790− Right _ -> fail "expected InvalidStateError"

790+ Right _ -> fail "expected InvalidStateError"

791− _ -> pure unit

791+ _ -> pure unit

792−

792+

793− it "openCursor() - throw TransactionInactiveError on aborted transaction" do

793+ it "openCursor() - throw TransactionInactiveError on aborted transaction" do

794− { db } <- setup

794+ { db } <- setup

795− { storeParams: { keyPath: [ "key" ], autoIncrement: false }

795+ { storeParams: { keyPath: [ "key" ], autoIncrement: false }

796− , indexParams: IDBObjectStore.defaultParameters

796+ , indexParams: IDBObjectStore.defaultParameters

797− , keyPath: [ "indexedProperty" ]

797+ , keyPath: [ "indexedProperty" ]

798− , values:

798+ , values:

799− [ { key: 14, indexedProperty: "patate" } :+: Nothing

799+ [ { key: 14, indexedProperty: "patate" } :+: Nothing

800− ]

800+ ]

801− , onUpgradeNeeded: Nothing

801+ , onUpgradeNeeded: Nothing

802+ }

803+ let

804+ cb =

805+ { onSuccess: const $ pure unit

806+ , onError: show >>> fail >>> launchAff'

807+ , onComplete: pure unit

802 }

808 }

809+ tx <- IDBDatabase.transaction db [ "store" ] ReadOnly

810+ store <- IDBTransaction.objectStore tx "store"

811+ index <- IDBObjectStore.index store "index"

812+ IDBTransaction.onAbort tx (pure unit)

813+ IDBTransaction.abort tx

814+ cursor <- attempt $ IDBIndex.openCursor index Nothing Next cb

815+ case cursor of

816+ Right _ -> fail "expected TransactionInactiveError"

817+ Left err -> name err `shouldEqual` "TransactionInactiveError"

818+

819+ tearDown db

820+

821+ it "openCursor() - throw InvalidStateError when the index is deleted" do

822+ { db } <- setup

823+ { storeParams: { keyPath: [ "key" ], autoIncrement: false }

824+ , indexParams: IDBObjectStore.defaultParameters

825+ , keyPath: [ "indexedProperty" ]

826+ , values:

827+ [ { key: 14, indexedProperty: "patate" } :+: Nothing

828+ ]

829+ , onUpgradeNeeded: Just $ \db tx index -> launchAff' do

830+ let

831+ cb =

832+ { onSuccess: const $ pure unit

833+ , onError: show >>> fail >>> launchAff'

834+ , onComplete: pure unit

835+ }

836+ store <- IDBTransaction.objectStore tx "store"

837+ IDBObjectStore.deleteIndex store "index"

838+ cursor <- attempt $ IDBIndex.openCursor index Nothing Next cb

839+ case cursor of

840+ Right _ -> fail "expected InvalidStateError"

841+ Left err -> name err `shouldEqual` "InvalidStateError"

842+ }

843+

844+ tearDown db

845+

846+ it "getKey() - multiEntry - adding keys" do

847+ { db } <- setup

848+ { storeParams: IDBDatabase.defaultParameters

849+ , indexParams: { unique: false, multiEntry: true }

850+ , keyPath: [ "name" ]

851+ , values:

852+ [ { name: [ "patate", "autruche" ] } :+: (Just $ toKey 1)

853+ , { name: [ "bob" ] } :+: (Just $ toKey 2)

854+ ]

855+ , onUpgradeNeeded: Just $ \_ _ index -> launchAff' do

856+ key <- IDBIndex.getKey index (IDBKeyRange.only "patate")

857+ key `shouldEqual` (Just $ toKey 1)

858+

859+ key' <- IDBIndex.getKey index (IDBKeyRange.only "autruche")

860+ key' `shouldEqual` (Just $ toKey 1)

861+

862+ key'' <- IDBIndex.getKey index (IDBKeyRange.only "bob")

863+ key'' `shouldEqual` (Just $ toKey 2)

864+ }

865+ tearDown db

866+

867+ it "get() - returns the record with the first key in the range" do

868+ { db } <- setup

869+ { storeParams: { keyPath: [ "key" ], autoIncrement: false }

870+ , indexParams: IDBObjectStore.defaultParameters

871+ , keyPath: [ "indexedProperty" ]

872+ , values:

873+ [ { key: 14, indexedProperty: "patate" } :+: Nothing

874+ , { key: 42, indexedProperty: "autruche" } :+: Nothing

875+ , { key: 1337, indexedProperty: "baguette" } :+: Nothing

876+ ]

877+ , onUpgradeNeeded: Nothing

878+ }

879+

880+ tx <- IDBDatabase.transaction db [ "store" ] ReadOnly

881+ store <- IDBTransaction.objectStore tx "store"

882+ index <- IDBObjectStore.index store "index"

883+ val <- IDBIndex.get index (IDBKeyRange.lowerBound "autruche" false)

884+ ((\r -> r.key) <$> val) `shouldEqual` (Just 42)

885+

886+ tearDown db

887+

888+ describe "IDBCursor" do

889+ let

890+ tearDown db = do

891+ IDBDatabase.close db

892+ _ <- IDBFactory.deleteDatabase (IDBDatabase.name db)

893+ pure unit

894+

895+ setup

896+ :: forall value

897+ . { storeParams :: { keyPath :: Array String, autoIncrement :: Boolean }

898+ , indexParams :: { unique :: Boolean, multiEntry :: Boolean }

899+ , values :: Array (Tuple value (Maybe Key))

900+ , keyPath :: Array String

901+ , onUpgradeNeeded :: Maybe (Database -> Transaction -> Index -> Effect Unit)

902+ }

903+ -> Aff { db :: Database, index :: Index, store :: ObjectStore }

904+ setup { storeParams, indexParams, values, keyPath, onUpgradeNeeded } = do

803 let

905 let

804− cb =

906+ onUpgradeNeeded' var db tx _ = launchAff' do

805− { onSuccess: const $ pure unit

907+ store <- IDBDatabase.createObjectStore db "store" storeParams

806− , onError: show >>> fail >>> launchAff'

908+ _ <- traverse (uncurry (IDBObjectStore.add store)) values

807− , onComplete: pure unit

909+ index <- IDBObjectStore.createIndex store "index" keyPath indexParams

808− }

910+ liftEffect $ maybe (pure unit) identity (onUpgradeNeeded <*> pure db <*> pure tx <*> pure index)

809− tx <- IDBDatabase.transaction db [ "store" ] ReadOnly

911+ AVar.put { db, index, store } var

810− store <- IDBTransaction.objectStore tx "store"

811− index <- IDBObjectStore.index store "index"

812− IDBTransaction.onAbort tx (pure unit)

813− IDBTransaction.abort tx

814− cursor <- attempt $ IDBIndex.openCursor index Nothing Next cb

815− case cursor of

816− Right _ -> fail "expected TransactionInactiveError"

817− Left err -> name err `shouldEqual` "TransactionInactiveError"

818−

819− tearDown db

820−

821− it "openCursor() - throw InvalidStateError when the index is deleted" do

822− { db } <- setup

823− { storeParams: { keyPath: [ "key" ], autoIncrement: false }

824− , indexParams: IDBObjectStore.defaultParameters

825− , keyPath: [ "indexedProperty" ]

826− , values:

827− [ { key: 14, indexedProperty: "patate" } :+: Nothing

828− ]

829− , onUpgradeNeeded: Just $ \db tx index -> launchAff' do

830− let

831− cb =

832− { onSuccess: const $ pure unit

833− , onError: show >>> fail >>> launchAff'

834− , onComplete: pure unit

835− }

836− store <- IDBTransaction.objectStore tx "store"

837− IDBObjectStore.deleteIndex store "index"

838− cursor <- attempt $ IDBIndex.openCursor index Nothing Next cb

839− case cursor of

840− Right _ -> fail "expected InvalidStateError"

841− Left err -> name err `shouldEqual` "InvalidStateError"

842− }

843

912

844− tearDown db

913+ var <- AVar.empty

845−

914+ db <- IDBFactory.open "db" Nothing

846− it "getKey() - multiEntry - adding keys" do

915+ { onUpgradeNeeded: Just (onUpgradeNeeded' var)

847− { db } <- setup

916+ , onBlocked: Nothing

848− { storeParams: IDBDatabase.defaultParameters

849− , indexParams: { unique: false, multiEntry: true }

850− , keyPath: [ "name" ]

851− , values:

852− [ { name: [ "patate", "autruche" ] } :+: (Just $ toKey 1)

853− , { name: [ "bob" ] } :+: (Just $ toKey 2)

854− ]

855− , onUpgradeNeeded: Just $ \_ _ index -> launchAff' do

856− key <- IDBIndex.getKey index (IDBKeyRange.only "patate")

857− key `shouldEqual` (Just $ toKey 1)

858−

859− key' <- IDBIndex.getKey index (IDBKeyRange.only "autruche")

860− key' `shouldEqual` (Just $ toKey 1)

861−

862− key'' <- IDBIndex.getKey index (IDBKeyRange.only "bob")

863− key'' `shouldEqual` (Just $ toKey 2)

864 }

917 }

865− tearDown db

918+ AVar.take var

866−

919+

867− it "get() - returns the record with the first key in the range" do

920+ it "continue() - iterate to the next record" do

868− { db } <- setup

921+ { db } <- setup

869− { storeParams: { keyPath: [ "key" ], autoIncrement: false }

922+ { storeParams: IDBDatabase.defaultParameters

870− , indexParams: IDBObjectStore.defaultParameters

923+ , indexParams: IDBObjectStore.defaultParameters

871− , keyPath: [ "indexedProperty" ]

924+ , keyPath: []

872− , values:

925+ , values:

873− [ { key: 14, indexedProperty: "patate" } :+: Nothing

926+ [ "cupcake" :+: (Just $ toKey 4)

874− , { key: 42, indexedProperty: "autruche" } :+: Nothing

927+ , "pancake" :+: (Just $ toKey 2)

875− , { key: 1337, indexedProperty: "baguette" } :+: Nothing

928+ , "pie" :+: (Just $ toKey 1)

929+ , "pie" :+: (Just $ toKey 3)

876− ]

930+ ]

877− , onUpgradeNeeded: Nothing

931+ , onUpgradeNeeded: Nothing

932+ }

933+ let

934+ cb vdone vvals =

935+ { onComplete: launchAff' do

936+ AVar.put unit vdone

937+

938+ , onError: \error -> launchAff' do

939+ fail $ "unexpected error: " <> show error

940+

941+ , onSuccess: \cursor -> launchAff' do

942+ vals <- AVar.take vvals

943+ pure (IDBCursor.value cursor) >>= shouldEqual (maybe "" _.v $ head vals)

944+ IDBCursor.primaryKey cursor >>= shouldEqual (maybe (toKey 0) _.k $ head vals)

945+ AVar.put (drop 1 vals) vvals

946+ IDBCursor.continue cursor none

878 }

947 }

879−

948+ vdone <- AVar.empty

949+ vvals <- AVar.new

950+ [ { v: "pie", k: toKey 1 }

951+ , { v: "pancake", k: toKey 2 }

952+ , { v: "pie", k: toKey 3 }

953+ , { v: "cupcake", k: toKey 4 }

954+ ]

880− tx <- IDBDatabase.transaction db [ "store" ] ReadOnly

955+ tx <- IDBDatabase.transaction db [ "store" ] ReadOnly

881− store <- IDBTransaction.objectStore tx "store"

956+ store <- IDBTransaction.objectStore tx "store"

882− index <- IDBObjectStore.index store "index"

957+ IDBObjectStore.openCursor store Nothing Next (cb vdone vvals)

883− val <- IDBIndex.get index (IDBKeyRange.lowerBound "autruche" false)

958+ AVar.take vdone

884− ((\r -> r.key) <$> val) `shouldEqual` (Just 42)

885−

886− tearDown db

959+ tearDown db

887−

960+

888− describe "IDBCursor" do

961+ it "continue() - attempt to iterate in the wrong direction" do

962+ { db } <- setup

963+ { storeParams: IDBDatabase.defaultParameters

964+ , indexParams: IDBObjectStore.defaultParameters

965+ , keyPath: []

966+ , values:

967+ [ "cupcake" :+: (Just $ toKey 4)

968+ , "pancake" :+: (Just $ toKey 2)

969+ , "pie" :+: (Just $ toKey 1)

970+ , "pie" :+: (Just $ toKey 3)

971+ ]

972+ , onUpgradeNeeded: Nothing

973+ }

889 let

974 let

890− tearDown db = do

975+ cb vdone =

891− IDBDatabase.close db

976+ { onComplete: launchAff' do

892− _ <- IDBFactory.deleteDatabase (IDBDatabase.name db)

977+ fail $ "shouldn't complete"

893− pure unit

978+

894−

979+ , onError: \error -> launchAff' do

895− setup

980+ fail $ "unexpected error: " <> show error

896− :: forall value

981+

897− . { storeParams :: { keyPath :: Array String, autoIncrement :: Boolean }

982+ , onSuccess: \cursor -> launchAff' do

898− , indexParams :: { unique :: Boolean, multiEntry :: Boolean }

983+ res <- attempt $ IDBCursor.continue cursor (Just 1)

899− , values :: Array (Tuple value (Maybe Key))

984+ case res of

900− , keyPath :: Array String

985+ Left err -> do

901− , onUpgradeNeeded :: Maybe (Database -> Transaction -> Index -> Effect Unit)

986+ name err `shouldEqual` "DataError"

902− }

987+ AVar.put unit vdone

903− -> Aff { db :: Database, index :: Index, store :: ObjectStore }

988+ Right _ -> do

904− setup { storeParams, indexParams, values, keyPath, onUpgradeNeeded } = do

989+ fail "expected continue to fail"

905− let

906− onUpgradeNeeded' var db tx _ = launchAff' do

907− store <- IDBDatabase.createObjectStore db "store" storeParams

908− _ <- traverse (uncurry (IDBObjectStore.add store)) values

909− index <- IDBObjectStore.createIndex store "index" keyPath indexParams

910− liftEffect $ maybe (pure unit) identity (onUpgradeNeeded <*> pure db <*> pure tx <*> pure index)

911− AVar.put { db, index, store } var

912−

913− var <- AVar.empty

914− db <- IDBFactory.open "db" Nothing

915− { onUpgradeNeeded: Just (onUpgradeNeeded' var)

916− , onBlocked: Nothing

917− }

918− AVar.take var

919−

920− it "continue() - iterate to the next record" do

921− { db } <- setup

922− { storeParams: IDBDatabase.defaultParameters

923− , indexParams: IDBObjectStore.defaultParameters

924− , keyPath: []

925− , values:

926− [ "cupcake" :+: (Just $ toKey 4)

927− , "pancake" :+: (Just $ toKey 2)

928− , "pie" :+: (Just $ toKey 1)

929− , "pie" :+: (Just $ toKey 3)

930− ]

931− , onUpgradeNeeded: Nothing

932 }

990 }

991+ vdone <- AVar.empty

992+ tx <- IDBDatabase.transaction db [ "store" ] ReadOnly

993+ store <- IDBTransaction.objectStore tx "store"

994+ IDBObjectStore.openCursor store Nothing Next (cb vdone)

995+ AVar.take vdone

996+ tearDown db

997+

998+ it "advance() - iterate cursor number of times specified by count" do

999+ { db } <- setup

1000+ { storeParams: { keyPath: [ "pKey" ], autoIncrement: false }

1001+ , indexParams: IDBObjectStore.defaultParameters

1002+ , keyPath: []

1003+ , values:

1004+ [ { pKey: "pkey_0", iKey: "ikey_0" } :+: Nothing

1005+ , { pKey: "pkey_1", iKey: "ikey_1" } :+: Nothing

1006+ , { pKey: "pkey_2", iKey: "ikey_2" } :+: Nothing

1007+ , { pKey: "pkey_3", iKey: "ikey_3" } :+: Nothing

1008+ ]

1009+ , onUpgradeNeeded: Nothing

1010+ }

933− let

1011+ let

934− cb vdone vvals =

1012+ cb vdone vjump =

935− { onComplete: launchAff' do

1013+ { onComplete: launchAff' do

936− AVar.put unit vdone

1014+ AVar.put unit vdone

937−

1015+

938− , onError: \error -> launchAff' do

1016+ , onError: \error -> launchAff' do

939− fail $ "unexpected error: " <> show error

1017+ fail $ "unexpected error: " <> show error

940−

1018+

941− , onSuccess: \cursor -> launchAff' do

1019+ , onSuccess: \cursor -> launchAff' do

942− vals <- AVar.take vvals

1020+ jump <- AVar.take vjump

1021+ if jump then do

943− pure (IDBCursor.value cursor) >>= shouldEqual (maybe "" _.v $ head vals)

1022+ IDBCursor.advance cursor 3

944− IDBCursor.primaryKey cursor >>= shouldEqual (maybe (toKey 0) _.k $ head vals)

1023+ else do

945− AVar.put (drop 1 vals) vvals

1024+ let value = IDBCursor.value cursor

1025+ value.pKey `shouldEqual` "pkey_3"

1026+ value.iKey `shouldEqual` "ikey_3"

946 IDBCursor.continue cursor none

1027 IDBCursor.continue cursor none

947− }

1028+ AVar.put false vjump

948− vdone <- AVar.empty

949− vvals <- AVar.new

950− [ { v: "pie", k: toKey 1 }

951− , { v: "pancake", k: toKey 2 }

952− , { v: "pie", k: toKey 3 }

953− , { v: "cupcake", k: toKey 4 }

954− ]

955− tx <- IDBDatabase.transaction db [ "store" ] ReadOnly

956− store <- IDBTransaction.objectStore tx "store"

957− IDBObjectStore.openCursor store Nothing Next (cb vdone vvals)

958− AVar.take vdone

959− tearDown db

960−

961− it "continue() - attempt to iterate in the wrong direction" do

962− { db } <- setup

963− { storeParams: IDBDatabase.defaultParameters

964− , indexParams: IDBObjectStore.defaultParameters

965− , keyPath: []

966− , values:

967− [ "cupcake" :+: (Just $ toKey 4)

968− , "pancake" :+: (Just $ toKey 2)

969− , "pie" :+: (Just $ toKey 1)

970− , "pie" :+: (Just $ toKey 3)

971− ]

972− , onUpgradeNeeded: Nothing

973 }

1029 }

974− let

975− cb vdone =

976− { onComplete: launchAff' do

977− fail $ "shouldn't complete"

978−

979− , onError: \error -> launchAff' do

980− fail $ "unexpected error: " <> show error

981−

982− , onSuccess: \cursor -> launchAff' do

983− res <- attempt $ IDBCursor.continue cursor (Just 1)

984− case res of

985− Left err -> do

986− name err `shouldEqual` "DataError"

987− AVar.put unit vdone

988− Right _ -> do

989− fail "expected continue to fail"

990− }

991− vdone <- AVar.empty

1030+ vdone <- AVar.empty

1031+ vjump <- AVar.new true

992− tx <- IDBDatabase.transaction db [ "store" ] ReadOnly

1032+ tx <- IDBDatabase.transaction db [ "store" ] ReadOnly

993− store <- IDBTransaction.objectStore tx "store"

1033+ store <- IDBTransaction.objectStore tx "store"

994− IDBObjectStore.openCursor store Nothing Next (cb vdone)

1034+ IDBObjectStore.openCursor store Nothing Next (cb vdone vjump)

995− AVar.take vdone

1035+ AVar.take vdone

996− tearDown db

1036+ tearDown db

997−

1037+

998− it "advance() - iterate cursor number of times specified by count" do

1038+ it "delete() - remove a record from the object store" do

999− { db } <- setup

1039+ { db } <- setup

1000− { storeParams: { keyPath: [ "pKey" ], autoIncrement: false }

1040+ { storeParams: { keyPath: [ "pKey" ], autoIncrement: false }

1001− , indexParams: IDBObjectStore.defaultParameters

1041+ , indexParams: IDBObjectStore.defaultParameters

1002− , keyPath: []

1042+ , keyPath: []

1003− , values:

1043+ , values:

1004− [ { pKey: "pkey_0", iKey: "ikey_0" } :+: Nothing

1044+ [ { pKey: "pkey_0", iKey: "ikey_0" } :+: Nothing

1005− , { pKey: "pkey_1", iKey: "ikey_1" } :+: Nothing

1045+ , { pKey: "pkey_1", iKey: "ikey_1" } :+: Nothing

1006− , { pKey: "pkey_2", iKey: "ikey_2" } :+: Nothing

1046+ , { pKey: "pkey_2", iKey: "ikey_2" } :+: Nothing

1007− , { pKey: "pkey_3", iKey: "ikey_3" } :+: Nothing

1047+ , { pKey: "pkey_3", iKey: "ikey_3" } :+: Nothing

1008− ]

1048+ ]

1009− , onUpgradeNeeded: Nothing

1049+ , onUpgradeNeeded: Nothing

1050+ }

1051+ let

1052+ cb vdone store =

1053+ { onComplete: launchAff' do

1054+ mval <- map _.pKey <$> IDBIndex.get store (IDBKeyRange.only "pkey_0")

1055+ mval `shouldEqual` (Nothing :: Maybe String)

1056+ AVar.put unit vdone

1057+

1058+ , onError: \error -> launchAff' do

1059+ fail $ "unexpected error: " <> show error

1060+

1061+ , onSuccess: \cursor -> launchAff' do

1062+ let value = IDBCursor.value cursor

1063+ value.pKey `shouldEqual` "pkey_0"

1064+ IDBCursor.delete cursor

1065+ IDBCursor.advance cursor 4

1010 }

1066 }

1011− let

1012− cb vdone vjump =

1013− { onComplete: launchAff' do

1014− AVar.put unit vdone

1015−

1016− , onError: \error -> launchAff' do

1017− fail $ "unexpected error: " <> show error

1018−

1019− , onSuccess: \cursor -> launchAff' do

1020− jump <- AVar.take vjump

1021− if jump then do

1022− IDBCursor.advance cursor 3

1023− else do

1024− let value = IDBCursor.value cursor

1025− value.pKey `shouldEqual` "pkey_3"

1026− value.iKey `shouldEqual` "ikey_3"

1027− IDBCursor.continue cursor none

1028− AVar.put false vjump

1029− }

1030− vdone <- AVar.empty

1067+ vdone <- AVar.empty

1031− vjump <- AVar.new true

1032− tx <- IDBDatabase.transaction db [ "store" ] ReadOnly

1068+ tx <- IDBDatabase.transaction db [ "store" ] ReadWrite

1033− store <- IDBTransaction.objectStore tx "store"

1069+ store <- IDBTransaction.objectStore tx "store"

1034− IDBObjectStore.openCursor store Nothing Next (cb vdone vjump)

1070+ IDBObjectStore.openCursor store Nothing Next (cb vdone store)

1035− AVar.take vdone

1071+ AVar.take vdone

1036− tearDown db

1072+ tearDown db

1037−

1073+

1038− it "delete() - remove a record from the object store" do

1074+ it "update() - modify a record in the object store" do

1039− { db } <- setup

1075+ { db } <- setup

1040− { storeParams: { keyPath: [ "pKey" ], autoIncrement: false }

1076+ { storeParams: { keyPath: [ "pKey" ], autoIncrement: false }

1041− , indexParams: IDBObjectStore.defaultParameters

1077+ , indexParams: IDBObjectStore.defaultParameters

1042− , keyPath: []

1078+ , keyPath: []

1043− , values:

1079+ , values:

1044− [ { pKey: "pkey_0", iKey: "ikey_0" } :+: Nothing

1080+ [ { pKey: "pkey_0", iKey: "ikey_0" } :+: Nothing

1045− , { pKey: "pkey_1", iKey: "ikey_1" } :+: Nothing

1046− , { pKey: "pkey_2", iKey: "ikey_2" } :+: Nothing

1047− , { pKey: "pkey_3", iKey: "ikey_3" } :+: Nothing

1048− ]

1081+ ]

1049− , onUpgradeNeeded: Nothing

1082+ , onUpgradeNeeded: Nothing

1083+ }

1084+ let

1085+ cb vdone store =

1086+ { onComplete: launchAff' do

1087+ mval <- map _.iKey <$> IDBIndex.get store (IDBKeyRange.only "pkey_0")

1088+ mval `shouldEqual` (Just "patate")

1089+ AVar.put unit vdone

1090+

1091+ , onError: \error -> launchAff' do

1092+ fail $ "unexpected error: " <> show error

1093+

1094+ , onSuccess: \cursor -> launchAff' do

1095+ let value = IDBCursor.value cursor

1096+ value.pKey `shouldEqual` "pkey_0"

1097+ key <- IDBCursor.update cursor { pKey: "pkey_0", iKey: "patate" }

1098+ key `shouldEqual` toKey "pkey_0"

1099+ IDBCursor.advance cursor 4

1050 }

1100 }

1051− let

1052− cb vdone store =

1053− { onComplete: launchAff' do

1054− mval <- map _.pKey <$> IDBIndex.get store (IDBKeyRange.only "pkey_0")

1055− mval `shouldEqual` (Nothing :: Maybe String)

1056− AVar.put unit vdone

1057−

1058− , onError: \error -> launchAff' do

1059− fail $ "unexpected error: " <> show error

1060−

1061− , onSuccess: \cursor -> launchAff' do

1062− let value = IDBCursor.value cursor

1063− value.pKey `shouldEqual` "pkey_0"

1064− IDBCursor.delete cursor

1065− IDBCursor.advance cursor 4

1066− }

1067− vdone <- AVar.empty

1101+ vdone <- AVar.empty

1068− tx <- IDBDatabase.transaction db [ "store" ] ReadWrite

1102+ tx <- IDBDatabase.transaction db [ "store" ] ReadWrite

1069− store <- IDBTransaction.objectStore tx "store"

1103+ store <- IDBTransaction.objectStore tx "store"

1070− IDBObjectStore.openCursor store Nothing Next (cb vdone store)

1104+ IDBObjectStore.openCursor store Nothing Next (cb vdone store)

1071− AVar.take vdone

1105+ AVar.take vdone

1072− tearDown db

1106+ tearDown db

1073−

1107+

1074− it "update() - modify a record in the object store" do

1108+ it "update() - throw ReadOnlyError after update on ReadOnly transaction" do

1075− { db } <- setup

1109+ { db } <- setup

1076− { storeParams: { keyPath: [ "pKey" ], autoIncrement: false }

1110+ { storeParams: { keyPath: [ "pKey" ], autoIncrement: false }

1077− , indexParams: IDBObjectStore.defaultParameters

1111+ , indexParams: IDBObjectStore.defaultParameters

1078− , keyPath: []

1112+ , keyPath: []

1079− , values:

1113+ , values:

1080− [ { pKey: "pkey_0", iKey: "ikey_0" } :+: Nothing

1114+ [ { pKey: "pkey_0", iKey: "ikey_0" } :+: Nothing

1081− ]

1115+ ]

1082− , onUpgradeNeeded: Nothing

1116+ , onUpgradeNeeded: Nothing

1117+ }

1118+ let

1119+ cb vdone =

1120+ { onComplete: launchAff' do

1121+ fail $ "shouldn't complete"

1122+

1123+ , onError: \error -> launchAff' do

1124+ fail $ "unexpected error: " <> show error

1125+

1126+ , onSuccess: \cursor -> launchAff' do

1127+ res <- attempt $ IDBCursor.update cursor "patate"

1128+ case res of

1129+ Left err -> do

1130+ name err `shouldEqual` "ReadOnlyError"

1131+ AVar.put unit vdone

1132+ Right _ ->

1133+ fail $ "expected ReadOnlyError"

1083 }

1134 }

1084− let

1135+ vdone <- AVar.empty

1085− cb vdone store =

1136+ tx <- IDBDatabase.transaction db [ "store" ] ReadOnly

1086− { onComplete: launchAff' do

1137+ store <- IDBTransaction.objectStore tx "store"

1087− mval <- map _.iKey <$> IDBIndex.get store (IDBKeyRange.only "pkey_0")

1138+ IDBObjectStore.openCursor store Nothing Next (cb vdone)

1088− mval `shouldEqual` (Just "patate")

1139+ AVar.take vdone

1089− AVar.put unit vdone

1140+ tearDown db

1090

1141

1091− , onError: \error -> launchAff' do

1092− fail $ "unexpected error: " <> show error

1093−

1094− , onSuccess: \cursor -> launchAff' do

1095− let value = IDBCursor.value cursor

1096− value.pKey `shouldEqual` "pkey_0"

1097− key <- IDBCursor.update cursor { pKey: "pkey_0", iKey: "patate" }

1098− key `shouldEqual` toKey "pkey_0"

1099− IDBCursor.advance cursor 4

1100− }

1101− vdone <- AVar.empty

1102− tx <- IDBDatabase.transaction db [ "store" ] ReadWrite

1103− store <- IDBTransaction.objectStore tx "store"

1104− IDBObjectStore.openCursor store Nothing Next (cb vdone store)

1105− AVar.take vdone

1106− tearDown db

1107−

1108− it "update() - throw ReadOnlyError after update on ReadOnly transaction" do

1109− { db } <- setup

1110− { storeParams: { keyPath: [ "pKey" ], autoIncrement: false }

1111− , indexParams: IDBObjectStore.defaultParameters

1112− , keyPath: []

1113− , values:

1114− [ { pKey: "pkey_0", iKey: "ikey_0" } :+: Nothing

1115− ]

1116− , onUpgradeNeeded: Nothing

1117− }

1118− let

1119− cb vdone =

1120− { onComplete: launchAff' do

1121− fail $ "shouldn't complete"

1122−

1123− , onError: \error -> launchAff' do

1124− fail $ "unexpected error: " <> show error

1125−

1126− , onSuccess: \cursor -> launchAff' do

1127− res <- attempt $ IDBCursor.update cursor "patate"

1128− case res of

1129− Left err -> do

1130− name err `shouldEqual` "ReadOnlyError"

1131− AVar.put unit vdone

1132− Right _ ->

1133− fail $ "expected ReadOnlyError"

1134− }

1135− vdone <- AVar.empty

1136− tx <- IDBDatabase.transaction db [ "store" ] ReadOnly

1137− store <- IDBTransaction.objectStore tx "store"

1138− IDBObjectStore.openCursor store Nothing Next (cb vdone)

1139− AVar.take vdone

1140− tearDown db

yarn.locknew file+81

@@ -0,0 +1,81 @@

1+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.

2+# yarn lockfile v1

5+base64-arraybuffer-es6@^0.7.0:

6+ version "0.7.0"

7+ resolved "https://registry.yarnpkg.com/base64-arraybuffer-es6/-/base64-arraybuffer-es6-0.7.0.tgz#dbe1e6c87b1bf1ca2875904461a7de40f21abc86"

8+ integrity sha512-ESyU/U1CFZDJUdr+neHRhNozeCv72Y7Vm0m1DCbjX3KBjT6eYocvAJlSk6+8+HkVwXlT1FNxhGW6q3UKAlCvvw==

10+domexception@^1.0.1:

11+ version "1.0.1"

12+ resolved "https://registry.yarnpkg.com/domexception/-/domexception-1.0.1.tgz#937442644ca6a31261ef36e3ec677fe805582c90"

13+ integrity sha512-raigMkn7CJNNo6Ihro1fzG7wr3fHuYVytzquZKX5n0yizGsTcYgzdIUwj1X9pK0VvjeihV+XiclP+DjwbsSKug==

14+ dependencies:

15+ webidl-conversions "^4.0.2"

16+

17+fake-indexeddb@^4.0.1:

18+ version "4.0.1"

19+ resolved "https://registry.yarnpkg.com/fake-indexeddb/-/fake-indexeddb-4.0.1.tgz#09bb2468e21d0832b2177e894765fb109edac8fb"

20+ integrity sha512-hFRyPmvEZILYgdcLBxVdHLik4Tj3gDTu/g7s9ZDOiU3sTNiGx+vEu1ri/AMsFJUZ/1sdRbAVrEcKndh3sViBcA==

21+ dependencies:

22+ realistic-structured-clone "^3.0.0"

23+

24+lodash@^4.7.0:

25+ version "4.17.21"

26+ resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c"

27+ integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==

28+

29+punycode@^2.1.1:

30+ version "2.3.0"

31+ resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.3.0.tgz#f67fa67c94da8f4d0cfff981aee4118064199b8f"

32+ integrity sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA==

33+

34+realistic-structured-clone@^3.0.0:

35+ version "3.0.0"

36+ resolved "https://registry.yarnpkg.com/realistic-structured-clone/-/realistic-structured-clone-3.0.0.tgz#7b518049ce2dad41ac32b421cd297075b00e3e35"

37+ integrity sha512-rOjh4nuWkAqf9PWu6JVpOWD4ndI+JHfgiZeMmujYcPi+fvILUu7g6l26TC1K5aBIp34nV+jE1cDO75EKOfHC5Q==

38+ dependencies:

39+ domexception "^1.0.1"

40+ typeson "^6.1.0"

41+ typeson-registry "^1.0.0-alpha.20"

42+

43+tr46@^2.1.0:

44+ version "2.1.0"

45+ resolved "https://registry.yarnpkg.com/tr46/-/tr46-2.1.0.tgz#fa87aa81ca5d5941da8cbf1f9b749dc969a4e240"

46+ integrity sha512-15Ih7phfcdP5YxqiB+iDtLoaTz4Nd35+IiAv0kQ5FNKHzXgdWqPoTIqEDDJmXceQt4JZk6lVPT8lnDlPpGDppw==

47+ dependencies:

48+ punycode "^2.1.1"

49+

50+typeson-registry@^1.0.0-alpha.20:

51+ version "1.0.0-alpha.39"

52+ resolved "https://registry.yarnpkg.com/typeson-registry/-/typeson-registry-1.0.0-alpha.39.tgz#9e0f5aabd5eebfcffd65a796487541196f4b1211"

53+ integrity sha512-NeGDEquhw+yfwNhguLPcZ9Oj0fzbADiX4R0WxvoY8nGhy98IbzQy1sezjoEFWOywOboj/DWehI+/aUlRVrJnnw==

54+ dependencies:

55+ base64-arraybuffer-es6 "^0.7.0"

56+ typeson "^6.0.0"

57+ whatwg-url "^8.4.0"

58+

59+typeson@^6.0.0, typeson@^6.1.0:

60+ version "6.1.0"

61+ resolved "https://registry.yarnpkg.com/typeson/-/typeson-6.1.0.tgz#5b2a53705a5f58ff4d6f82f965917cabd0d7448b"

62+ integrity sha512-6FTtyGr8ldU0pfbvW/eOZrEtEkczHRUtduBnA90Jh9kMPCiFNnXIon3vF41N0S4tV1HHQt4Hk1j4srpESziCaA==

63+

64+webidl-conversions@^4.0.2:

65+ version "4.0.2"

66+ resolved "https://registry.yarnpkg.com/webidl-conversions/-/webidl-conversions-4.0.2.tgz#a855980b1f0b6b359ba1d5d9fb39ae941faa63ad"

67+ integrity sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg==

68+

69+webidl-conversions@^6.1.0:

70+ version "6.1.0"

71+ resolved "https://registry.yarnpkg.com/webidl-conversions/-/webidl-conversions-6.1.0.tgz#9111b4d7ea80acd40f5270d666621afa78b69514"

72+ integrity sha512-qBIvFLGiBpLjfwmYAaHPXsn+ho5xZnGvyGvsarywGNc8VyQJUMHJ8OBKGGrPER0okBeMDaan4mNBlgBROxuI8w==

73+

74+whatwg-url@^8.4.0:

75+ version "8.7.0"

76+ resolved "https://registry.yarnpkg.com/whatwg-url/-/whatwg-url-8.7.0.tgz#656a78e510ff8f3937bc0bcbe9f5c0ac35941b77"

77+ integrity sha512-gAojqb/m9Q8a5IV96E3fHJM70AzCkgt4uXYX2O7EmuyOnLrViCQlsEBmF9UQIu3/aeAIp2U17rtbpZWNntQqdg==

78+ dependencies:

79+ lodash "^4.7.0"

80+ tr46 "^2.1.0"

81+ webidl-conversions "^6.1.0"