isomorfeus-preact 10.6.18 → 10.6.22

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.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: 2ea65d13596d480bc9236508994f2fe5e8faed1d74cab03acd6f2c3b272c4446
4
- data.tar.gz: 961c5f11b767f30b4db8a7124c2029f0aa748404c175dc8466b67f38ef58292a
3
+ metadata.gz: 0c7377e941df8a5dd82b65906faa7353cd463aff37722ef42e7545b00967bed8
4
+ data.tar.gz: 3e4a52c1ea3ab9db460e06deba29a42e915e6e01a2d8c43bbdf7c9eaa8153c3f
5
5
  SHA512:
6
- metadata.gz: 57baa3fcf48a20fa0693942f0ffd84794b2ae3409a27e8cf925d3f67c27d03dc2ecdd8a5517bdd392cb06f04212892dd1d5d64177e85ddb59dc2e393bf3991be
7
- data.tar.gz: 808e9777924661bef69c400af5ab5c04d02f76df9ae644344a474df2e8d14f63e6fcf2754af9cfd1cefab590cfcfedc0c7d18109ca1022341a8358f8f9d829ed
6
+ metadata.gz: 9010971c7c91b3dd4ee6f97c36d42b783b1885ca6a8ef74aae2c921c4e67f4cc9c1acc5a7b3997808f48338afe9a0fd4518c17d93bced3f12960c816bbd3fe94
7
+ data.tar.gz: 52d34fd59be865c5edac53bf371813b430f3b2ff85d94047a30b4c64cdb42bb2470435533d19bfeb405eab89597085de8cafaee6d6b8a380953df2902e7bb1ef
@@ -16,55 +16,47 @@ module Browser
16
16
  # function, that function is invoked with `args`. Otherwise, the property
17
17
  # is returned as is.
18
18
  def method_missing message, *args, &block
19
- property_name = property_for_message(message)
20
- property = `#@native[#{property_name}]`
21
-
22
- # translate setting a property
23
19
  if message.end_with? '='
20
+ message = message.chop
21
+ property_name = property_for_message(message)
24
22
  return `#@native[#{property_name}] = args[0]`
25
- end
26
-
27
- # If the native element doesn't have this property, bubble it up
28
- super unless `#{property_name} in #@native`
29
-
30
- if `property === false`
31
- return false
32
- elsif `typeof(property) === 'number' && isNaN(property)`
33
- return nil
34
23
  else
35
- property = `property == null ? nil : property`
36
- end
37
-
38
- # If it's a method, call it. Otherwise, return it.
39
- if `typeof(property) === 'function'`
40
- `property.apply(#@native, args)`
41
- else
42
- property
24
+ property_name = property_for_message(message)
25
+
26
+ %x{
27
+ let value = #@native[#{property_name}];
28
+ let type = typeof(value);
29
+ if (type === 'function') {
30
+ return value.apply(#@native, args);
31
+ } else if (value === null || type === 'undefined' || (type === 'number' && isNaN(value))) {
32
+ return nil;
33
+ }
34
+ return value;
35
+ }
43
36
  end
44
37
  end
45
38
 
46
39
  def respond_to_missing? message, include_all
47
- return true if message.end_with? '='
48
- return true if property_for_message(message)
49
-
40
+ message = message.chop if message.end_with? '='
41
+ property_name = property_for_message(message)
42
+ return true unless `#{property_name} in #@native`
50
43
  false
51
44
  end
52
45
 
53
- def property_for_message message
54
- camel_cased_message = message
55
- .gsub(/_\w/) { |match| `match[1]`.upcase }
56
- .sub(/=$/, '')
57
-
58
- # translate `supported?` to `supported` or `isSupported`
59
- if message.end_with? '?'
60
- camel_cased_message = camel_cased_message.chop
61
- property_type = `typeof(#@native[camel_cased_message])`
62
- if property_type == 'undefined'
63
- camel_cased_message = "is#{camel_cased_message[0].upcase}#{camel_cased_message[1..-1]}"
64
- end
65
- end
66
-
67
- camel_cased_message
46
+ def property_for_message(message)
47
+ %x{
48
+ let camel_cased_message;
49
+ if (typeof(#@native[message]) !== 'undefined') { camel_cased_message = message; }
50
+ else { camel_cased_message = Opal.Preact.lower_camelize(message) }
51
+
52
+ if (camel_cased_message.endsWith('?')) {
53
+ camel_cased_message = camel_cased_message.substring(0, camel_cased_message.length - 2);
54
+ if (typeof(#@native[camel_cased_message]) === 'undefined') {
55
+ camel_cased_message = 'is' + camel_cased_message[0].toUpperCase() + camel_cased_message.substring(0, camel_cased_message.length - 1);
56
+ }
57
+ }
58
+ return camel_cased_message
59
+ }
68
60
  end
69
61
  end
70
62
  end
@@ -7,7 +7,7 @@ if RUBY_ENGINE == 'opal'
7
7
  require 'browser/event'
8
8
  require 'browser/event_target'
9
9
  require 'browser/delegate_native'
10
- require 'browser/element'
10
+ require 'browser/element' # depends on 'preact'
11
11
  end
12
12
 
13
13
  require 'isomorfeus/preact/config'
@@ -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.18'
2
+ VERSION = '10.6.22'
3
3
  end
data/lib/preact.rb CHANGED
@@ -57,8 +57,9 @@ module Preact
57
57
  };
58
58
 
59
59
  self.native_element_or_component_to_ruby = function (element) {
60
- if (typeof element.__ruby_instance !== 'undefined') { return element.__ruby_instance }
61
- if (element instanceof Element || element instanceof Node) { return #{Browser::Element.new(`element`)} }
60
+ if (element == null || typeof(element) === 'undefined' ) { return nil; }
61
+ if (typeof element.__ruby_instance !== 'undefined') { return element.__ruby_instance; }
62
+ if (element instanceof Element || element instanceof Node) { return #{Browser::Element.new(`element`)}; }
62
63
  return element;
63
64
  };
64
65
 
@@ -95,6 +96,20 @@ module Preact
95
96
  return self.active_redux_components[length-1];
96
97
  };
97
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
+
98
113
  function isObject(obj) { return (obj && typeof obj === 'object'); }
99
114
 
100
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.18
4
+ version: 10.6.22
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-28 00:00:00.000000000 Z
11
+ date: 2022-01-30 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: concurrent-ruby