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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
|
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/**
* Represents the detailed information about a form field, including
* the inferred field name, the approach used for inferring, and additional metadata.
*/
export class FieldDetail {
// Reference to the elemenet
elementWeakRef = null;
// The inferred field name for this element
fieldName = null;
// The approach we use to infer the information for this element
// The possible values are "autocomplete", "fathom", and "regex-heuristic"
reason = null;
/*
* The "section", "addressType", and "contactType" values are
* used to identify the exact field when the serializable data is received
* from the backend. There cannot be multiple fields which have
* the same exact combination of these values.
*/
// Which section the field belongs to. The value comes from autocomplete attribute.
// See https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofill-detail-tokens for more details
section = "";
addressType = "";
contactType = "";
// When a field is split into N fields, we use part to record which field it is
// For example, a credit card number field is split into 4 fields, the value of
// "part" for the first cc-number field is 1, for the last one is 4.
// If the field is not split, the value is null
part = null;
// Confidence value when the field name is inferred by "fathom"
confidence = null;
constructor(
element,
fieldName,
{ autocompleteInfo = {}, confidence = null }
) {
this.elementWeakRef = Cu.getWeakReference(element);
this.fieldName = fieldName;
if (autocompleteInfo) {
this.reason = "autocomplete";
this.section = autocompleteInfo.section;
this.addressType = autocompleteInfo.addressType;
this.contactType = autocompleteInfo.contactType;
} else if (confidence) {
this.reason = "fathom";
this.confidence = confidence;
} else {
this.reason = "regex-heuristic";
}
}
get element() {
return this.elementWeakRef.get();
}
get sectionName() {
return this.section || this.addressType;
}
}
/**
* A scanner for traversing all elements in a form. It also provides a
* cursor (parsingIndex) to indicate which element is waiting for parsing.
*
* The scanner retrives the field detail by calling heuristics handlers
* `inferFieldInfo` function.
*/
export class FieldScanner {
#elementsWeakRef = null;
#inferFieldInfoFn = null;
#parsingIndex = 0;
fieldDetails = [];
/**
* Create a FieldScanner based on form elements with the existing
* fieldDetails.
*
* @param {Array.DOMElement} elements
* The elements from a form for each parser.
* @param {Funcion} inferFieldInfoFn
* The callback function that is used to infer the field info of a given element
*/
constructor(elements, inferFieldInfoFn) {
this.#elementsWeakRef = Cu.getWeakReference(elements);
this.#inferFieldInfoFn = inferFieldInfoFn;
}
get #elements() {
return this.#elementsWeakRef.get();
}
/**
* This cursor means the index of the element which is waiting for parsing.
*
* @returns {number}
* The index of the element which is waiting for parsing.
*/
get parsingIndex() {
return this.#parsingIndex;
}
get parsingFinished() {
return this.parsingIndex >= this.#elements.length;
}
/**
* Move the parsingIndex to the next elements. Any elements behind this index
* means the parsing tasks are finished.
*
* @param {number} index
* The latest index of elements waiting for parsing.
*/
set parsingIndex(index) {
if (index > this.#elements.length) {
throw new Error("The parsing index is out of range.");
}
this.#parsingIndex = index;
}
/**
* Retrieve the field detail by the index. If the field detail is not ready,
* the elements will be traversed until matching the index.
*
* @param {number} index
* The index of the element that you want to retrieve.
* @returns {object}
* The field detail at the specific index.
*/
getFieldDetailByIndex(index) {
if (index >= this.#elements.length) {
throw new Error(
`The index ${index} is out of range.(${this.#elements.length})`
);
}
if (index < this.fieldDetails.length) {
return this.fieldDetails[index];
}
for (let i = this.fieldDetails.length; i < index + 1; i++) {
this.pushDetail();
}
return this.fieldDetails[index];
}
/**
* This function retrieves the first unparsed element and obtains its
* information by invoking the `inferFieldInfoFn` callback function.
* The field information is then stored in a FieldDetail object and
* appended to the `fieldDetails` array.
*
* Any element without the related detail will be used for adding the detail
* to the end of field details.
*/
pushDetail() {
const elementIndex = this.fieldDetails.length;
if (elementIndex >= this.#elements.length) {
throw new Error("Try to push the non-existing element info.");
}
const element = this.#elements[elementIndex];
const [fieldName, autocompleteInfo, confidence] =
this.#inferFieldInfoFn(element);
const fieldDetail = new FieldDetail(element, fieldName, {
autocompleteInfo,
confidence,
});
this.fieldDetails.push(fieldDetail);
}
/**
* When a field detail should be changed its fieldName after parsing, use
* this function to update the fieldName which is at a specific index.
*
* @param {number} index
* The index indicates a field detail to be updated.
* @param {string} fieldName
* The new fieldName
* @param {string} reason
* What approach we use to identify this field
*/
updateFieldName(index, fieldName, reason = null) {
if (index >= this.fieldDetails.length) {
throw new Error("Try to update the non-existing field detail.");
}
this.fieldDetails[index].fieldName = fieldName;
if (reason) {
this.fieldDetails[index].reason = reason;
}
}
elementExisting(index) {
return index < this.#elements.length;
}
}
export default FieldScanner;
|
