isomorfeus-preact 10.6.19 → 10.6.23

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: dcabd6672c23dfd3a4eaf10b565b032522c1f0d352778e2d92366a24061b8d97
4
- data.tar.gz: 0bb1045aa576165352bf122f510eb3e94cffa6ea277008ab3a0c835502331e88
3
+ metadata.gz: e8b133ab120af42dff909afe3fd478174cd0ff2414a73b8d1281cfdde3e5d333
4
+ data.tar.gz: 681651aa16c14f38d2e0fa45a5fff880a4513bc5bff3f59acb88fadf0fc3279d
5
5
  SHA512:
6
- metadata.gz: 2c478adf7ffcfab21bb7ba74ca6c109bdb4ec257ba830ba7bafbd91b1f12e2e50b427cf57dfd78b50570ca788630e539e1203ada466af987dcc23e5caf0aa9e9
7
- data.tar.gz: eb945769548e040115bca58246c94625dec9bb68e585bc1fd9268ebcc58c26d6894a72816d4d4ceea751e881a7933418bca067c867ea4e8ff92c342adffb30a5
6
+ metadata.gz: e881c1b2d966629ff7ce355387ebaa43f05d9e89f73a513e09f0da1721143ec4370141f7c1679c50363794be974632f13ff92a1377883094459329ad9873f9e1
7
+ data.tar.gz: 6857773386b43ddb122e7045d2cfc07fa06375b59597e7e51d6860ba26e841ececee6b7ae44b8713c3a72eff35678071b7d03c4bae38fee73d7475b90b3a2e25
@@ -41,6 +41,8 @@ module Isomorfeus
41
41
  end
42
42
  end
43
43
 
44
+ start_time = Time.now if Isomorfeus.development?
45
+ pass = 1
44
46
  # if location_host and scheme are given and if Transport is loaded, connect and then render,
45
47
  # otherwise do not render because only one pass is required
46
48
  ws_scheme = props[:location_scheme] == 'https:' ? 'wss:' : 'ws:'
@@ -88,6 +90,7 @@ module Isomorfeus
88
90
  end
89
91
  # wait for first pass to finish
90
92
  unless first_pass_skipped
93
+ pass += 1
91
94
  first_pass_finished, exception = Isomorfeus.ssr_contexts[thread_id_asset].exec('return [global.FirstPassFinished, global.Exception ? { message: global.Exception.message, stack: global.Exception.stack } : false ]')
92
95
  Isomorfeus.raise_error(message: "Server Side Rendering: #{exception['message']}", stack: exception['stack']) if exception
93
96
  unless first_pass_finished
@@ -104,7 +107,7 @@ module Isomorfeus
104
107
  if transport_busy
105
108
  start_time = Time.now
106
109
  while transport_busy
107
- break if (Time.now - start_time) > 10
110
+ break if (Time.now - start_time) > 5
108
111
  sleep 0.01
109
112
  transport_busy = Isomorfeus.ssr_contexts[thread_id_asset].exec('return global.Opal.Isomorfeus.Transport["$busy?"]()')
110
113
  end
@@ -127,12 +130,31 @@ module Isomorfeus
127
130
  global.Exception = e;
128
131
  }
129
132
  let application_state = global.Opal.Isomorfeus.store.native.getState();
130
- if (typeof global.Opal.Isomorfeus.Transport !== 'undefined') { global.Opal.Isomorfeus.Transport.$disconnect(); }
133
+ let transport_busy = false;
134
+ if (typeof global.Opal.Isomorfeus.Transport !== 'undefined' && global.Opal.Isomorfeus.Transport["$busy?"]()) { transport_busy = true; }
131
135
  if (typeof global.NanoCSSInstance !== 'undefined') { ssr_styles = global.NanoCSSInstance.raw }
132
- return [rendered_tree, application_state, ssr_styles, global.Opal.Isomorfeus['$ssr_response_status'](), global.Exception ? { message: global.Exception.message, stack: global.Exception.stack } : false];
136
+ return [rendered_tree, application_state, ssr_styles, global.Opal.Isomorfeus['$ssr_response_status'](), transport_busy, global.Exception ? { message: global.Exception.message, stack: global.Exception.stack } : false];
137
+ JAVASCRIPT
138
+ # execute further render passes
139
+ rendered_tree, application_state, @ssr_styles, @ssr_response_status, transport_busy, exception = Isomorfeus.ssr_contexts[thread_id_asset].exec(javascript)
140
+ break_while = false
141
+ start_time = Time.now
142
+ while transport_busy
143
+ break if (Time.now - start_time) > 5
144
+ while transport_busy
145
+ break if (Time.now - start_time) > 4
146
+ sleep 0.01
147
+ transport_busy = Isomorfeus.ssr_contexts[thread_id_asset].exec('return global.Opal.Isomorfeus.Transport["$busy?"]()')
148
+ end
149
+ # execute third render pass
150
+ pass += 1
151
+ rendered_tree, application_state, @ssr_styles, @ssr_response_status, transport_busy, exception = Isomorfeus.ssr_contexts[thread_id_asset].exec(javascript)
152
+ break if break_while || pass > 5
153
+ end
154
+ javascript = <<~JAVASCRIPT
155
+ if (typeof global.Opal.Isomorfeus.Transport !== 'undefined') { global.Opal.Isomorfeus.Transport.$disconnect(); }
133
156
  JAVASCRIPT
134
- # execute second render pass
135
- rendered_tree, application_state, @ssr_styles, @ssr_response_status, exception = Isomorfeus.ssr_contexts[thread_id_asset].exec(javascript)
157
+ Isomorfeus.ssr_contexts[thread_id_asset].exec(javascript)
136
158
  Isomorfeus.raise_error(message: exception['message'], stack: exception['stack']) if exception
137
159
  render_result << " data-iso-hydrated='true'" if rendered_tree
138
160
  if Isomorfeus.respond_to?(:current_user) && Isomorfeus.current_user && !Isomorfeus.current_user.anonymous?
@@ -150,6 +172,7 @@ module Isomorfeus
150
172
  if Isomorfeus.server_side_rendering
151
173
  render_result = "<script type='application/javascript'>\nServerSideRenderingStateJSON = #{Oj.dump(application_state, mode: :strict)}\n</script>\n" << render_result
152
174
  end
175
+ STDERR.puts "PreactViewHelper Server Side Rendering rendered #{pass} passes and took ~#{Time.now - start_time}s" if Isomorfeus.development?
153
176
  render_result
154
177
  end
155
178
 
@@ -33,9 +33,12 @@ module LucidApp
33
33
  var defined_refs = #{base.defined_refs};
34
34
  for (var ref in defined_refs) {
35
35
  if (defined_refs[ref] != null) {
36
+ let r = ref; // to ensure closure for function below gets correct ref name
36
37
  this[ref] = function(element) {
37
38
  element = oper.native_element_or_component_to_ruby(element);
38
- #{`this.__ruby_instance`.instance_exec(`element`, &`defined_refs[ref]`)}
39
+ oper.register_active_component(this);
40
+ #{`this.__ruby_instance`.instance_exec(`element`, &`defined_refs[r]`)}
41
+ oper.unregister_active_component(this);
39
42
  }
40
43
  this[ref] = this[ref].bind(this);
41
44
  } else {
@@ -43,9 +46,9 @@ module LucidApp
43
46
  }
44
47
  }
45
48
  if (base.preload_block) {
46
- oper.active_redux_components.push(this);
49
+ oper.register_active_component(this);
47
50
  this.state.preloaded = this.__ruby_instance.$execute_preload_block();
48
- oper.active_redux_components.pop();
51
+ oper.unregister_active_component(this);
49
52
  }
50
53
  this.listener = this.listener.bind(this);
51
54
  this.unsubscriber = Opal.Isomorfeus.store.native.subscribe(this.listener);
@@ -56,17 +59,13 @@ module LucidApp
56
59
  render(props, state) {
57
60
  const oper = Opal.Preact;
58
61
  oper.render_buffer.push([]);
59
- // console.log("lucid app pushed", oper.render_buffer, oper.render_buffer.toString());
60
- oper.active_components.push(this);
61
- oper.active_redux_components.push(this);
62
+ oper.register_active_component(this);
62
63
  let block_result;
63
64
  if (base.while_loading_block && !state.preloaded) { block_result = #{`this.__ruby_instance`.instance_exec(&`base.while_loading_block`)}; }
64
65
  else { block_result = #{`this.__ruby_instance`.instance_exec(&`base.render_block`)}; }
65
66
  if (block_result && block_result !== nil) { oper.render_block_result(block_result); }
66
- oper.active_redux_components.pop();
67
- oper.active_components.pop();
67
+ oper.unregister_active_component(this);
68
68
  let children = oper.render_buffer.pop();
69
- // console.log("lucid app popping", oper.render_buffer, oper.render_buffer.toString());
70
69
  return Opal.global.Preact.createElement(Opal.global.LucidApplicationContext.Provider, { value: { iso_store: this.state.isomorfeus_store_state, iso_theme: base.css_theme }}, children);
71
70
  }
72
71
  data_access() {
@@ -29,9 +29,12 @@ module LucidComponent
29
29
  var defined_refs = base.$defined_refs();
30
30
  for (var ref in defined_refs) {
31
31
  if (defined_refs[ref] != null) {
32
+ let r = ref; // to ensure closure for function below gets correct ref name
32
33
  this[ref] = function(element) {
33
34
  element = oper.native_element_or_component_to_ruby(element);
34
- #{`this.__ruby_instance`.instance_exec(`element`, &`defined_refs[ref]`)}
35
+ oper.register_active_component(this);
36
+ #{`this.__ruby_instance`.instance_exec(`element`, &`defined_refs[r]`)}
37
+ oper.unregister_active_component(this);
35
38
  }
36
39
  this[ref] = this[ref].bind(this);
37
40
  } else {
@@ -39,9 +42,9 @@ module LucidComponent
39
42
  }
40
43
  }
41
44
  if (base.preload_block) {
42
- oper.active_redux_components.push(this);
45
+ oper.register_active_component(this);
43
46
  this.state.preloaded = this.__ruby_instance.$execute_preload_block();
44
- oper.active_redux_components.pop();
47
+ oper.unregister_active_component(this);
45
48
  }
46
49
  }
47
50
  static get displayName() {
@@ -50,16 +53,12 @@ module LucidComponent
50
53
  render(props, state) {
51
54
  const oper = Opal.Preact;
52
55
  oper.render_buffer.push([]);
53
- // console.log("lucid component pushed", oper.render_buffer, oper.render_buffer.toString());
54
- oper.active_components.push(this);
55
- oper.active_redux_components.push(this);
56
+ oper.register_active_component(this);
56
57
  let block_result;
57
58
  if (base.while_loading_block && !state.preloaded) { block_result = #{`this.__ruby_instance`.instance_exec(&`base.while_loading_block`)}; }
58
59
  else { block_result = #{`this.__ruby_instance`.instance_exec(&`base.render_block`)}; }
59
60
  if (block_result && block_result !== nil) { oper.render_block_result(block_result); }
60
- oper.active_redux_components.pop();
61
- oper.active_components.pop();
62
- // console.log("lucid component popping", oper.render_buffer, oper.render_buffer.toString());
61
+ oper.unregister_active_component(this);
63
62
  let result = oper.render_buffer.pop();
64
63
  return (result.length === 1) ? result[0] : result;
65
64
  }
@@ -23,12 +23,10 @@ module LucidFunc
23
23
  const [__ruby_state, __ruby_dispatch] = og.PreactHooks.useReducer(base.instance_reducer, null, base.instance_init);
24
24
  const __ruby_instance = __ruby_state.instance;
25
25
  __ruby_instance.props = Object.assign({}, props, context);
26
- oper.active_components.push(__ruby_instance);
27
- oper.active_redux_components.push(__ruby_instance);
26
+ oper.register_active_component(__ruby_instance);
28
27
  let block_result = #{`__ruby_instance`.instance_exec(&`base.render_block`)};
29
28
  if (block_result && block_result !== nil) { oper.render_block_result(block_result); }
30
- oper.active_redux_components.pop();
31
- oper.active_components.pop();
29
+ oper.unregister_active_component(__ruby_instance);
32
30
  // console.log("function popping", oper.render_buffer, oper.render_buffer.toString());
33
31
  let result = oper.render_buffer.pop();
34
32
  return (result.length === 1) ? result[0] : result;
@@ -13,15 +13,13 @@ module Preact
13
13
  base.preact_component = function(props) {
14
14
  const oper = Opal.Preact;
15
15
  oper.render_buffer.push([]);
16
- // console.log("function pushed", oper.render_buffer, oper.render_buffer.toString());
17
16
  const [__ruby_state, __ruby_dispatch] = Opal.global.PreactHooks.useReducer(base.instance_reducer, null, base.instance_init);
18
17
  const __ruby_instance = __ruby_state.instance;
19
18
  __ruby_instance.props = props;
20
- oper.active_components.push(__ruby_instance);
19
+ oper.register_active_component(__ruby_instance);
21
20
  let block_result = #{`__ruby_instance`.instance_exec(&`base.render_block`)};
22
21
  if (block_result && block_result !== nil) { oper.render_block_result(block_result); }
23
- oper.active_components.pop();
24
- // console.log("function popping", oper.render_buffer, oper.render_buffer.toString());
22
+ oper.unregister_active_component(__ruby_instance);
25
23
  let result = oper.render_buffer.pop();
26
24
  return (result.length === 1) ? result[0] : result;
27
25
  }
@@ -22,7 +22,7 @@ module Preact
22
22
  end
23
23
 
24
24
  def defined_refs
25
- @defined_ref ||= `{}`
25
+ @defined_refs ||= `{}`
26
26
  end
27
27
 
28
28
  def default_state_defined
@@ -7,9 +7,9 @@ module Preact
7
7
  # TODO convert error
8
8
  %x{
9
9
  var fun = function(error) {
10
- Opal.Preact.active_redux_components.push(this);
10
+ Opal.Preact.register_active_component(this);
11
11
  #{`this.__ruby_instance`.instance_exec(`error`, &block)};
12
- Opal.Preact.active_redux_components.pop();
12
+ Opal.Preact.unregister_active_component(this);
13
13
  }
14
14
  if (self.lucid_preact_component) { self.lucid_preact_component.prototype.componentDidCatch = fun; }
15
15
  else { self.preact_component.prototype.componentDidCatch = fun; }
@@ -19,9 +19,9 @@ module Preact
19
19
  def component_did_mount(&block)
20
20
  %x{
21
21
  let fun = function() {
22
- Opal.Preact.active_redux_components.push(this);
22
+ Opal.Preact.register_active_component(this);
23
23
  #{`this.__ruby_instance`.instance_exec(&block)};
24
- Opal.Preact.active_redux_components.pop();
24
+ Opal.Preact.unregister_active_component(this);
25
25
  }
26
26
  if (self.lucid_preact_component) {
27
27
  if (self.lucid_preact_component.prototype.componentDidMount) {
@@ -40,11 +40,11 @@ module Preact
40
40
  def component_did_update(&block)
41
41
  %x{
42
42
  var fun = function(prev_props, prev_state, snapshot) {
43
- Opal.Preact.active_redux_components.push(this);
43
+ Opal.Preact.register_active_component(this);
44
44
  #{`this.__ruby_instance`.instance_exec(`Opal.Preact.Props.$new({props: prev_props})`,
45
45
  `Opal.Preact.State.$new({state: prev_state})`,
46
46
  `snapshot`, &block)};
47
- Opal.Preact.active_redux_components.pop();
47
+ Opal.Preact.unregister_active_component(this);
48
48
  }
49
49
  if (self.lucid_preact_component) { self.lucid_preact_component.prototype.componentDidUpdate = fun; }
50
50
  else { self.preact_component.prototype.componentDidUpdate = fun; }
@@ -55,9 +55,9 @@ module Preact
55
55
  %x{
56
56
  var fun = function() {
57
57
  if (typeof this.unsubscriber === "function") { this.unsubscriber(); };
58
- Opal.Preact.active_redux_components.push(this);
58
+ Opal.Preact.register_active_component(this);
59
59
  #{`this.__ruby_instance`.instance_exec(&block)};
60
- Opal.Preact.active_redux_components.pop();
60
+ Opal.Preact.unregister_active_component(this);
61
61
  }
62
62
  if (self.lucid_preact_component) { self.lucid_preact_component.prototype.componentWillUnmount = fun; }
63
63
  else { self.preact_component.prototype.componentWillUnmount = fun; }
@@ -68,12 +68,12 @@ module Preact
68
68
  def get_derived_state_from_props(&block)
69
69
  %x{
70
70
  var fun = function(props, state) {
71
- Opal.Preact.active_redux_components.push(this);
71
+ Opal.Preact.register_active_component(this);
72
72
  var result = #{`this.__ruby_instance`.instance_exec(`Opal.Preact.Props.$new({props: props})`,
73
73
  `Opal.Preact.State.$new({state: state})`, &block)};
74
- Opal.Preact.active_redux_components.pop();
74
+ Opal.Preact.unregister_active_component(this);
75
75
  if (typeof result.$to_n === 'function') { result = result.$to_n() }
76
- if (result === Opal.nil) { return null; }
76
+ if (result === nil) { return null; }
77
77
  return result;
78
78
  }
79
79
  if (self.lucid_preact_component) { self.lucid_preact_component.prototype.getDerivedStateFromProps = fun; }
@@ -84,11 +84,11 @@ module Preact
84
84
  def get_snapshot_before_update(&block)
85
85
  %x{
86
86
  var fun = function(prev_props, prev_state) {
87
- Opal.Preact.active_redux_components.push(this);
87
+ Opal.Preact.register_active_component(this);
88
88
  var result = #{`this.__ruby_instance`.instance_exec(`Opal.Preact.Props.$new({props: prev_props})`,
89
89
  `Opal.Preact.State.$new({state: prev_state})`, &block)};
90
- Opal.Preact.active_redux_components.pop();
91
- if (result === Opal.nil) { return null; }
90
+ Opal.Preact.unregister_active_component(this);
91
+ if (result === nil) { return null; }
92
92
  return result;
93
93
  }
94
94
  if (self.lucid_preact_component) { self.lucid_preact_component.prototype.getSnapshotBeforeUpdate = fun; }
@@ -19,9 +19,13 @@ module Preact
19
19
  var defined_refs = #{base.defined_refs};
20
20
  for (var ref in defined_refs) {
21
21
  if (defined_refs[ref] != null) {
22
+ let r = ref; // to ensure closure for function below gets correct ref name
22
23
  this[ref] = function(element) {
23
- element = Opal.Preact.native_element_or_component_to_ruby(element);
24
- #{`this.__ruby_instance`.instance_exec(`element`, &`defined_refs[ref]`)}
24
+ const oper = Opal.Preact;
25
+ element = oper.native_element_or_component_to_ruby(element);
26
+ oper.register_active_component(this);
27
+ #{`this.__ruby_instance`.instance_exec(`element`, &`defined_refs[r]`)}
28
+ oper.unregister_active_component(this);
25
29
  }
26
30
  this[ref] = this[ref].bind(this);
27
31
  } else {
@@ -35,21 +39,22 @@ module Preact
35
39
  render(props, state) {
36
40
  const oper = Opal.Preact;
37
41
  oper.render_buffer.push([]);
38
- // console.log("preact component pushed", oper.render_buffer, oper.render_buffer.toString());
39
- oper.active_components.push(this);
42
+ oper.register_active_component(this);
40
43
  let block_result = #{`this.__ruby_instance`.instance_exec(&`base.render_block`)};
41
44
  if (block_result && block_result !== nil) { oper.render_block_result(block_result); }
42
- // console.log("preact component popping", oper.render_buffer, oper.render_buffer.toString());
43
- oper.active_components.pop();
45
+ oper.unregister_active_component(this);
44
46
  let result = oper.render_buffer.pop();
45
47
  return (result.length === 1) ? result[0] : result;
46
48
  }
47
49
  shouldComponentUpdate(next_props, next_state) {
50
+ const oper = Opal.Preact;
48
51
  if (base.should_component_update_block) {
49
- return #{!!`this.__ruby_instance`.instance_exec(`Opal.Preact.Props.$new({props: next_props})`, `Opal.Preact.State.$new({state: next_state })`, &`base.should_component_update_block`)};
52
+ oper.register_active_component(this);
53
+ return #{!!`this.__ruby_instance`.instance_exec(`oper.Props.$new({props: next_props})`, `oper.State.$new({state: next_state })`, &`base.should_component_update_block`)};
54
+ oper.unregister_active_component(this);
50
55
  }
51
- if (!Opal.Preact.props_are_equal(this.props, next_props)) { return true; }
52
- if (Opal.Preact.state_is_not_equal(this.state, next_state)) { return true; }
56
+ if (!oper.props_are_equal(this.props, next_props)) { return true; }
57
+ if (oper.state_is_not_equal(this.state, next_state)) { return true; }
53
58
  return false;
54
59
  }
55
60
  validateProp(props, propName, componentName) {
@@ -1,3 +1,3 @@
1
1
  module Preact
2
- VERSION = '10.6.19'
2
+ VERSION = '10.6.23'
3
3
  end
data/lib/preact.rb CHANGED
@@ -96,6 +96,20 @@ module Preact
96
96
  return self.active_redux_components[length-1];
97
97
  };
98
98
 
99
+ self.register_active_component = function(component) {
100
+ self.active_components.push(component);
101
+ if (typeof(component.data_access) === 'function') {
102
+ self.active_redux_components.push(component);
103
+ }
104
+ };
105
+
106
+ self.unregister_active_component = function(component) {
107
+ if (typeof(component.data_access) === 'function') {
108
+ self.active_redux_components.pop();
109
+ }
110
+ self.active_components.pop();
111
+ };
112
+
99
113
  function isObject(obj) { return (obj && typeof obj === 'object'); }
100
114
 
101
115
  self.merge_deep = function(one, two) {
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: isomorfeus-preact
3
3
  version: !ruby/object:Gem::Version
4
- version: 10.6.19
4
+ version: 10.6.23
5
5
  platform: ruby
6
6
  authors:
7
7
  - Jan Biedermann
8
8
  autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2022-01-29 00:00:00.000000000 Z
11
+ date: 2022-01-31 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: concurrent-ruby