8180903340

Committed 07 Mar 2024 12:34AM UTC coverage: 73.689% (+3.0%) from 70.67%

Build # 8180903340

Build Type

Pull #8586

github

Committed by

web-flow

Commit Message

Merge 7b4662f2e into e76b1c48e

Pull Request Pull Request #8586: chore: bump luma 9.0.0 beta.7

Run Details

3675 of 4371 branches covered (84.08%)

Branch coverage included in aggregate %.

12 of 12 new or added lines in 3 files covered. (100.0%)

4 existing lines in 1 file now uncovered.

41744 of 57265 relevant lines covered (72.9%)

309.89 hits per line

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

62.77

/modules/json/src/transports/transport.ts

/* global document */
const state = {
  onInitialize: _ => _,
  onFinalize: _ => _,
  onMessage: _ => _
};

export default class Transport {
  static setCallbacks({onInitialize, onFinalize, onMessage}) {
    if (onInitialize) {
      state.onInitialize = onInitialize;
    }
    if (onFinalize) {
      state.onFinalize = onFinalize;
    }
    if (onMessage) {
      state.onMessage = onMessage;
    }
    // this._flushQueuedConnections();
  }

  name: string;
  _messageQueue = [];
  userData = {};
  _destroyed: boolean = false;

  constructor(name = 'Transport') {
    this.name = name;
  }

  /**
   * Return a root DOM element for this transport connection
   * @return {HTMLElement} default implementation returns document.body
   * Jupyter Notebook transports will return an element associated with the notebook cell
   */
  getRootDOMElement() {
    return typeof document !== 'undefined' ? document.body : null;
  }

  /**
   * Back-channel messaging
   */
  sendJSONMessage() {
    // eslint-disable-next-line
    console.error('Back-channel not implemented for this transport');
  }

  /**
   * Back-channel messaging
   */
  sendBinaryMessage() {
    // eslint-disable-next-line
    console.error('Back-channel not implemented for this transport');
  }

  //
  // API for transports (not intended for apps)
  //

  _initialize(options = {}) {
    const message = {transport: this, ...options};
    state.onInitialize(message);

    // console.debug('Resolving init promise', options); // eslint-disable-line
    // this._initResolvers.resolve(message);
  }

  _finalize(options = {}) {
    const message = {transport: this, ...options};

    // TODO - could potentially be called without Initialize being called
    state.onFinalize(message);
    this._destroyed = true;
  }

  _messageReceived(message = {}) {
    message = {transport: this, ...message};

    // TODO - this function could potentially be called before callback registered/ Initialize called
    // if (!state.onMessage) {
    //   console.error('Queueing transport message', message); // eslint-disable-line
    //   this._messageQueue.push(message);
    //   return;
    // }

    console.debug('Delivering transport message', message); // eslint-disable-line
    state.onMessage(message);
  }

  /*
  // This tries to handle the case that a transport connection initializes before the application
  // has set the callbacks.
  // Note: It is not clear that this can actually happen in the in initial Jupyter widget transport
  _flushQueuedConnections() {
    if (onInitialize) {
      state._initPromise.then(initArgs => {
        onInitialize(initArgs);

        if (state._onMessage) {
          // Send any queued messages
          let message;
          while ((message = this._messageQueue.pop())) {
            console.debug('Delivering queued transport message', message); // eslint-disable-line
            this._onMessage(message);
          }
        }
      });
    }
  }
  */

  static _stringifyJSONSafe(v) {
    const cache = new Set();
    return JSON.stringify(v, (key, value) => {
      if (typeof value === 'object' && value !== null) {
        if (cache.has(value)) {
          // Circular reference found
          try {
            // If this value does not reference a parent it can be deduped
            return JSON.parse(JSON.stringify(value));
          } catch (err) {
            // discard key if value cannot be deduped
            return undefined;
          }
        }
        // Store value in our set
        cache.add(value);
      }
      return value;
    });
  }
}

1	/* global document */	1✔
2	const state = {	1✔
3	onInitialize: _ => _,	1✔
4	onFinalize: _ => _,	1✔
5	onMessage: _ => _	1✔
6	};	1✔
7		1✔
8	export default class Transport {	1✔
9	static setCallbacks({onInitialize, onFinalize, onMessage}) {	1✔
10	if (onInitialize) {	1✔
11	state.onInitialize = onInitialize;	1✔
12	}	1✔
13	if (onFinalize) {	1!
UNCOV 14	state.onFinalize = onFinalize;	×
UNCOV 15	}	×
16	if (onMessage) {	1!
UNCOV 17	state.onMessage = onMessage;	×
UNCOV 18	}	×
19	// this._flushQueuedConnections();	1✔
20	}	1✔
21		1✔
22	name: string;	1✔
23	_messageQueue = [];	1✔
24	userData = {};	1✔
25	_destroyed: boolean = false;	1✔
26		1✔
27	constructor(name = 'Transport') {	1✔
28	this.name = name;	1✔
29	}	1✔
30		1✔
31	/**	1✔
32	* Return a root DOM element for this transport connection	1✔
33	* @return {HTMLElement} default implementation returns document.body	1✔
34	* Jupyter Notebook transports will return an element associated with the notebook cell	1✔
35	*/	1✔
36	getRootDOMElement() {	1✔
37	return typeof document !== 'undefined' ? document.body : null;	×
38	}	×
39		1✔
40	/**	1✔
41	* Back-channel messaging	1✔
42	*/	1✔
43	sendJSONMessage() {	1✔
44	// eslint-disable-next-line	×
45	console.error('Back-channel not implemented for this transport');	×
46	}	×
47		1✔
48	/**	1✔
49	* Back-channel messaging	1✔
50	*/	1✔
51	sendBinaryMessage() {	1✔
52	// eslint-disable-next-line	×
53	console.error('Back-channel not implemented for this transport');	×
54	}	×
55		1✔
56	//	1✔
57	// API for transports (not intended for apps)	1✔
58	//	1✔
59		1✔
60	_initialize(options = {}) {	1✔
61	const message = {transport: this, ...options};	1✔
62	state.onInitialize(message);	1✔
63		1✔
64	// console.debug('Resolving init promise', options); // eslint-disable-line	1✔
65	// this._initResolvers.resolve(message);	1✔
66	}	1✔
67		1✔
68	_finalize(options = {}) {	1✔
69	const message = {transport: this, ...options};	×
70		×
71	// TODO - could potentially be called without Initialize being called	×
72	state.onFinalize(message);	×
73	this._destroyed = true;	×
74	}	×
75		1✔
76	_messageReceived(message = {}) {	1✔
77	message = {transport: this, ...message};	×
78		×
79	// TODO - this function could potentially be called before callback registered/ Initialize called	×
80	// if (!state.onMessage) {	×
81	// console.error('Queueing transport message', message); // eslint-disable-line	×
82	// this._messageQueue.push(message);	×
83	// return;	×
84	// }	×
85		×
86	console.debug('Delivering transport message', message); // eslint-disable-line	×
87	state.onMessage(message);	×
88	}	×
89		1✔
90	/*	1✔
91	// This tries to handle the case that a transport connection initializes before the application	1✔
92	// has set the callbacks.	1✔
93	// Note: It is not clear that this can actually happen in the in initial Jupyter widget transport	1✔
94	_flushQueuedConnections() {	1✔
95	if (onInitialize) {	1✔
96	state._initPromise.then(initArgs => {	1✔
97	onInitialize(initArgs);	1✔
98		1✔
99	if (state._onMessage) {	1✔
100	// Send any queued messages	1✔
101	let message;	1✔
102	while ((message = this._messageQueue.pop())) {	1✔
103	console.debug('Delivering queued transport message', message); // eslint-disable-line	1✔
104	this._onMessage(message);	1✔
105	}	1✔
106	}	1✔
107	});	1✔
108	}	1✔
109	}	1✔
110	*/	1✔
111		1✔
112	static _stringifyJSONSafe(v) {	1✔
113	const cache = new Set();	×
114	return JSON.stringify(v, (key, value) => {	×
115	if (typeof value === 'object' && value !== null) {	×
116	if (cache.has(value)) {	×
117	// Circular reference found	×
118	try {	×
119	// If this value does not reference a parent it can be deduped	×
120	return JSON.parse(JSON.stringify(value));	×
121	} catch (err) {	×
122	// discard key if value cannot be deduped	×
123	return undefined;	×
124	}	×
125	}	×
126	// Store value in our set	×
127	cache.add(value);	×
128	}	×
129	return value;	×
130	});	×
131	}	×
132	}	1✔

visgl / deck.gl / 8180903340

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