prism-cli 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,7 @@
1
+ ---
2
+ SHA256:
3
+ metadata.gz: b0218ebb7dce432192080abe5363572f90c165fe5973b5ccafc331114d623bac
4
+ data.tar.gz: 71c1f38bce33cef73884c67a692fc2f75adf688a973499d74e37f216b21d75b2
5
+ SHA512:
6
+ metadata.gz: ed762dc2a2f25993499303bcbef0eba3af8e644d330761a36c2344bdfeb7ab47c0f0096302a02760600852dc947fed3bcb32f071407f007d0510e2c4c949330d
7
+ data.tar.gz: dc9e250cca5874922cf1a664aa1f81ec4fb42cf63c9852868708fb5299179d66fd85f2841da8c5b20bc5a90dcc1e03e380d2277aaa0cec9c80dcf25bf05e09e8
@@ -0,0 +1,116 @@
1
+ #!/usr/bin/env ruby
2
+
3
+ TEMPLATE = <<-TEMPLATE.strip
4
+ class HelloWorld < Prism::Component
5
+ attr_accessor :name
6
+
7
+ def initialize(name = "World")
8
+ @name = name
9
+ end
10
+
11
+ def render
12
+ div(".hello-world", [
13
+ input(onInput: call(:name=).with_target_data(:value)),
14
+ div("Hello, \#{name}")
15
+ ])
16
+ end
17
+ end
18
+
19
+ Prism.mount(HelloWorld.new)
20
+ TEMPLATE
21
+
22
+ HTML_TEMPLATE = <<-HTML.strip
23
+ <!DOCTYPE html>
24
+ <html lang=en-us>
25
+
26
+ <head>
27
+ <meta charset=utf-8>
28
+ <meta content="text/html; charset=utf-8" http-equiv=Content-Type>
29
+ <title>Hello World</title>
30
+ </head>
31
+
32
+ <body>
33
+ <div id="root"></div>
34
+ <script src="prism.js"></script>
35
+ <script async src=bundle.js></script>
36
+ </body>
37
+ </html>
38
+ HTML
39
+
40
+ def init(path = "app.rb")
41
+ fail "#{path} already exists" if File.exist?(path)
42
+ File.write(path, TEMPLATE) # TODO - there's a race condition here where the file is created between the previous statement and this one
43
+ puts "Created new Prism app at app.rb\n\nRun prism build #{path} to compile your app."
44
+ end
45
+
46
+ def build(files)
47
+ mrbc_path = `which mrbc`.split("\n").first
48
+ emcc_path = `which emcc`.split("\n").first
49
+
50
+ if (!mrbc_path || !emcc_path)
51
+ puts "Error: Please ensure you have mruby and emscripten installed and available on the $PATH.\n\n mrbc: #{mrbc_path || 'Not found!'}\n emcc: #{emcc_path || 'Not found! Do you need to source emsdk_env.sh?'}"
52
+ exit 1
53
+ end
54
+
55
+ all_files = ["#{__dir__}/../src/prism.rb"] + files
56
+ bundle = all_files.map { |f| File.read(f) }.join("\n")
57
+
58
+ `mkdir -p build`
59
+ Dir.chdir("build")
60
+
61
+ File.write("./bundle.rb", bundle)
62
+
63
+ puts "Compiling ruby code to mruby bytecode..."
64
+
65
+ `mrbc -Bbundle bundle.rb`
66
+ `cp #{__dir__}/../main.c main.c`
67
+
68
+ puts "Compiling to Wasm..."
69
+ `
70
+ emcc \
71
+ -s ALLOW_MEMORY_GROWTH=1 \
72
+ -s EXPORTED_FUNCTIONS="['_main', '_render', '_dispatch', '_event']" \
73
+ -s EXTRA_EXPORTED_RUNTIME_METHODS='["ccall", "cwrap"]' \
74
+ -s WASM=1 \
75
+ -I #{__dir__}/../mruby/include \
76
+ -g4 \
77
+ main.c \
78
+ #{__dir__}/../mruby/build/emscripten/lib/libmruby.a \
79
+ -o bundle.js
80
+ `
81
+
82
+ `cp #{__dir__}/../dist/prism.js ./prism.js`
83
+ File.write("./index.html", HTML_TEMPLATE) # TODO - there's a race condition here where the file is created between the previous statement and this one
84
+ `rm bundle.c bundle.rb main.c`
85
+ puts "Compiled to build/"
86
+ end
87
+
88
+ def server
89
+ Dir.chdir("build")
90
+ `node #{__dir__}/../wasm-server.js`
91
+ end
92
+
93
+ def help
94
+ puts <<-HEREDOC.strip
95
+ Usage: prism <command> [options]
96
+
97
+ Commands:
98
+ init initializes a new prism application
99
+ build <entrypoint> builds a prism application
100
+ server
101
+ HEREDOC
102
+ end
103
+
104
+ command, *rest = ARGV
105
+
106
+ case command
107
+ when "init"
108
+ init
109
+ when "build"
110
+ rest = ["app.rb"] if rest.empty?
111
+ build(rest)
112
+ when "server"
113
+ server
114
+ else
115
+ help
116
+ end
@@ -0,0 +1,893 @@
1
+ (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
2
+ "use strict";
3
+ Object.defineProperty(exports, "__esModule", { value: true });
4
+ var vnode_1 = require("./vnode");
5
+ var is = require("./is");
6
+ function addNS(data, children, sel) {
7
+ data.ns = 'http://www.w3.org/2000/svg';
8
+ if (sel !== 'foreignObject' && children !== undefined) {
9
+ for (var i = 0; i < children.length; ++i) {
10
+ var childData = children[i].data;
11
+ if (childData !== undefined) {
12
+ addNS(childData, children[i].children, children[i].sel);
13
+ }
14
+ }
15
+ }
16
+ }
17
+ function h(sel, b, c) {
18
+ var data = {}, children, text, i;
19
+ if (c !== undefined) {
20
+ data = b;
21
+ if (is.array(c)) {
22
+ children = c;
23
+ }
24
+ else if (is.primitive(c)) {
25
+ text = c;
26
+ }
27
+ else if (c && c.sel) {
28
+ children = [c];
29
+ }
30
+ }
31
+ else if (b !== undefined) {
32
+ if (is.array(b)) {
33
+ children = b;
34
+ }
35
+ else if (is.primitive(b)) {
36
+ text = b;
37
+ }
38
+ else if (b && b.sel) {
39
+ children = [b];
40
+ }
41
+ else {
42
+ data = b;
43
+ }
44
+ }
45
+ if (children !== undefined) {
46
+ for (i = 0; i < children.length; ++i) {
47
+ if (is.primitive(children[i]))
48
+ children[i] = vnode_1.vnode(undefined, undefined, undefined, children[i], undefined);
49
+ }
50
+ }
51
+ if (sel[0] === 's' && sel[1] === 'v' && sel[2] === 'g' &&
52
+ (sel.length === 3 || sel[3] === '.' || sel[3] === '#')) {
53
+ addNS(data, children, sel);
54
+ }
55
+ return vnode_1.vnode(sel, data, children, text, undefined);
56
+ }
57
+ exports.h = h;
58
+ ;
59
+ exports.default = h;
60
+
61
+ },{"./is":3,"./vnode":10}],2:[function(require,module,exports){
62
+ "use strict";
63
+ Object.defineProperty(exports, "__esModule", { value: true });
64
+ function createElement(tagName) {
65
+ return document.createElement(tagName);
66
+ }
67
+ function createElementNS(namespaceURI, qualifiedName) {
68
+ return document.createElementNS(namespaceURI, qualifiedName);
69
+ }
70
+ function createTextNode(text) {
71
+ return document.createTextNode(text);
72
+ }
73
+ function createComment(text) {
74
+ return document.createComment(text);
75
+ }
76
+ function insertBefore(parentNode, newNode, referenceNode) {
77
+ parentNode.insertBefore(newNode, referenceNode);
78
+ }
79
+ function removeChild(node, child) {
80
+ node.removeChild(child);
81
+ }
82
+ function appendChild(node, child) {
83
+ node.appendChild(child);
84
+ }
85
+ function parentNode(node) {
86
+ return node.parentNode;
87
+ }
88
+ function nextSibling(node) {
89
+ return node.nextSibling;
90
+ }
91
+ function tagName(elm) {
92
+ return elm.tagName;
93
+ }
94
+ function setTextContent(node, text) {
95
+ node.textContent = text;
96
+ }
97
+ function getTextContent(node) {
98
+ return node.textContent;
99
+ }
100
+ function isElement(node) {
101
+ return node.nodeType === 1;
102
+ }
103
+ function isText(node) {
104
+ return node.nodeType === 3;
105
+ }
106
+ function isComment(node) {
107
+ return node.nodeType === 8;
108
+ }
109
+ exports.htmlDomApi = {
110
+ createElement: createElement,
111
+ createElementNS: createElementNS,
112
+ createTextNode: createTextNode,
113
+ createComment: createComment,
114
+ insertBefore: insertBefore,
115
+ removeChild: removeChild,
116
+ appendChild: appendChild,
117
+ parentNode: parentNode,
118
+ nextSibling: nextSibling,
119
+ tagName: tagName,
120
+ setTextContent: setTextContent,
121
+ getTextContent: getTextContent,
122
+ isElement: isElement,
123
+ isText: isText,
124
+ isComment: isComment,
125
+ };
126
+ exports.default = exports.htmlDomApi;
127
+
128
+ },{}],3:[function(require,module,exports){
129
+ "use strict";
130
+ Object.defineProperty(exports, "__esModule", { value: true });
131
+ exports.array = Array.isArray;
132
+ function primitive(s) {
133
+ return typeof s === 'string' || typeof s === 'number';
134
+ }
135
+ exports.primitive = primitive;
136
+
137
+ },{}],4:[function(require,module,exports){
138
+ "use strict";
139
+ Object.defineProperty(exports, "__esModule", { value: true });
140
+ function updateClass(oldVnode, vnode) {
141
+ var cur, name, elm = vnode.elm, oldClass = oldVnode.data.class, klass = vnode.data.class;
142
+ if (!oldClass && !klass)
143
+ return;
144
+ if (oldClass === klass)
145
+ return;
146
+ oldClass = oldClass || {};
147
+ klass = klass || {};
148
+ for (name in oldClass) {
149
+ if (!klass[name]) {
150
+ elm.classList.remove(name);
151
+ }
152
+ }
153
+ for (name in klass) {
154
+ cur = klass[name];
155
+ if (cur !== oldClass[name]) {
156
+ elm.classList[cur ? 'add' : 'remove'](name);
157
+ }
158
+ }
159
+ }
160
+ exports.classModule = { create: updateClass, update: updateClass };
161
+ exports.default = exports.classModule;
162
+
163
+ },{}],5:[function(require,module,exports){
164
+ "use strict";
165
+ Object.defineProperty(exports, "__esModule", { value: true });
166
+ function invokeHandler(handler, vnode, event) {
167
+ if (typeof handler === "function") {
168
+ // call function handler
169
+ handler.call(vnode, event, vnode);
170
+ }
171
+ else if (typeof handler === "object") {
172
+ // call handler with arguments
173
+ if (typeof handler[0] === "function") {
174
+ // special case for single argument for performance
175
+ if (handler.length === 2) {
176
+ handler[0].call(vnode, handler[1], event, vnode);
177
+ }
178
+ else {
179
+ var args = handler.slice(1);
180
+ args.push(event);
181
+ args.push(vnode);
182
+ handler[0].apply(vnode, args);
183
+ }
184
+ }
185
+ else {
186
+ // call multiple handlers
187
+ for (var i = 0; i < handler.length; i++) {
188
+ invokeHandler(handler[i], vnode, event);
189
+ }
190
+ }
191
+ }
192
+ }
193
+ function handleEvent(event, vnode) {
194
+ var name = event.type, on = vnode.data.on;
195
+ // call event handler(s) if exists
196
+ if (on && on[name]) {
197
+ invokeHandler(on[name], vnode, event);
198
+ }
199
+ }
200
+ function createListener() {
201
+ return function handler(event) {
202
+ handleEvent(event, handler.vnode);
203
+ };
204
+ }
205
+ function updateEventListeners(oldVnode, vnode) {
206
+ var oldOn = oldVnode.data.on, oldListener = oldVnode.listener, oldElm = oldVnode.elm, on = vnode && vnode.data.on, elm = (vnode && vnode.elm), name;
207
+ // optimization for reused immutable handlers
208
+ if (oldOn === on) {
209
+ return;
210
+ }
211
+ // remove existing listeners which no longer used
212
+ if (oldOn && oldListener) {
213
+ // if element changed or deleted we remove all existing listeners unconditionally
214
+ if (!on) {
215
+ for (name in oldOn) {
216
+ // remove listener if element was changed or existing listeners removed
217
+ oldElm.removeEventListener(name, oldListener, false);
218
+ }
219
+ }
220
+ else {
221
+ for (name in oldOn) {
222
+ // remove listener if existing listener removed
223
+ if (!on[name]) {
224
+ oldElm.removeEventListener(name, oldListener, false);
225
+ }
226
+ }
227
+ }
228
+ }
229
+ // add new listeners which has not already attached
230
+ if (on) {
231
+ // reuse existing listener or create new
232
+ var listener = vnode.listener = oldVnode.listener || createListener();
233
+ // update vnode for listener
234
+ listener.vnode = vnode;
235
+ // if element changed or added we add all needed listeners unconditionally
236
+ if (!oldOn) {
237
+ for (name in on) {
238
+ // add listener if element was changed or new listeners added
239
+ elm.addEventListener(name, listener, false);
240
+ }
241
+ }
242
+ else {
243
+ for (name in on) {
244
+ // add listener if new listener added
245
+ if (!oldOn[name]) {
246
+ elm.addEventListener(name, listener, false);
247
+ }
248
+ }
249
+ }
250
+ }
251
+ }
252
+ exports.eventListenersModule = {
253
+ create: updateEventListeners,
254
+ update: updateEventListeners,
255
+ destroy: updateEventListeners
256
+ };
257
+ exports.default = exports.eventListenersModule;
258
+
259
+ },{}],6:[function(require,module,exports){
260
+ "use strict";
261
+ Object.defineProperty(exports, "__esModule", { value: true });
262
+ function updateProps(oldVnode, vnode) {
263
+ var key, cur, old, elm = vnode.elm, oldProps = oldVnode.data.props, props = vnode.data.props;
264
+ if (!oldProps && !props)
265
+ return;
266
+ if (oldProps === props)
267
+ return;
268
+ oldProps = oldProps || {};
269
+ props = props || {};
270
+ for (key in oldProps) {
271
+ if (!props[key]) {
272
+ delete elm[key];
273
+ }
274
+ }
275
+ for (key in props) {
276
+ cur = props[key];
277
+ old = oldProps[key];
278
+ if (old !== cur && (key !== 'value' || elm[key] !== cur)) {
279
+ elm[key] = cur;
280
+ }
281
+ }
282
+ }
283
+ exports.propsModule = { create: updateProps, update: updateProps };
284
+ exports.default = exports.propsModule;
285
+
286
+ },{}],7:[function(require,module,exports){
287
+ "use strict";
288
+ Object.defineProperty(exports, "__esModule", { value: true });
289
+ // Bindig `requestAnimationFrame` like this fixes a bug in IE/Edge. See #360 and #409.
290
+ var raf = (typeof window !== 'undefined' && (window.requestAnimationFrame).bind(window)) || setTimeout;
291
+ var nextFrame = function (fn) { raf(function () { raf(fn); }); };
292
+ var reflowForced = false;
293
+ function setNextFrame(obj, prop, val) {
294
+ nextFrame(function () { obj[prop] = val; });
295
+ }
296
+ function updateStyle(oldVnode, vnode) {
297
+ var cur, name, elm = vnode.elm, oldStyle = oldVnode.data.style, style = vnode.data.style;
298
+ if (!oldStyle && !style)
299
+ return;
300
+ if (oldStyle === style)
301
+ return;
302
+ oldStyle = oldStyle || {};
303
+ style = style || {};
304
+ var oldHasDel = 'delayed' in oldStyle;
305
+ for (name in oldStyle) {
306
+ if (!style[name]) {
307
+ if (name[0] === '-' && name[1] === '-') {
308
+ elm.style.removeProperty(name);
309
+ }
310
+ else {
311
+ elm.style[name] = '';
312
+ }
313
+ }
314
+ }
315
+ for (name in style) {
316
+ cur = style[name];
317
+ if (name === 'delayed' && style.delayed) {
318
+ for (var name2 in style.delayed) {
319
+ cur = style.delayed[name2];
320
+ if (!oldHasDel || cur !== oldStyle.delayed[name2]) {
321
+ setNextFrame(elm.style, name2, cur);
322
+ }
323
+ }
324
+ }
325
+ else if (name !== 'remove' && cur !== oldStyle[name]) {
326
+ if (name[0] === '-' && name[1] === '-') {
327
+ elm.style.setProperty(name, cur);
328
+ }
329
+ else {
330
+ elm.style[name] = cur;
331
+ }
332
+ }
333
+ }
334
+ }
335
+ function applyDestroyStyle(vnode) {
336
+ var style, name, elm = vnode.elm, s = vnode.data.style;
337
+ if (!s || !(style = s.destroy))
338
+ return;
339
+ for (name in style) {
340
+ elm.style[name] = style[name];
341
+ }
342
+ }
343
+ function applyRemoveStyle(vnode, rm) {
344
+ var s = vnode.data.style;
345
+ if (!s || !s.remove) {
346
+ rm();
347
+ return;
348
+ }
349
+ if (!reflowForced) {
350
+ getComputedStyle(document.body).transform;
351
+ reflowForced = true;
352
+ }
353
+ var name, elm = vnode.elm, i = 0, compStyle, style = s.remove, amount = 0, applied = [];
354
+ for (name in style) {
355
+ applied.push(name);
356
+ elm.style[name] = style[name];
357
+ }
358
+ compStyle = getComputedStyle(elm);
359
+ var props = compStyle['transition-property'].split(', ');
360
+ for (; i < props.length; ++i) {
361
+ if (applied.indexOf(props[i]) !== -1)
362
+ amount++;
363
+ }
364
+ elm.addEventListener('transitionend', function (ev) {
365
+ if (ev.target === elm)
366
+ --amount;
367
+ if (amount === 0)
368
+ rm();
369
+ });
370
+ }
371
+ function forceReflow() {
372
+ reflowForced = false;
373
+ }
374
+ exports.styleModule = {
375
+ pre: forceReflow,
376
+ create: updateStyle,
377
+ update: updateStyle,
378
+ destroy: applyDestroyStyle,
379
+ remove: applyRemoveStyle
380
+ };
381
+ exports.default = exports.styleModule;
382
+
383
+ },{}],8:[function(require,module,exports){
384
+ "use strict";
385
+ Object.defineProperty(exports, "__esModule", { value: true });
386
+ var vnode_1 = require("./vnode");
387
+ var is = require("./is");
388
+ var htmldomapi_1 = require("./htmldomapi");
389
+ function isUndef(s) { return s === undefined; }
390
+ function isDef(s) { return s !== undefined; }
391
+ var emptyNode = vnode_1.default('', {}, [], undefined, undefined);
392
+ function sameVnode(vnode1, vnode2) {
393
+ return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel;
394
+ }
395
+ function isVnode(vnode) {
396
+ return vnode.sel !== undefined;
397
+ }
398
+ function createKeyToOldIdx(children, beginIdx, endIdx) {
399
+ var i, map = {}, key, ch;
400
+ for (i = beginIdx; i <= endIdx; ++i) {
401
+ ch = children[i];
402
+ if (ch != null) {
403
+ key = ch.key;
404
+ if (key !== undefined)
405
+ map[key] = i;
406
+ }
407
+ }
408
+ return map;
409
+ }
410
+ var hooks = ['create', 'update', 'remove', 'destroy', 'pre', 'post'];
411
+ var h_1 = require("./h");
412
+ exports.h = h_1.h;
413
+ var thunk_1 = require("./thunk");
414
+ exports.thunk = thunk_1.thunk;
415
+ function init(modules, domApi) {
416
+ var i, j, cbs = {};
417
+ var api = domApi !== undefined ? domApi : htmldomapi_1.default;
418
+ for (i = 0; i < hooks.length; ++i) {
419
+ cbs[hooks[i]] = [];
420
+ for (j = 0; j < modules.length; ++j) {
421
+ var hook = modules[j][hooks[i]];
422
+ if (hook !== undefined) {
423
+ cbs[hooks[i]].push(hook);
424
+ }
425
+ }
426
+ }
427
+ function emptyNodeAt(elm) {
428
+ var id = elm.id ? '#' + elm.id : '';
429
+ var c = elm.className ? '.' + elm.className.split(' ').join('.') : '';
430
+ return vnode_1.default(api.tagName(elm).toLowerCase() + id + c, {}, [], undefined, elm);
431
+ }
432
+ function createRmCb(childElm, listeners) {
433
+ return function rmCb() {
434
+ if (--listeners === 0) {
435
+ var parent_1 = api.parentNode(childElm);
436
+ api.removeChild(parent_1, childElm);
437
+ }
438
+ };
439
+ }
440
+ function createElm(vnode, insertedVnodeQueue) {
441
+ var i, data = vnode.data;
442
+ if (data !== undefined) {
443
+ if (isDef(i = data.hook) && isDef(i = i.init)) {
444
+ i(vnode);
445
+ data = vnode.data;
446
+ }
447
+ }
448
+ var children = vnode.children, sel = vnode.sel;
449
+ if (sel === '!') {
450
+ if (isUndef(vnode.text)) {
451
+ vnode.text = '';
452
+ }
453
+ vnode.elm = api.createComment(vnode.text);
454
+ }
455
+ else if (sel !== undefined) {
456
+ // Parse selector
457
+ var hashIdx = sel.indexOf('#');
458
+ var dotIdx = sel.indexOf('.', hashIdx);
459
+ var hash = hashIdx > 0 ? hashIdx : sel.length;
460
+ var dot = dotIdx > 0 ? dotIdx : sel.length;
461
+ var tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel;
462
+ var elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? api.createElementNS(i, tag)
463
+ : api.createElement(tag);
464
+ if (hash < dot)
465
+ elm.setAttribute('id', sel.slice(hash + 1, dot));
466
+ if (dotIdx > 0)
467
+ elm.setAttribute('class', sel.slice(dot + 1).replace(/\./g, ' '));
468
+ for (i = 0; i < cbs.create.length; ++i)
469
+ cbs.create[i](emptyNode, vnode);
470
+ if (is.array(children)) {
471
+ for (i = 0; i < children.length; ++i) {
472
+ var ch = children[i];
473
+ if (ch != null) {
474
+ api.appendChild(elm, createElm(ch, insertedVnodeQueue));
475
+ }
476
+ }
477
+ }
478
+ else if (is.primitive(vnode.text)) {
479
+ api.appendChild(elm, api.createTextNode(vnode.text));
480
+ }
481
+ i = vnode.data.hook; // Reuse variable
482
+ if (isDef(i)) {
483
+ if (i.create)
484
+ i.create(emptyNode, vnode);
485
+ if (i.insert)
486
+ insertedVnodeQueue.push(vnode);
487
+ }
488
+ }
489
+ else {
490
+ vnode.elm = api.createTextNode(vnode.text);
491
+ }
492
+ return vnode.elm;
493
+ }
494
+ function addVnodes(parentElm, before, vnodes, startIdx, endIdx, insertedVnodeQueue) {
495
+ for (; startIdx <= endIdx; ++startIdx) {
496
+ var ch = vnodes[startIdx];
497
+ if (ch != null) {
498
+ api.insertBefore(parentElm, createElm(ch, insertedVnodeQueue), before);
499
+ }
500
+ }
501
+ }
502
+ function invokeDestroyHook(vnode) {
503
+ var i, j, data = vnode.data;
504
+ if (data !== undefined) {
505
+ if (isDef(i = data.hook) && isDef(i = i.destroy))
506
+ i(vnode);
507
+ for (i = 0; i < cbs.destroy.length; ++i)
508
+ cbs.destroy[i](vnode);
509
+ if (vnode.children !== undefined) {
510
+ for (j = 0; j < vnode.children.length; ++j) {
511
+ i = vnode.children[j];
512
+ if (i != null && typeof i !== "string") {
513
+ invokeDestroyHook(i);
514
+ }
515
+ }
516
+ }
517
+ }
518
+ }
519
+ function removeVnodes(parentElm, vnodes, startIdx, endIdx) {
520
+ for (; startIdx <= endIdx; ++startIdx) {
521
+ var i_1 = void 0, listeners = void 0, rm = void 0, ch = vnodes[startIdx];
522
+ if (ch != null) {
523
+ if (isDef(ch.sel)) {
524
+ invokeDestroyHook(ch);
525
+ listeners = cbs.remove.length + 1;
526
+ rm = createRmCb(ch.elm, listeners);
527
+ for (i_1 = 0; i_1 < cbs.remove.length; ++i_1)
528
+ cbs.remove[i_1](ch, rm);
529
+ if (isDef(i_1 = ch.data) && isDef(i_1 = i_1.hook) && isDef(i_1 = i_1.remove)) {
530
+ i_1(ch, rm);
531
+ }
532
+ else {
533
+ rm();
534
+ }
535
+ }
536
+ else {
537
+ api.removeChild(parentElm, ch.elm);
538
+ }
539
+ }
540
+ }
541
+ }
542
+ function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue) {
543
+ var oldStartIdx = 0, newStartIdx = 0;
544
+ var oldEndIdx = oldCh.length - 1;
545
+ var oldStartVnode = oldCh[0];
546
+ var oldEndVnode = oldCh[oldEndIdx];
547
+ var newEndIdx = newCh.length - 1;
548
+ var newStartVnode = newCh[0];
549
+ var newEndVnode = newCh[newEndIdx];
550
+ var oldKeyToIdx;
551
+ var idxInOld;
552
+ var elmToMove;
553
+ var before;
554
+ while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
555
+ if (oldStartVnode == null) {
556
+ oldStartVnode = oldCh[++oldStartIdx]; // Vnode might have been moved left
557
+ }
558
+ else if (oldEndVnode == null) {
559
+ oldEndVnode = oldCh[--oldEndIdx];
560
+ }
561
+ else if (newStartVnode == null) {
562
+ newStartVnode = newCh[++newStartIdx];
563
+ }
564
+ else if (newEndVnode == null) {
565
+ newEndVnode = newCh[--newEndIdx];
566
+ }
567
+ else if (sameVnode(oldStartVnode, newStartVnode)) {
568
+ patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue);
569
+ oldStartVnode = oldCh[++oldStartIdx];
570
+ newStartVnode = newCh[++newStartIdx];
571
+ }
572
+ else if (sameVnode(oldEndVnode, newEndVnode)) {
573
+ patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);
574
+ oldEndVnode = oldCh[--oldEndIdx];
575
+ newEndVnode = newCh[--newEndIdx];
576
+ }
577
+ else if (sameVnode(oldStartVnode, newEndVnode)) {
578
+ patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);
579
+ api.insertBefore(parentElm, oldStartVnode.elm, api.nextSibling(oldEndVnode.elm));
580
+ oldStartVnode = oldCh[++oldStartIdx];
581
+ newEndVnode = newCh[--newEndIdx];
582
+ }
583
+ else if (sameVnode(oldEndVnode, newStartVnode)) {
584
+ patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);
585
+ api.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
586
+ oldEndVnode = oldCh[--oldEndIdx];
587
+ newStartVnode = newCh[++newStartIdx];
588
+ }
589
+ else {
590
+ if (oldKeyToIdx === undefined) {
591
+ oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
592
+ }
593
+ idxInOld = oldKeyToIdx[newStartVnode.key];
594
+ if (isUndef(idxInOld)) {
595
+ api.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm);
596
+ newStartVnode = newCh[++newStartIdx];
597
+ }
598
+ else {
599
+ elmToMove = oldCh[idxInOld];
600
+ if (elmToMove.sel !== newStartVnode.sel) {
601
+ api.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm);
602
+ }
603
+ else {
604
+ patchVnode(elmToMove, newStartVnode, insertedVnodeQueue);
605
+ oldCh[idxInOld] = undefined;
606
+ api.insertBefore(parentElm, elmToMove.elm, oldStartVnode.elm);
607
+ }
608
+ newStartVnode = newCh[++newStartIdx];
609
+ }
610
+ }
611
+ }
612
+ if (oldStartIdx <= oldEndIdx || newStartIdx <= newEndIdx) {
613
+ if (oldStartIdx > oldEndIdx) {
614
+ before = newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].elm;
615
+ addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
616
+ }
617
+ else {
618
+ removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);
619
+ }
620
+ }
621
+ }
622
+ function patchVnode(oldVnode, vnode, insertedVnodeQueue) {
623
+ var i, hook;
624
+ if (isDef(i = vnode.data) && isDef(hook = i.hook) && isDef(i = hook.prepatch)) {
625
+ i(oldVnode, vnode);
626
+ }
627
+ var elm = vnode.elm = oldVnode.elm;
628
+ var oldCh = oldVnode.children;
629
+ var ch = vnode.children;
630
+ if (oldVnode === vnode)
631
+ return;
632
+ if (vnode.data !== undefined) {
633
+ for (i = 0; i < cbs.update.length; ++i)
634
+ cbs.update[i](oldVnode, vnode);
635
+ i = vnode.data.hook;
636
+ if (isDef(i) && isDef(i = i.update))
637
+ i(oldVnode, vnode);
638
+ }
639
+ if (isUndef(vnode.text)) {
640
+ if (isDef(oldCh) && isDef(ch)) {
641
+ if (oldCh !== ch)
642
+ updateChildren(elm, oldCh, ch, insertedVnodeQueue);
643
+ }
644
+ else if (isDef(ch)) {
645
+ if (isDef(oldVnode.text))
646
+ api.setTextContent(elm, '');
647
+ addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
648
+ }
649
+ else if (isDef(oldCh)) {
650
+ removeVnodes(elm, oldCh, 0, oldCh.length - 1);
651
+ }
652
+ else if (isDef(oldVnode.text)) {
653
+ api.setTextContent(elm, '');
654
+ }
655
+ }
656
+ else if (oldVnode.text !== vnode.text) {
657
+ if (isDef(oldCh)) {
658
+ removeVnodes(elm, oldCh, 0, oldCh.length - 1);
659
+ }
660
+ api.setTextContent(elm, vnode.text);
661
+ }
662
+ if (isDef(hook) && isDef(i = hook.postpatch)) {
663
+ i(oldVnode, vnode);
664
+ }
665
+ }
666
+ return function patch(oldVnode, vnode) {
667
+ var i, elm, parent;
668
+ var insertedVnodeQueue = [];
669
+ for (i = 0; i < cbs.pre.length; ++i)
670
+ cbs.pre[i]();
671
+ if (!isVnode(oldVnode)) {
672
+ oldVnode = emptyNodeAt(oldVnode);
673
+ }
674
+ if (sameVnode(oldVnode, vnode)) {
675
+ patchVnode(oldVnode, vnode, insertedVnodeQueue);
676
+ }
677
+ else {
678
+ elm = oldVnode.elm;
679
+ parent = api.parentNode(elm);
680
+ createElm(vnode, insertedVnodeQueue);
681
+ if (parent !== null) {
682
+ api.insertBefore(parent, vnode.elm, api.nextSibling(elm));
683
+ removeVnodes(parent, [oldVnode], 0, 0);
684
+ }
685
+ }
686
+ for (i = 0; i < insertedVnodeQueue.length; ++i) {
687
+ insertedVnodeQueue[i].data.hook.insert(insertedVnodeQueue[i]);
688
+ }
689
+ for (i = 0; i < cbs.post.length; ++i)
690
+ cbs.post[i]();
691
+ return vnode;
692
+ };
693
+ }
694
+ exports.init = init;
695
+
696
+ },{"./h":1,"./htmldomapi":2,"./is":3,"./thunk":9,"./vnode":10}],9:[function(require,module,exports){
697
+ "use strict";
698
+ Object.defineProperty(exports, "__esModule", { value: true });
699
+ var h_1 = require("./h");
700
+ function copyToThunk(vnode, thunk) {
701
+ thunk.elm = vnode.elm;
702
+ vnode.data.fn = thunk.data.fn;
703
+ vnode.data.args = thunk.data.args;
704
+ thunk.data = vnode.data;
705
+ thunk.children = vnode.children;
706
+ thunk.text = vnode.text;
707
+ thunk.elm = vnode.elm;
708
+ }
709
+ function init(thunk) {
710
+ var cur = thunk.data;
711
+ var vnode = cur.fn.apply(undefined, cur.args);
712
+ copyToThunk(vnode, thunk);
713
+ }
714
+ function prepatch(oldVnode, thunk) {
715
+ var i, old = oldVnode.data, cur = thunk.data;
716
+ var oldArgs = old.args, args = cur.args;
717
+ if (old.fn !== cur.fn || oldArgs.length !== args.length) {
718
+ copyToThunk(cur.fn.apply(undefined, args), thunk);
719
+ return;
720
+ }
721
+ for (i = 0; i < args.length; ++i) {
722
+ if (oldArgs[i] !== args[i]) {
723
+ copyToThunk(cur.fn.apply(undefined, args), thunk);
724
+ return;
725
+ }
726
+ }
727
+ copyToThunk(oldVnode, thunk);
728
+ }
729
+ exports.thunk = function thunk(sel, key, fn, args) {
730
+ if (args === undefined) {
731
+ args = fn;
732
+ fn = key;
733
+ key = undefined;
734
+ }
735
+ return h_1.h(sel, {
736
+ key: key,
737
+ hook: { init: init, prepatch: prepatch },
738
+ fn: fn,
739
+ args: args
740
+ });
741
+ };
742
+ exports.default = exports.thunk;
743
+
744
+ },{"./h":1}],10:[function(require,module,exports){
745
+ "use strict";
746
+ Object.defineProperty(exports, "__esModule", { value: true });
747
+ function vnode(sel, data, children, text, elm) {
748
+ var key = data === undefined ? undefined : data.key;
749
+ return { sel: sel, data: data, children: children,
750
+ text: text, elm: elm, key: key };
751
+ }
752
+ exports.vnode = vnode;
753
+ exports.default = vnode;
754
+
755
+ },{}],11:[function(require,module,exports){
756
+ var snabbdom = require('snabbdom');
757
+ var patch = snabbdom.init([
758
+ require('snabbdom/modules/class').default,
759
+ require('snabbdom/modules/props').default,
760
+ require('snabbdom/modules/style').default,
761
+ require('snabbdom/modules/eventlisteners').default,
762
+ ]);
763
+ snabbdom_h = require('snabbdom/h').default;
764
+
765
+ function stringifyEvent(e) {
766
+ const obj = {};
767
+ for (let k in e) {
768
+ obj[k] = e[k];
769
+ }
770
+ return JSON.stringify(obj, (k, v) => {
771
+ if (v instanceof Node) return 'Node';
772
+ if (v instanceof Window) return 'Window';
773
+ return v;
774
+ }, ' ');
775
+ }
776
+
777
+ const events = new Map();
778
+ let eventId = -1;
779
+
780
+ function getEventId(event) {
781
+ const id = (eventId++).toString();
782
+
783
+ events.set(id, event);
784
+
785
+ return id;
786
+ }
787
+
788
+ function preventDefault(id) {
789
+ const event = events.get(id);
790
+
791
+ if (event) {
792
+ event.preventDefault();
793
+ } else {
794
+ throw new Error(`Tried to prevent default on event with id ${eventId} but was not found`);
795
+ }
796
+ }
797
+
798
+ function rubyVTreeToSnabbdom(rvtree) {
799
+ if (rvtree.type === "text") { return rvtree.content; }
800
+
801
+ let options = {};
802
+
803
+ for (let key in rvtree) {
804
+ if (key === "_children") { continue; }
805
+ if (key === "_type") { continue; }
806
+ if (key === "_class") { continue; }
807
+ if (key === "onClick") { continue; }
808
+ if (key === "onKeydown") { continue; }
809
+ if (key === "onInput") { continue; }
810
+
811
+ options[key] = rvtree[key];
812
+ }
813
+
814
+ if (options.on) {
815
+ for (let key in options.on) {
816
+ var handler = options.on[key];
817
+
818
+ options.on[key] = function(event) {
819
+ if (handler.prevent_default) {
820
+ event.preventDefault();
821
+ }
822
+
823
+ if (handler.stop_propagation) {
824
+ event.stopPropagation();
825
+ }
826
+
827
+ let args = [];
828
+
829
+ for (let arg of handler.args) {
830
+ if (arg.type === "constant") {
831
+ args.push(arg.value);
832
+ }
833
+
834
+ if (arg.type === "event_data") {
835
+ args.push(event[arg.key]);
836
+ }
837
+
838
+ if (arg.type === "target_data") {
839
+ args.push(event.target[arg.key]);
840
+ }
841
+ }
842
+
843
+ var handlerWithArgs = Object.assign(
844
+ {},
845
+ handler,
846
+ {args}
847
+ );
848
+
849
+ if (handlerWithArgs.type) {
850
+ Module.ccall("dispatch", "void", ["string"], [JSON.stringify(handlerWithArgs)]);
851
+ }
852
+ render();
853
+ }
854
+ }
855
+ }
856
+
857
+ return snabbdom_h(
858
+ rvtree._type + (rvtree._class || ""),
859
+ options,
860
+ (rvtree._children || []).map(rubyVTreeToSnabbdom)
861
+ );
862
+ }
863
+
864
+ var currentContainer = document.getElementById('root');
865
+
866
+ function render() {
867
+ const rvtree = JSON.parse(Module.ccall("render", "string", []));
868
+ const vtree = rubyVTreeToSnabbdom(rvtree);
869
+
870
+ patch(currentContainer, vtree);
871
+
872
+ currentContainer = vtree;
873
+ }
874
+
875
+ window.Module = {
876
+ preRun: [],
877
+ postRun: [ render ],
878
+ print: function() {
879
+ return function(e) {
880
+ 1 < arguments.length && (e = Array.prototype.slice.call(arguments).join(" ")), console.log(e)
881
+ }
882
+ }(),
883
+ printErr: function(e) {
884
+ 1 < arguments.length && (e = Array.prototype.slice.call(arguments).join(" ")), console.error(e)
885
+ },
886
+ canvas: function() {}(),
887
+ setStatus: function() {},
888
+ totalDependencies: 0,
889
+ monitorRunDependencies: function(e) {}
890
+ };
891
+
892
+
893
+ },{"snabbdom":8,"snabbdom/h":1,"snabbdom/modules/class":4,"snabbdom/modules/eventlisteners":5,"snabbdom/modules/props":6,"snabbdom/modules/style":7}]},{},[11]);