1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
/* @filedescription Minimal utils and assertion support for places in the code
* that are still not updated to JS modules. Do not use in new code. Use
* assert_ts and util_ts instead. */
/**
* Note: This method is deprecated. Use the equivalent method in assert_ts.ts
* instead.
* Verify |condition| is truthy and return |condition| if so.
* @template T
* @param {T} condition A condition to check for truthiness. Note that this
* may be used to test whether a value is defined or not, and we don't want
* to force a cast to Boolean.
* @param {string=} opt_message A message to show on failure.
* @return {T} A non-null |condition|.
* @closurePrimitive {asserts.truthy}
* @suppress {reportUnknownTypes} because T is not sufficiently constrained.
*/
function assert(condition, opt_message) {
if (!condition) {
let message = 'Assertion failed';
if (opt_message) {
message = message + ': ' + opt_message;
}
const error = new Error(message);
const global = function() {
const thisOrSelf = this || self;
/** @type {boolean} */
thisOrSelf.traceAssertionsForTesting;
return thisOrSelf;
}();
if (global.traceAssertionsForTesting) {
console.warn(error.stack);
}
throw error;
}
return condition;
}
/**
* Note: This method is deprecated. Use the equivalent method in assert_ts.ts
* instead.
* Call this from places in the code that should never be reached.
*
* For example, handling all the values of enum with a switch() like this:
*
* function getValueFromEnum(enum) {
* switch (enum) {
* case ENUM_FIRST_OF_TWO:
* return first
* case ENUM_LAST_OF_TWO:
* return last;
* }
* assertNotReached();
* return document;
* }
*
* This code should only be hit in the case of serious programmer error or
* unexpected input.
*
* @param {string=} message A message to show when this is hit.
* @closurePrimitive {asserts.fail}
*/
function assertNotReached(message) {
assert(false, message || 'Unreachable code hit');
}
/**
* @param {*} value The value to check.
* @param {function(new: T, ...)} type A user-defined constructor.
* @param {string=} message A message to show when this is hit.
* @return {T}
* @template T
*/
function assertInstanceof(value, type, message) {
// We don't use assert immediately here so that we avoid constructing an error
// message if we don't have to.
if (!(value instanceof type)) {
assertNotReached(
message ||
'Value ' + value + ' is not a[n] ' + (type.name || typeof type));
}
return value;
}
/**
* Alias for document.getElementById. Found elements must be HTMLElements.
* @param {string} id The ID of the element to find.
* @return {HTMLElement} The found element or null if not found.
*/
function $(id) {
// Disable getElementById restriction here, since we are instructing other
// places to re-use the $() that is defined here.
// eslint-disable-next-line no-restricted-properties
const el = document.getElementById(id);
return el ? assertInstanceof(el, HTMLElement) : null;
}
/**
* Return the first ancestor for which the {@code predicate} returns true.
* @param {Node} node The node to check.
* @param {function(Node):boolean} predicate The function that tests the
* nodes.
* @param {boolean=} includeShadowHosts
* @return {Node} The found ancestor or null if not found.
*/
function findAncestor(node, predicate, includeShadowHosts) {
while (node !== null) {
if (predicate(node)) {
break;
}
node = includeShadowHosts && node instanceof ShadowRoot ? node.host :
node.parentNode;
}
return node;
}
console.warn('crbug/1173575, non-JS module files deprecated.');
|
