10753642043

Committed 07 Sep 2024 06:42PM UTC coverage: 55.832% (+0.002%) from 55.83%

Build # 10753642043

Build Type

push

github

Committed by

rinick

Commit Message

fix call button handler, should use onCall instead of queueFunction

Run Details

4882 of 10233 branches covered (47.71%)

Branch coverage included in aggregate %.

4 of 4 new or added lines in 2 files covered. (100.0%)

31 existing lines in 3 files now uncovered.

13786 of 23203 relevant lines covered (59.41%)

244.26 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.81

/src/core/block/BlockProperty.ts

import {PropDispatcher, PropListener, Destroyable} from './Dispatcher';
import {Block} from './Block';
import {DataMap, isSavedBlock} from '../util/DataTypes';

export interface BlockBindingSource extends PropDispatcher<any>, Destroyable {
  getProperty(): BlockProperty;
}

export interface BlockPropertyEvent {
  error?: string;
  bind?: string | null;
  listener?: PropListener<any> | null;
}

export interface BlockPropertySubscriber {
  onPropertyEvent(change: BlockPropertyEvent): void;
}

export class BlockProperty extends PropDispatcher<any> implements PropListener<any>, BlockBindingSource {
  readonly _block: Block;
  readonly _name: string;
  _bindingPath: string;
  _bindingSource: BlockBindingSource;
  _helperProperty: HelperProperty;

  _saved: unknown;

  constructor(block: Block, name: string) {
    super();
    this._block = block;
    this._name = name;
  }

  getProperty() {
    return this;
  }

  onSourceChange(prop: PropDispatcher<any>) {
    // do nothing
  }

  _valueChanged(saved?: boolean) {
    // to be overridden
  }

  updateValue(val: unknown): boolean {
    return this.onChange(val);
  }

  revertUpdate() {
    let val: unknown;
    if (this._saved !== undefined) {
      val = this._saved;
    } else if (this._bindingSource) {
      val = this._bindingSource.getProperty()._value;
    } else {
      return;
    }
    if (!Object.is(this._value, val)) {
      this.onChange(val);
    }
  }

  onChange(val: unknown, save?: boolean): boolean {
    if (Object.is(this._value, val)) {
      if (save && !Object.is(this._saved, val)) {
        this._saved = val;
      }
      return false;
    }
    if (this._value instanceof Block) {
      if (this._value._prop === this) {
        this._value.destroy();
      }
      if (this._saved === this._value) {
        this._saved = undefined;
      }
    }
    this._value = val;
    if (save) {
      this._saved = val;
    }
    this._valueChanged(save);
    this._dispatch();
    return true;
  }

  // output the value but doesn't notify the function
  // to be overriden in BlockIo
  setOutput(val: unknown): boolean {
    return this.onChange(val);
  }

  setValue(val: unknown) {
    if (this._bindingSource) {
      this._bindingSource.unlisten(this);
      if (this._helperProperty) {
        this._helperProperty.setValue(undefined);
        this._helperProperty = null;
      }
      this._bindingPath = null;
      this._bindingSource = null;
      if (this._subscribers) {
        this.addEvent({bind: null});
      }
    }
    this.onChange(val, true);
  }

  isCleared() {
    return this._bindingPath == null && this._saved === undefined;
  }

  getValue() {
    return this._value;
  }

  setBinding(path: string) {
    if (path === this._bindingPath) return;

    if (this._bindingSource) {
      this._bindingSource.unlisten(this);
    }
    if (this._helperProperty) {
      this._helperProperty.setValue(undefined);
      this._helperProperty = null;
    }
    this._bindingPath = path;

    if (path != null) {
      this._saved = undefined;
      this._bindingSource = this._block.createBinding(path, this);
    } else {
      this._bindingSource = null;
      this.onChange(undefined, true);
    }
    if (this._subscribers) {
      this.addEvent({bind: path});
    }
  }

  _listenRaw(source: BlockBindingSource) {
    if (this._bindingSource) {
      if (source === this._bindingSource) {
        return;
      }
      this._bindingSource.unlisten(this);
      this._bindingPath = null;
    }
    this._bindingSource = source;
    source.listen(this);
  }

  setBindProperty(prop: HelperProperty) {
    this._helperProperty = prop;
  }

  _saveValue(): unknown {
    if (this._saved !== undefined) {
      if (this._saved instanceof Block) {
        return this._saved._save();
      }
      if (isSavedBlock(this._saved)) {
        // when saved object is ambiguous, wrapped it with another layer of #is:{}
        return {'#is': this._saved};
      }
      return this._saved;
    }
  }

  _saveBinding(): unknown {
    if (this._helperProperty) {
      return this._helperProperty.__save();
    }
    return this._bindingPath;
  }

  _saveToMap(map: DataMap) {
    if (this._bindingPath) {
      map[`~${this._name}`] = this._saveBinding();
    } else {
      let saved = this._saveValue();
      if (saved !== undefined) {
        map[this._name] = saved;
      }
    }
  }

  _load(val: unknown) {
    if (isSavedBlock(val)) {
      if (typeof val['#is'] === 'object') {
        // not a saved block, but a wrapped object
        this.onChange(val['#is'], true);
        return;
      }
      let block = this.createBlock(undefined);
      block._load(val);
      this.onChange(block, true);
    } else {
      this.onChange(val, true);
    }
  }

  _liveUpdate(val: unknown) {
    if (this._bindingSource) {
      this._bindingSource.unlisten(this);
      this._bindingSource = null;
      this._bindingPath = null;
      if (this._subscribers) {
        this.addEvent({bind: null});
      }
    }
    if (isSavedBlock(val)) {
      if (typeof val['#is'] === 'object') {
        // not a saved block, but a wrapped object
        this.onChange(val['#is'], true);
        return;
      }
      if (this._saved instanceof Block) {
        this._saved._liveUpdate(val);
      } else {
        // just do a normal loading
        let block = this.createBlock(undefined);
        block._load(val);
        this.onChange(block, true);
      }
    } else if (val !== this._saved) {
      this.onChange(val, true);
    }
  }
  // clear saved value and binding path if they exist, otherwise leave runtime value unchanged
  _liveClear() {
    if (this._bindingPath || this._saved !== undefined) {
      this.setValue(undefined);
    }
  }

  _subscribers: Set<BlockPropertySubscriber>;

  subscribe(subscriber: BlockPropertySubscriber) {
    if (this._subscribers == null) {
      this._subscribers = new Set<BlockPropertySubscriber>();
    }
    this._subscribers.add(subscriber);
  }

  unsubscribe(subscriber: BlockPropertySubscriber) {
    if (!this._subscribers) {
      return;
    }
    this._subscribers.delete(subscriber);
    if (this._subscribers.size === 0) {
      this._subscribers = null;
    }
  }

  addEvent(event: BlockPropertyEvent) {
    for (let subscriber of this._subscribers) {
      subscriber.onPropertyEvent(event);
    }
  }

  listen(listener: PropListener<any>) {
    this._listeners.add(listener);
    listener.onSourceChange(this);
    if (!this._updating) {
      // skip extra update if it's already in updating iteration
      listener.onChange(this._value);
    }
    if (this._subscribers) {
      this.addEvent({listener});
    }
  }

  unlisten(listener: PropListener<any>) {
    if (this._listeners) {
      this._listeners.delete(listener);
      if (this._subscribers) {
        this.addEvent({listener: null});
      }
    }
  }

  createBlock(save: boolean) {
    let block = new Block(this._block._flow, this._block, this);
    if (save) {
      this.setValue(block);
    } else if (save === false) {
      this.onChange(block);
    }
    // skip value change when save is undefined
    return block;
  }

  destroy() {
    if (!this._listeners) {
      return;
    }
    if (this._bindingSource) {
      this._bindingSource.unlisten(this);
      this._bindingSource = null;
    }
    if (this._value instanceof Block && this._value._prop === this) {
      this._value.destroy();
    }
    for (let listener of this._listeners) {
      listener.onSourceChange(null);
    }
    this._listeners = null;
    this._subscribers = null;
    // TODO ?
  }

  isDestroyed() {
    return (
      this._block._destroyed || !this._listeners // maybe destroy is not called but block is in the middle of destroy()
    );
  }
}

export class BlockIO extends BlockProperty {
  constructor(block: Block, name: string) {
    super(block, name);
    if (block._ioCache) {
      block._ioCache.set(name, this);
    }
  }

  _valueChanged(saved?: boolean) {
    if (!this._outputing) {
      this._block.inputChanged(this, this._value);
    }
    if (this._block._watchers) {
      this._block._onChildChanged(this, saved);
    }
  }

  _outputing: boolean = false;

  // outputs the value but doesn't notify the function
  setOutput(val: unknown): boolean {
    this._outputing = true;
    let changed = this.onChange(val);
    this._outputing = false;
    return changed;
  }
}

export class BlockConfig extends BlockProperty {
  _valueChanged(saved?: boolean) {
    if (!this._outputing) {
      this._block.configChanged(this, this._value);
    }
    if (this._block._watchers) {
      this._block._onChildChanged(this, saved);
    }
  }

  _outputing: boolean = false;

  // outputs the value but doesn't notify the function
  setOutput(val: unknown): boolean {
    this._outputing = true;
    let changed = this.onChange(val);
    this._outputing = false;
    return changed;
  }
}

export class GlobalProperty extends BlockIO {
  constructor(block: Block, name: string) {
    super(block, name);
    this.listenToParentGlobal();
  }

  onChange(val: unknown, save?: boolean): boolean {
    if (super.onChange(val, save) && save) {
      this.checkInUse();
      return true;
    } else {
      return false;
    }
  }

  unlisten(listener: PropListener<any>) {
    super.unlisten(listener);
    this.checkInUse();
  }

  setBinding(path: string) {
    super.setBinding(path);
    this.checkInUse();
  }

  checkInUse() {
    if (this._saved === undefined && this._bindingPath == null) {
      if (this._listeners.size === 0) {
        this._block._props.delete(this._name);
        if (this._block._ioCache) {
          this._block._ioCache.delete(this._name);
        }
        this.destroy();
      } else {
        this.listenToParentGlobal();
      }
    }
  }

  listenToParentGlobal() {
    this._listenRaw(this._block._flow._parent._flow.getGlobalProperty(this._name));
  }
}

export class HelperProperty extends BlockProperty {
  // a helper block should only be saved from original property
  _saveValue(): unknown {
    return undefined;
  }

  // call the raw save function
  __save(): unknown {
    if (this._saved instanceof Block) {
      return this._saved._save();
    } else {
      return undefined;
    }
  }
}

1	import {PropDispatcher, PropListener, Destroyable} from './Dispatcher';	2✔
2	import {Block} from './Block';	2✔
3	import {DataMap, isSavedBlock} from '../util/DataTypes';	2✔
4		1✔
5	export interface BlockBindingSource extends PropDispatcher<any>, Destroyable {	1✔
6	getProperty(): BlockProperty;	1✔
7	}	1✔
8		1✔
9	export interface BlockPropertyEvent {	1✔
10	error?: string;	1✔
11	bind?: string \| null;	1✔
12	listener?: PropListener<any> \| null;	1✔
13	}	1✔
14		1✔
15	export interface BlockPropertySubscriber {	1✔
16	onPropertyEvent(change: BlockPropertyEvent): void;	1✔
17	}	1✔
18		1✔
19	export class BlockProperty extends PropDispatcher<any> implements PropListener<any>, BlockBindingSource {	2✔
20	readonly _block: Block;	7,908✔
21	readonly _name: string;	7,908✔
22	_bindingPath: string;	7,908✔
23	_bindingSource: BlockBindingSource;	7,908✔
24	_helperProperty: HelperProperty;	7,908✔
25		7,908✔
26	_saved: unknown;	7,908✔
27		7,908✔
28	constructor(block: Block, name: string) {	7,908✔
29	super();	13,198✔
30	this._block = block;	13,198✔
31	this._name = name;	13,198✔
32	}	7,908✔
33		7,908✔
34	getProperty() {	7,908✔
35	return this;	×
36	}
37		7,908✔
38	onSourceChange(prop: PropDispatcher<any>) {	7,908✔
39	// do nothing	1,609✔
40	}	1,609✔
41		7,908✔
42	_valueChanged(saved?: boolean) {	7,908✔
43	// to be overridden	136✔
44	}	136✔
45		7,908✔
46	updateValue(val: unknown): boolean {	7,908✔
47	return this.onChange(val);	2,531✔
48	}	1,555✔
49		7,908✔
50	revertUpdate() {	7,908✔
51	let val: unknown;
52	if (this._saved !== undefined) {	12!
53	val = this._saved;	12✔
UNCOV 54	} else if (this._bindingSource) {	×
UNCOV 55	val = this._bindingSource.getProperty()._value;	×
56	} else {
UNCOV 57	return;	×
58	}
59	if (!Object.is(this._value, val)) {	12✔
60	this.onChange(val);	4✔
61	}
62	}
63		7,908✔
64	onChange(val: unknown, save?: boolean): boolean {	7,908✔
65	if (Object.is(this._value, val)) {	16,737✔
66	if (save && !Object.is(this._saved, val)) {	2,595✔
67	this._saved = val;	9✔
68	}	4✔
69	return false;	2,595✔
70	}	1,375✔
71	if (this._value instanceof Block) {	15,517✔
72	if (this._value._prop === this) {	492✔
73	this._value.destroy();	480✔
74	}	389✔
75	if (this._saved === this._value) {	492✔
76	this._saved = undefined;	159✔
77	}	120✔
78	}	400✔
79	this._value = val;	14,142✔
80	if (save) {	15,510✔
81	this._saved = val;	7,964✔
82	}	4,530✔
83	this._valueChanged(save);	14,142✔
84	this._dispatch();	14,142✔
85	return true;	14,142✔
86	}	9,682✔
87		7,908✔
88	// output the value but doesn't notify the function	7,908✔
89	// to be overriden in BlockIo	7,908✔
90	setOutput(val: unknown): boolean {	7,908✔
UNCOV 91	return this.onChange(val);	×
92	}
93		7,908✔
94	setValue(val: unknown) {	7,908✔
95	if (this._bindingSource) {	2,462✔
96	this._bindingSource.unlisten(this);	12✔
97	if (this._helperProperty) {	12!
98	this._helperProperty.setValue(undefined);	2✔
99	this._helperProperty = null;	2✔
100	}	2✔
101	this._bindingPath = null;	12✔
102	this._bindingSource = null;	12✔
103	if (this._subscribers) {	12!
104	this.addEvent({bind: null});	5✔
105	}	3✔
106	}	10✔
107	this.onChange(val, true);	2,462✔
108	}	1,757✔
109		7,908✔
110	isCleared() {	7,908✔
111	return this._bindingPath == null && this._saved === undefined;	43✔
112	}	37✔
113		7,908✔
114	getValue() {	7,908✔
115	return this._value;	4,291✔
116	}	2,443✔
117		7,908✔
118	setBinding(path: string) {	7,908✔
119	if (path === this._bindingPath) return;	1,580!
120		973✔
121	if (this._bindingSource) {	1,580✔
122	this._bindingSource.unlisten(this);	28✔
123	}	19✔
124	if (this._helperProperty) {	1,580!
125	this._helperProperty.setValue(undefined);	1✔
126	this._helperProperty = null;	1✔
127	}	1✔
128	this._bindingPath = path;	1,579✔
129		973✔
130	if (path != null) {	1,579✔
131	this._saved = undefined;	1,575✔
132	this._bindingSource = this._block.createBinding(path, this);	1,575✔
133	} else {	974✔
134	this._bindingSource = null;	4✔
135	this.onChange(undefined, true);	4✔
136	}	3✔
137	if (this._subscribers) {	1,580✔
138	this.addEvent({bind: path});	14✔
139	}	7✔
140	}	974✔
141		7,908✔
142	_listenRaw(source: BlockBindingSource) {	7,908✔
143	if (this._bindingSource) {	70!
144	if (source === this._bindingSource) {	31!
145	return;	31✔
146	}
UNCOV 147	this._bindingSource.unlisten(this);	×
UNCOV 148	this._bindingPath = null;	×
149	}
150	this._bindingSource = source;	39✔
151	source.listen(this);	39✔
152	}	9✔
153		7,908✔
154	setBindProperty(prop: HelperProperty) {	7,908✔
155	this._helperProperty = prop;	85✔
156	}	13✔
157		7,908✔
158	_saveValue(): unknown {	7,908✔
159	if (this._saved !== undefined) {	332✔
160	if (this._saved instanceof Block) {	259✔
161	return this._saved._save();	82✔
162	}	69✔
163	if (isSavedBlock(this._saved)) {	242!
164	// when saved object is ambiguous, wrapped it with another layer of #is:{}	1✔
165	return {'#is': this._saved};	1✔
166	}	1✔
167	return this._saved;	176✔
168	}	158✔
169	}	283✔
170		7,908✔
171	_saveBinding(): unknown {	7,908✔
172	if (this._helperProperty) {	9!
173	return this._helperProperty.__save();	1✔
174	}	1✔
175	return this._bindingPath;	8✔
176	}	9✔
177		7,908✔
178	_saveToMap(map: DataMap) {	7,908✔
179	if (this._bindingPath) {	421!
180	map[`~${this._name}`] = this._saveBinding();	9✔
181	} else {	362✔
182	let saved = this._saveValue();	412✔
183	if (saved !== undefined) {	412✔
184	map[this._name] = saved;	335✔
185	}	294✔
186	}	353✔
187	}	362✔
188		7,908✔
189	_load(val: unknown) {	7,908✔
190	if (isSavedBlock(val)) {	6,330✔
191	if (typeof val['#is'] === 'object') {	1,539✔
192	// not a saved block, but a wrapped object	40✔
193	this.onChange(val['#is'], true);	51✔
194	return;	51✔
195	}	40✔
196	let block = this.createBlock(undefined);	1,488✔
197	block._load(val);	1,488✔
198	this.onChange(block, true);	1,488✔
199	} else {	3,421✔
200	this.onChange(val, true);	4,791✔
201	}	2,351✔
202	}	3,421✔
203		7,908✔
204	_liveUpdate(val: unknown) {	7,908✔
205	if (this._bindingSource) {	96!
206	this._bindingSource.unlisten(this);	1✔
207	this._bindingSource = null;	1✔
208	this._bindingPath = null;	1✔
209	if (this._subscribers) {	1!
UNCOV 210	this.addEvent({bind: null});	×
211	}
212	}	1✔
213	if (isSavedBlock(val)) {	96✔
214	if (typeof val['#is'] === 'object') {	18!
215	// not a saved block, but a wrapped object	1✔
216	this.onChange(val['#is'], true);	1✔
217	return;	1✔
218	}	1✔
219	if (this._saved instanceof Block) {	17!
220	this._saved._liveUpdate(val);	5✔
221	} else {	16✔
222	// just do a normal loading	11✔
223	let block = this.createBlock(undefined);	12✔
224	block._load(val);	12✔
225	this.onChange(block, true);	12✔
226	}	11✔
227	} else if (val !== this._saved) {	95!
228	this.onChange(val, true);	60✔
229	}	48✔
230	}	83✔
231	// clear saved value and binding path if they exist, otherwise leave runtime value unchanged	7,908✔
232	_liveClear() {	7,908✔
233	if (this._bindingPath \|\| this._saved !== undefined) {	46✔
234	this.setValue(undefined);	17✔
235	}	12✔
236	}	35✔
237		7,908✔
238	_subscribers: Set<BlockPropertySubscriber>;	7,908✔
239		7,908✔
240	subscribe(subscriber: BlockPropertySubscriber) {	7,908✔
241	if (this._subscribers == null) {	25!
242	this._subscribers = new Set<BlockPropertySubscriber>();	25✔
243	}	15✔
244	this._subscribers.add(subscriber);	25✔
245	}	15✔
246		7,908✔
247	unsubscribe(subscriber: BlockPropertySubscriber) {	7,908✔
248	if (!this._subscribers) {	19!
UNCOV 249	return;	×
250	}
251	this._subscribers.delete(subscriber);	19✔
252	if (this._subscribers.size === 0) {	19!
253	this._subscribers = null;	19✔
254	}	11✔
255	}	11✔
256		7,908✔
257	addEvent(event: BlockPropertyEvent) {	7,908✔
258	for (let subscriber of this._subscribers) {	76✔
259	subscriber.onPropertyEvent(event);	76✔
260	}	45✔
261	}	45✔
262		7,908✔
263	listen(listener: PropListener<any>) {	7,908✔
264	this._listeners.add(listener);	2,826✔
265	listener.onSourceChange(this);	2,826✔
266	if (!this._updating) {	2,826!
267	// skip extra update if it's already in updating iteration	1,687✔
268	listener.onChange(this._value);	2,825✔
269	}	1,687✔
270	if (this._subscribers) {	2,826✔
271	this.addEvent({listener});	28✔
272	}	17✔
273	}	1,688✔
274		7,908✔
275	unlisten(listener: PropListener<any>) {	7,908✔
276	if (this._listeners) {	2,307✔
277	this._listeners.delete(listener);	1,015✔
278	if (this._subscribers) {	1,015✔
279	this.addEvent({listener: null});	29✔
280	}	18✔
281	}	476✔
282	}	1,600✔
283		7,908✔
284	createBlock(save: boolean) {	7,908✔
285	let block = new Block(this._block._flow, this._block, this);	1,777✔
286	if (save) {	1,777✔
287	this.setValue(block);	702✔
288	} else if (save === false) {	1,476✔
289	this.onChange(block);	54✔
290	}	44✔
291	// skip value change when save is undefined	1,104✔
292	return block;	1,777✔
293	}	1,104✔
294		7,908✔
295	destroy() {	7,908✔
296	if (!this._listeners) {	8,671!
UNCOV 297	return;	×
298	}
299	if (this._bindingSource) {	8,671✔
300	this._bindingSource.unlisten(this);	1,296✔
301	this._bindingSource = null;	1,296✔
302	}	904✔
303	if (this._value instanceof Block && this._value._prop === this) {	8,671✔
304	this._value.destroy();	1,781✔
305	}	1,240✔
306	for (let listener of this._listeners) {	8,671✔
307	listener.onSourceChange(null);	1,309✔
308	}	1,139✔
309	this._listeners = null;	8,671✔
310	this._subscribers = null;	8,671✔
311	// TODO ?	5,830✔
312	}	5,830✔
313		7,908✔
314	isDestroyed() {	7,908✔
315	return (	1✔
316	this._block._destroyed \|\| !this._listeners // maybe destroy is not called but block is in the middle of destroy()	1!
317	);	1✔
318	}	1✔
319	}	7,908✔
320		1✔
321	export class BlockIO extends BlockProperty {	2✔
322	constructor(block: Block, name: string) {	2,991✔
323	super(block, name);	5,283✔
324	if (block._ioCache) {	5,283✔
325	block._ioCache.set(name, this);	22✔
326	}	15✔
327	}	2,991✔
328		2,991✔
329	_valueChanged(saved?: boolean) {	2,991✔
330	if (!this._outputing) {	6,588✔
331	this._block.inputChanged(this, this._value);	6,153✔
332	}	3,693✔
333	if (this._block._watchers) {	6,588✔
334	this._block._onChildChanged(this, saved);	33✔
335	}	22✔
336	}	3,958✔
337		2,991✔
338	_outputing: boolean = false;	5,283✔
339		2,991✔
340	// outputs the value but doesn't notify the function	2,991✔
341	setOutput(val: unknown): boolean {	2,991✔
342	this._outputing = true;	435✔
343	let changed = this.onChange(val);	435✔
344	this._outputing = false;	435✔
345	return changed;	435✔
346	}	265✔
347	}	2,991✔
348		1✔
349	export class BlockConfig extends BlockProperty {	2✔
350	_valueChanged(saved?: boolean) {	906✔
351	if (!this._outputing) {	2,256✔
352	this._block.configChanged(this, this._value);	1,245✔
353	}	935✔
354	if (this._block._watchers) {	2,256!
UNCOV 355	this._block._onChildChanged(this, saved);	×
356	}
357	}	1,415✔
358		906✔
359	_outputing: boolean = false;	1,490✔
360		906✔
361	// outputs the value but doesn't notify the function	906✔
362	setOutput(val: unknown): boolean {	906✔
363	this._outputing = true;	1,127✔
364	let changed = this.onChange(val);	1,127✔
365	this._outputing = false;	1,127✔
366	return changed;	1,127✔
367	}	493✔
368	}	906✔
369		1✔
370	export class GlobalProperty extends BlockIO {	2✔
371	constructor(block: Block, name: string) {	1✔
372	super(block, name);	33✔
373	this.listenToParentGlobal();	33✔
374	}	3✔
375		1✔
376	onChange(val: unknown, save?: boolean): boolean {	1✔
377	if (super.onChange(val, save) && save) {	55!
378	this.checkInUse();	2✔
379	return true;	2✔
380	} else {	14✔
381	return false;	53✔
382	}	12✔
383	}	14✔
384		1✔
385	unlisten(listener: PropListener<any>) {	1✔
386	super.unlisten(listener);	54✔
387	this.checkInUse();	54✔
388	}	3✔
389		1✔
390	setBinding(path: string) {	1✔
UNCOV 391	super.setBinding(path);	×
UNCOV 392	this.checkInUse();	×
393	}
394		1✔
395	checkInUse() {	1✔
396	if (this._saved === undefined && this._bindingPath == null) {	56!
397	if (this._listeners.size === 0) {	55✔
398	this._block._props.delete(this._name);	23✔
399	if (this._block._ioCache) {	23!
UNCOV 400	this._block._ioCache.delete(this._name);	×
401	}
402	this.destroy();	23✔
403	} else {	4✔
404	this.listenToParentGlobal();	32✔
405	}	1✔
406	}	4✔
407	}	5✔
408		1✔
409	listenToParentGlobal() {	1✔
410	this._listenRaw(this._block._flow._parent._flow.getGlobalProperty(this._name));	65✔
411	}	4✔
412	}	1✔
413		1✔
414	export class HelperProperty extends BlockProperty {	2✔
415	// a helper block should only be saved from original property	1✔
416	_saveValue(): unknown {	1✔
417	return undefined;	1✔
418	}	1✔
419		1✔
420	// call the raw save function	1✔
421	__save(): unknown {	1✔
422	if (this._saved instanceof Block) {	2!
423	return this._saved._save();	2✔
424	} else {	2!
UNCOV 425	return undefined;	×
426	}
427	}	2✔
428	}	1✔

ticlo / ticlo / 10753642043

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous