@oslokommune/punkt-testing-utils 16.7.3 → 16.7.6
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.
|
@@ -1,321 +1,251 @@
|
|
|
1
1
|
import { getElementError } from "@testing-library/dom";
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
2
|
+
//#region src/index.ts
|
|
3
|
+
var PKT_CUSTOM_FORMFIELDS = [
|
|
4
|
+
"pkt-backlink",
|
|
5
|
+
"pkt-checkbox",
|
|
6
|
+
"pkt-combobox",
|
|
7
|
+
"pkt-progressbar",
|
|
8
|
+
"pkt-radiobutton",
|
|
9
|
+
"pkt-select",
|
|
10
|
+
"pkt-textarea",
|
|
11
|
+
"pkt-textinput"
|
|
11
12
|
];
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
13
|
+
var PKT_CUSTOM_ELEMENTS = [
|
|
14
|
+
"pkt-input-wrapper",
|
|
15
|
+
"pkt-icon",
|
|
16
|
+
"pkt-helptext",
|
|
17
|
+
"pkt-loader",
|
|
18
|
+
"pkt-backlink",
|
|
19
|
+
...PKT_CUSTOM_FORMFIELDS
|
|
19
20
|
];
|
|
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
|
-
try {
|
|
118
|
-
const queryFunc = syncQueryFunctionResolver(testingLibrary)(query);
|
|
119
|
-
const innerElement = doElementSearch(identifier, query, queryFunc, container)[0];
|
|
120
|
-
return findPossibleWrappingPktCustomElement(testingLibrary)(innerElement, false, []);
|
|
121
|
-
} catch (e) {
|
|
122
|
-
return fallbackSearchForPktSelectByLabel()(identifier, query, container);
|
|
123
|
-
}
|
|
124
|
-
};
|
|
125
|
-
const removeElementBySelector = (ancestor, selector) => {
|
|
126
|
-
const elements = Array.from(ancestor.querySelectorAll(selector));
|
|
127
|
-
elements.forEach((element) => {
|
|
128
|
-
var _a;
|
|
129
|
-
(_a = element.parentNode) == null ? void 0 : _a.removeChild(element);
|
|
130
|
-
});
|
|
21
|
+
var setupPktTestingLibrary = (options) => {
|
|
22
|
+
const tools = {
|
|
23
|
+
fireEvent: options.fireEvent,
|
|
24
|
+
findAllByLabelText: options.findAllByLabelText,
|
|
25
|
+
findAllByDisplayValue: options.findAllByDisplayValue,
|
|
26
|
+
findAllByTestId: options.findAllByTestId,
|
|
27
|
+
findAllByText: options.findAllByText,
|
|
28
|
+
getAllByLabelText: options.getAllByLabelText,
|
|
29
|
+
getAllByDisplayValue: options.getAllByDisplayValue,
|
|
30
|
+
getAllByTestId: options.getAllByTestId,
|
|
31
|
+
getAllByText: options.getAllByText
|
|
32
|
+
};
|
|
33
|
+
return {
|
|
34
|
+
findPktElementByLabelText: withTestingLibrary(tools, findPktElementByLabel),
|
|
35
|
+
waitForPktElementsToBeDefined,
|
|
36
|
+
getPktElementByLabelText: withTestingLibrary(tools, getPktElementByLabel),
|
|
37
|
+
setPktElementChecked: withTestingLibrary(tools, setPktElementChecked),
|
|
38
|
+
isPktElementChecked: withTestingLibrary(tools, isPktElementChecked),
|
|
39
|
+
getPktSelectOptions: withTestingLibrary(tools, getPktSelectOptions),
|
|
40
|
+
getAllPktElementsByLabelText: withTestingLibrary(tools, getAllPktElementsByLabelText),
|
|
41
|
+
setPktElementValue: withTestingLibrary(tools, setPktElementValue),
|
|
42
|
+
pktClickButton: withTestingLibrary(tools, pktClickButton),
|
|
43
|
+
setPktSelectedOptionsByLabel: withTestingLibrary(tools, setPktSelectedOptionsByLabel),
|
|
44
|
+
getPktElementByDisplayValue: withTestingLibrary(tools, getPktElementByDisplayValue),
|
|
45
|
+
findPktElementByDisplayValue: withTestingLibrary(tools, findPktElementByDisplayValue)
|
|
46
|
+
};
|
|
47
|
+
};
|
|
48
|
+
var syncQueryFunctionResolver = (testingLibrary) => (queryType) => {
|
|
49
|
+
const query = {
|
|
50
|
+
text: testingLibrary.getAllByText,
|
|
51
|
+
label: testingLibrary.getAllByLabelText,
|
|
52
|
+
testid: testingLibrary.getAllByTestId,
|
|
53
|
+
displayValue: testingLibrary.getAllByDisplayValue
|
|
54
|
+
}[queryType];
|
|
55
|
+
if (query) return query;
|
|
56
|
+
else throw new Error("Unsupported query type: " + queryType);
|
|
57
|
+
};
|
|
58
|
+
var asyncQueryFunctionResolver = (testingLibrary) => (queryType) => {
|
|
59
|
+
const query = {
|
|
60
|
+
text: testingLibrary.findAllByText,
|
|
61
|
+
label: testingLibrary.findAllByLabelText,
|
|
62
|
+
testid: testingLibrary.findAllByTestId,
|
|
63
|
+
displayValue: testingLibrary.findAllByDisplayValue
|
|
64
|
+
}[queryType];
|
|
65
|
+
if (query) return query;
|
|
66
|
+
else throw new Error("Unsupported query type: " + queryType);
|
|
67
|
+
};
|
|
68
|
+
var syncResolveIdentifierOrElement = (testingLibrary) => (elementOrIdentifier, query) => typeof elementOrIdentifier === "string" || elementOrIdentifier instanceof RegExp ? getPktElementBy(testingLibrary)(query, elementOrIdentifier) : elementOrIdentifier;
|
|
69
|
+
var getByLabelElement = (possibleLabelElement) => {
|
|
70
|
+
const control = possibleLabelElement instanceof HTMLLabelElement && possibleLabelElement.control;
|
|
71
|
+
if (control) return control;
|
|
72
|
+
else throw new Error("Fant ikke noe skjema-element for labelen: " + possibleLabelElement.outerHTML);
|
|
73
|
+
};
|
|
74
|
+
var asyncResolveIdentifierOrElement = (testingLibrary) => async (elementOrIdentifier, query) => elementOrIdentifier instanceof HTMLLabelElement && getByLabelElement(elementOrIdentifier) || (typeof elementOrIdentifier === "string" || elementOrIdentifier instanceof RegExp ? await findPktElementBy(testingLibrary)(query, elementOrIdentifier) : elementOrIdentifier);
|
|
75
|
+
var asyncFuncWithStringIdentifierOrElement = (testingLibrary) => (func, query = "label") => {
|
|
76
|
+
return async (labelOrPktElement, ...restArgs) => {
|
|
77
|
+
return await func(await asyncResolveIdentifierOrElement(testingLibrary)(labelOrPktElement, query), ...restArgs);
|
|
78
|
+
};
|
|
79
|
+
};
|
|
80
|
+
var syncFuncWithStringIdentifierOrElement = (testingLibrary) => (func, query = "label") => {
|
|
81
|
+
return (labelOrPktElement, ...restArgs) => {
|
|
82
|
+
return func(syncResolveIdentifierOrElement(testingLibrary)(labelOrPktElement, query), ...restArgs);
|
|
83
|
+
};
|
|
84
|
+
};
|
|
85
|
+
var withTestingLibrary = (testingLibrary, fn) => fn(testingLibrary);
|
|
86
|
+
/**
|
|
87
|
+
* Sørger for at alle brukte custom elements fra Punkt er definerte og erstattet med implementasjoner.
|
|
88
|
+
* Bør kalles etter `render`, før noen operasjoner og antakelser gjøres.
|
|
89
|
+
*
|
|
90
|
+
* F.eks.:
|
|
91
|
+
* <code>
|
|
92
|
+
* render(<div><PktTextinput id="textinput" name={'textInput'} label="My text input" aria-label="My text input" /></div>);
|
|
93
|
+
* await waitForPktElementsToBeDefined();
|
|
94
|
+
*
|
|
95
|
+
* await setPktElementValue("My text input", "new value");
|
|
96
|
+
* </code>
|
|
97
|
+
*/
|
|
98
|
+
var waitForPktElementsToBeDefined = async () => await Promise.all(PKT_CUSTOM_ELEMENTS.map((elementName) => {
|
|
99
|
+
if (document.querySelector(elementName) !== null) return window.customElements.whenDefined(elementName);
|
|
100
|
+
}).filter((promise) => promise));
|
|
101
|
+
var findPossibleWrappingPktCustomElement = (testingLibrary) => (innerElement, isByRole, args) => {
|
|
102
|
+
const pktElement = innerElement?.closest(PKT_CUSTOM_FORMFIELDS.join(", "));
|
|
103
|
+
if (pktElement) return pktElement;
|
|
104
|
+
else return innerElement;
|
|
105
|
+
};
|
|
106
|
+
var getPktElementBy = (testingLibrary) => (query = "label", identifier, container) => {
|
|
107
|
+
try {
|
|
108
|
+
const innerElement = doElementSearch(identifier, query, syncQueryFunctionResolver(testingLibrary)(query), container)[0];
|
|
109
|
+
return findPossibleWrappingPktCustomElement(testingLibrary)(innerElement, false, []);
|
|
110
|
+
} catch (e) {
|
|
111
|
+
return fallbackSearchForPktSelectByLabel(testingLibrary)(identifier, query, container);
|
|
112
|
+
}
|
|
113
|
+
};
|
|
114
|
+
var removeElementBySelector = (ancestor, selector) => {
|
|
115
|
+
Array.from(ancestor.querySelectorAll(selector)).forEach((element) => {
|
|
116
|
+
element.parentNode?.removeChild(element);
|
|
117
|
+
});
|
|
131
118
|
};
|
|
132
119
|
function getPureLabelText(label) {
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
return ((_a = clonedLabel.textContent) == null ? void 0 : _a.trim()) || null;
|
|
120
|
+
const clonedLabel = label.cloneNode(true);
|
|
121
|
+
removeElementBySelector(clonedLabel, "pkt-helptext");
|
|
122
|
+
removeElementBySelector(clonedLabel, ".pkt-input-suffix");
|
|
123
|
+
removeElementBySelector(clonedLabel, ".pkt-input-prefix");
|
|
124
|
+
removeElementBySelector(clonedLabel, ".pkt-input-icon");
|
|
125
|
+
removeElementBySelector(clonedLabel, ".pkt-input__counter");
|
|
126
|
+
removeElementBySelector(clonedLabel, "option");
|
|
127
|
+
removeElementBySelector(clonedLabel, "pkt-listbox");
|
|
128
|
+
removeElementBySelector(clonedLabel, ".pkt-alert--error");
|
|
129
|
+
removeElementBySelector(clonedLabel, ".pkt-tag");
|
|
130
|
+
removeElementBySelector(clonedLabel, ".pkt-input-check__input-helptext");
|
|
131
|
+
removeElementBySelector(clonedLabel, ".pkt-inputwrapper__helptext");
|
|
132
|
+
return clonedLabel.textContent?.trim() || null;
|
|
147
133
|
}
|
|
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
|
-
if (!("checked" in element)) {
|
|
196
|
-
throw new Error('Bare elementer som har en "checked"-attributt støttes');
|
|
197
|
-
}
|
|
198
|
-
let returnValue = false;
|
|
199
|
-
if (element.tagName === "INPUT") {
|
|
200
|
-
const htmlInputElement = element;
|
|
201
|
-
if (htmlInputElement.type === "radio") {
|
|
202
|
-
if (!checked) {
|
|
203
|
-
throw new Error("Kan ikke av-velge en <input type='radio'> - prøv å velge en annen radioknapp i samme gruppe");
|
|
204
|
-
} else {
|
|
205
|
-
returnValue = testingLibrary.fireEvent.click(element);
|
|
206
|
-
await new Promise((resolve) => setTimeout(resolve, 0));
|
|
207
|
-
}
|
|
208
|
-
} else if (htmlInputElement.type === "checkbox") {
|
|
209
|
-
if (htmlInputElement.checked !== checked) {
|
|
210
|
-
returnValue = testingLibrary.fireEvent.click(element);
|
|
211
|
-
}
|
|
212
|
-
}
|
|
213
|
-
} else {
|
|
214
|
-
returnValue = testingLibrary.fireEvent.change(element, { target: { checked } });
|
|
215
|
-
}
|
|
216
|
-
return Promise.resolve(returnValue);
|
|
134
|
+
var getPureLabelTextForLabelOwner = (labelOwner) => {
|
|
135
|
+
const label = "labels" in labelOwner && labelOwner.labels instanceof NodeList && labelOwner.labels.length > 0 && labelOwner.labels[0] || ["input", ...PKT_CUSTOM_FORMFIELDS].includes(labelOwner.tagName.toLowerCase()) && labelOwner.querySelector("label") || null;
|
|
136
|
+
if (label) return getPureLabelText(label);
|
|
137
|
+
else return null;
|
|
138
|
+
};
|
|
139
|
+
var labelMatcher = (labelTextToMatch) => (nodeContent, element) => {
|
|
140
|
+
if (element instanceof HTMLElement) return getPureLabelTextForLabelOwner(element) === labelTextToMatch;
|
|
141
|
+
else return false;
|
|
142
|
+
};
|
|
143
|
+
var fallbackSearchForPktSelectByLabel = (testingLibrary) => (identifier, query, container = document.body) => {
|
|
144
|
+
if (typeof identifier === "string" && query === "label") {
|
|
145
|
+
const matchingLabel = Array.from(container.querySelectorAll("label")).find((labelElement) => getPureLabelText(labelElement) === identifier);
|
|
146
|
+
const labelOwner = matchingLabel?.control || matchingLabel?.closest("pkt-select") || matchingLabel?.closest("pkt-combobox");
|
|
147
|
+
if (!labelOwner) throw getElementError(`Fant ikke noe element med label "${identifier}"`, container);
|
|
148
|
+
return labelOwner;
|
|
149
|
+
}
|
|
150
|
+
throw getElementError(`Fant ikke noe element med ${query} "${identifier}"`, container);
|
|
151
|
+
};
|
|
152
|
+
var doElementSearch = (identifier, query, queryFunc, container = document.body) => {
|
|
153
|
+
return identifier instanceof HTMLLabelElement ? getByLabelElement(identifier) : typeof identifier === "string" && query === "label" ? queryFunc(container, labelMatcher(identifier.trim())) : queryFunc(container, identifier);
|
|
154
|
+
};
|
|
155
|
+
var findPktElementBy = (testingLibrary) => async (query = "label", identifier, container) => {
|
|
156
|
+
try {
|
|
157
|
+
if (identifier instanceof HTMLLabelElement) return Promise.resolve(getByLabelElement(identifier));
|
|
158
|
+
const innerElement = (await doElementSearch(identifier, query, asyncQueryFunctionResolver(testingLibrary)(query), container))[0];
|
|
159
|
+
return Promise.resolve(findPossibleWrappingPktCustomElement(testingLibrary)(innerElement, false, []));
|
|
160
|
+
} catch (e) {
|
|
161
|
+
return fallbackSearchForPktSelectByLabel(testingLibrary)(identifier, query, container);
|
|
162
|
+
}
|
|
163
|
+
};
|
|
164
|
+
var getPktElementByLabel = (testingLibrary) => (label, container) => label instanceof HTMLLabelElement ? getByLabelElement(label) : getPktElementBy(testingLibrary)("label", label, container);
|
|
165
|
+
var findPktElementByLabel = (testingLibrary) => async (label, container) => label instanceof HTMLLabelElement ? getByLabelElement(label) : findPktElementBy(testingLibrary)("label", label, container);
|
|
166
|
+
var setPktElementChecked = (testingLibrary) => asyncFuncWithStringIdentifierOrElement(testingLibrary)(async (element, checked) => {
|
|
167
|
+
if (!("checked" in element)) throw new Error("Bare elementer som har en \"checked\"-attributt støttes");
|
|
168
|
+
let returnValue = false;
|
|
169
|
+
if (element.tagName === "INPUT") {
|
|
170
|
+
const htmlInputElement = element;
|
|
171
|
+
if (htmlInputElement.type === "radio") if (!checked) throw new Error("Kan ikke av-velge en <input type='radio'> - prøv å velge en annen radioknapp i samme gruppe");
|
|
172
|
+
else {
|
|
173
|
+
returnValue = testingLibrary.fireEvent.click(element);
|
|
174
|
+
await new Promise((resolve) => setTimeout(resolve, 0));
|
|
175
|
+
}
|
|
176
|
+
else if (htmlInputElement.type === "checkbox") {
|
|
177
|
+
if (htmlInputElement.checked !== checked) returnValue = testingLibrary.fireEvent.click(element);
|
|
178
|
+
}
|
|
179
|
+
} else returnValue = testingLibrary.fireEvent.change(element, { target: { checked } });
|
|
180
|
+
return Promise.resolve(returnValue);
|
|
217
181
|
});
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
const
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
|
|
230
|
-
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
|
|
243
|
-
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
|
|
261
|
-
|
|
262
|
-
|
|
263
|
-
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
273
|
-
|
|
274
|
-
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
}
|
|
278
|
-
if (options.useChangeEventForNative) {
|
|
279
|
-
testingLibrary.fireEvent.change(element, { target: { value: valueOrValues } });
|
|
280
|
-
}
|
|
281
|
-
return Promise.resolve(true);
|
|
282
|
-
}
|
|
283
|
-
}
|
|
284
|
-
);
|
|
285
|
-
const containsRadioInput = (element) => {
|
|
286
|
-
var _a;
|
|
287
|
-
if (element.tagName === "INPUT" && element.type === "radio") return true;
|
|
288
|
-
if ((_a = element.querySelector) == null ? void 0 : _a.call(element, 'input[type="radio"]')) return true;
|
|
289
|
-
if (element.tagName === "LABEL") {
|
|
290
|
-
const label = element;
|
|
291
|
-
const control = label.control || (label.htmlFor ? document.getElementById(label.htmlFor) : null);
|
|
292
|
-
return !!(control && control.type === "radio");
|
|
293
|
-
}
|
|
294
|
-
return false;
|
|
295
|
-
};
|
|
296
|
-
const pktClickButton = (testingLibrary) => asyncFuncWithStringIdentifierOrElement(testingLibrary)(async (element) => {
|
|
297
|
-
if (containsRadioInput(element)) {
|
|
298
|
-
throw new Error("Klikk på <pkt-radiobutton> støttes ikke - bruk setPktElementChecked i stedet");
|
|
299
|
-
}
|
|
300
|
-
return testingLibrary.fireEvent.click(element);
|
|
182
|
+
var isPktElementChecked = (testingLibrary) => (target) => {
|
|
183
|
+
const element = syncResolveIdentifierOrElement(testingLibrary)(target, "label");
|
|
184
|
+
if ("checked" in element) return !!element.checked;
|
|
185
|
+
return element.querySelector("input[type=\"radio\"]:checked, input[type=\"checkbox\"]:checked") !== null;
|
|
186
|
+
};
|
|
187
|
+
var getPktElementByDisplayValue = (testingLibrary) => (text, container) => getPktElementBy(testingLibrary)("displayValue", text, container);
|
|
188
|
+
var findPktElementByDisplayValue = (testingLibrary) => (text, container) => findPktElementBy(testingLibrary)("displayValue", text, container);
|
|
189
|
+
var getPktSelectOptions = (testingLibrary) => syncFuncWithStringIdentifierOrElement(testingLibrary)((selectElement, onlySelected) => {
|
|
190
|
+
const optionElements = Array.from(selectElement.querySelectorAll("option:not(.pkt-hide), data:not(.pkt.hide)"));
|
|
191
|
+
const filter = onlySelected ? ([, , selected]) => selected : (_) => true;
|
|
192
|
+
const currentValue = selectElement.value;
|
|
193
|
+
return optionElements.map((optionElement) => [
|
|
194
|
+
optionElement.value,
|
|
195
|
+
optionElement.textContent?.trim(),
|
|
196
|
+
optionElement.value === currentValue
|
|
197
|
+
]).filter(filter);
|
|
198
|
+
});
|
|
199
|
+
var getAllPktElementsByLabelText = (testingLibrary) => (label, container) => {
|
|
200
|
+
return testingLibrary.getAllByLabelText(container || document.body, label).map((element) => findPossibleWrappingPktCustomElement(testingLibrary)(element, false, []));
|
|
201
|
+
};
|
|
202
|
+
var setPktElementValue = (testingLibrary) => asyncFuncWithStringIdentifierOrElement(testingLibrary)(async (element, valueOrValues, optionsOrUseInputEvent = false) => {
|
|
203
|
+
const options = typeof optionsOrUseInputEvent === "object" ? optionsOrUseInputEvent : optionsOrUseInputEvent && {
|
|
204
|
+
useInputEventForNative: true,
|
|
205
|
+
useChangeEventForNative: true,
|
|
206
|
+
setValuePropForNative: true
|
|
207
|
+
} || {
|
|
208
|
+
useInputEventForNative: false,
|
|
209
|
+
useChangeEventForNative: true,
|
|
210
|
+
setValuePropForNative: false
|
|
211
|
+
};
|
|
212
|
+
if (Array.isArray(valueOrValues) && valueOrValues.length > 1 && element.tagName === "PKT-SELECT") throw new Error("Multi-verdi <pkt-select> støttes ikke. Bruk <pkt-combobox> i stedet.");
|
|
213
|
+
if (element.tagName === "PKT-SELECT" || element.tagName === "PKT-COMBOBOX") {
|
|
214
|
+
const multiple = element.multiple;
|
|
215
|
+
const valueAsArray = Array.isArray(valueOrValues) ? valueOrValues : [valueOrValues];
|
|
216
|
+
const newValue = multiple && valueAsArray || valueAsArray.length == 0 && "" || valueAsArray[0];
|
|
217
|
+
testingLibrary.fireEvent.change(element, { target: { value: newValue } });
|
|
218
|
+
return Promise.resolve(true);
|
|
219
|
+
} else {
|
|
220
|
+
if (options.setValuePropForNative) {
|
|
221
|
+
if ("value" in element) element.value = valueOrValues.toString();
|
|
222
|
+
}
|
|
223
|
+
if (options.useInputEventForNative) testingLibrary.fireEvent.input(element, { target: { value: valueOrValues } });
|
|
224
|
+
if (options.useChangeEventForNative) testingLibrary.fireEvent.change(element, { target: { value: valueOrValues } });
|
|
225
|
+
return Promise.resolve(true);
|
|
226
|
+
}
|
|
227
|
+
});
|
|
228
|
+
var containsRadioInput = (element) => {
|
|
229
|
+
if (element.tagName === "INPUT" && element.type === "radio") return true;
|
|
230
|
+
if (element.querySelector?.("input[type=\"radio\"]")) return true;
|
|
231
|
+
if (element.tagName === "LABEL") {
|
|
232
|
+
const label = element;
|
|
233
|
+
const control = label.control || (label.htmlFor ? document.getElementById(label.htmlFor) : null);
|
|
234
|
+
return !!(control && control.type === "radio");
|
|
235
|
+
}
|
|
236
|
+
return false;
|
|
237
|
+
};
|
|
238
|
+
var pktClickButton = (testingLibrary) => asyncFuncWithStringIdentifierOrElement(testingLibrary)(async (element) => {
|
|
239
|
+
if (containsRadioInput(element)) throw new Error("Klikk på <pkt-radiobutton> støttes ikke - bruk setPktElementChecked i stedet");
|
|
240
|
+
return testingLibrary.fireEvent.click(element);
|
|
301
241
|
}, "text");
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
pktSelect,
|
|
313
|
-
selectedOptions.map(([value]) => value)
|
|
314
|
-
);
|
|
315
|
-
}
|
|
316
|
-
);
|
|
317
|
-
export {
|
|
318
|
-
PKT_CUSTOM_FORMFIELDS,
|
|
319
|
-
setupPktTestingLibrary
|
|
320
|
-
};
|
|
321
|
-
//# sourceMappingURL=punkt-testing-utils.es.js.map
|
|
242
|
+
var setPktSelectedOptionsByLabel = (testingLibrary) => asyncFuncWithStringIdentifierOrElement(testingLibrary)(async (pktSelect, ...desiredOptionLabels) => {
|
|
243
|
+
const availableOptions = getPktSelectOptions(testingLibrary)(pktSelect);
|
|
244
|
+
const selectedOptions = desiredOptionLabels.map((optionLabel) => availableOptions.find(([_, label]) => label === optionLabel)).filter((possibleOption) => possibleOption);
|
|
245
|
+
if (selectedOptions.length !== desiredOptionLabels.length) throw new Error("Noen av option'ene finnes ikke i denne komponenten. Du valgte " + JSON.stringify(desiredOptionLabels) + ", mens valgmulighetene er " + JSON.stringify(availableOptions.map(([, label]) => label)));
|
|
246
|
+
return await setPktElementValue(testingLibrary)(pktSelect, selectedOptions.map(([value]) => value));
|
|
247
|
+
});
|
|
248
|
+
//#endregion
|
|
249
|
+
export { PKT_CUSTOM_FORMFIELDS, setupPktTestingLibrary };
|
|
250
|
+
|
|
251
|
+
//# sourceMappingURL=punkt-testing-utils.es.js.map
|