@cat-of-summer/st-script 1.1.1 → 1.3.0
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.
- package/dist/loader.esm.min.js +1 -1
- package/dist/loader.esm.min.js.map +1 -1
- package/dist/loader.min.js +1 -1
- package/dist/loader.min.js.map +1 -1
- package/dist/mask.esm.min.js +1 -1
- package/dist/mask.esm.min.js.map +4 -4
- package/dist/mask.min.js +1 -1
- package/dist/mask.min.js.map +4 -4
- package/dist/modal.esm.min.js +1 -1
- package/dist/modal.esm.min.js.map +3 -3
- package/dist/modal.min.js +1 -1
- package/dist/modal.min.js.map +3 -3
- package/dist/observer.esm.min.js +1 -1
- package/dist/observer.esm.min.js.map +1 -1
- package/dist/observer.min.js +1 -1
- package/dist/observer.min.js.map +1 -1
- package/dist/route.esm.min.js.map +2 -2
- package/dist/route.min.js.map +2 -2
- package/dist/select.esm.min.js +1 -1
- package/dist/select.esm.min.js.map +3 -3
- package/dist/select.min.js +1 -1
- package/dist/select.min.js.map +3 -3
- package/dist/toggle.esm.min.js +1 -1
- package/dist/toggle.esm.min.js.map +3 -3
- package/dist/toggle.min.js +1 -1
- package/dist/toggle.min.js.map +3 -3
- package/dist/typograf.esm.min.js +1 -1
- package/dist/typograf.esm.min.js.map +1 -1
- package/dist/typograf.min.js +1 -1
- package/dist/typograf.min.js.map +1 -1
- package/dist/uploader.esm.min.js +1 -1
- package/dist/uploader.esm.min.js.map +3 -3
- package/dist/uploader.min.js +1 -1
- package/dist/uploader.min.js.map +3 -3
- package/dist/validator.esm.min.js +1 -1
- package/dist/validator.esm.min.js.map +3 -3
- package/dist/validator.min.js +1 -1
- package/dist/validator.min.js.map +3 -3
- package/package.json +1 -1
- package/src/_traits/hasInstanceSymbol.js +16 -0
- package/src/mask/_engine.js +46 -14
- package/src/mask/_groups.js +84 -0
- package/src/mask/index.js +282 -104
- package/src/modal/index.js +69 -15
- package/src/select/index.js +57 -12
- package/src/toggle/index.js +24 -9
- package/src/uploader/index.js +22 -8
- package/src/validator/index.js +21 -4
|
@@ -0,0 +1,84 @@
|
|
|
1
|
+
// Группы маски поверх раскладки фиксированного шаблона: какие слоты к какой группе относятся
|
|
2
|
+
// и как группа ведёт себя при наборе в режиме edit: 'whole' (как поле <input type=date>).
|
|
3
|
+
// Чистые функции без DOM. Ячейки группы - массив символов, пустая ячейка - null
|
|
4
|
+
|
|
5
|
+
const OPTIONS = ['edit', 'pad', 'align', 'min', 'max'];
|
|
6
|
+
|
|
7
|
+
// Группы по порядку слотов: подряд идущие слоты с одним именем - одна группа. Слоты вне
|
|
8
|
+
// именованных групп собираются в неявные группы (имя null); у шаблона без групп это всё поле.
|
|
9
|
+
// Настройки группы - параметры верхнего уровня, переопределённые params.groups[имя]
|
|
10
|
+
export function spans(layout, params) {
|
|
11
|
+
let list = [];
|
|
12
|
+
|
|
13
|
+
layout.slots.forEach((slot, i) => {
|
|
14
|
+
let name = slot.node.group ?? null, g = list.at(-1);
|
|
15
|
+
if (!g || g.name !== name) {
|
|
16
|
+
let opts = Object.fromEntries(OPTIONS.map(key => [key, params[key]]));
|
|
17
|
+
if (name != null) Object.assign(opts, params.groups?.[name]);
|
|
18
|
+
list.push(g = { name, first: i, fmts: [], digits: true, opts });
|
|
19
|
+
}
|
|
20
|
+
g.fmts.push(slot.fmt);
|
|
21
|
+
g.last = i;
|
|
22
|
+
g.digits &&= slot.node.test.test('0') && !slot.node.test.test('a');
|
|
23
|
+
});
|
|
24
|
+
|
|
25
|
+
for (let g of list) [g.start, g.end] = [g.fmts[0], g.fmts.at(-1) + 1];
|
|
26
|
+
return list;
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
// Текст группы → ячейки: выравнивание по align, недостающие ячейки - pad или пусто
|
|
30
|
+
export function fit(g, text) {
|
|
31
|
+
let n = g.fmts.length, chars = [...text].slice(-n);
|
|
32
|
+
let rest = Array(n - chars.length).fill(g.opts.pad ?? null);
|
|
33
|
+
return g.opts.align == 'right' ? [...rest, ...chars] : [...chars, ...rest];
|
|
34
|
+
}
|
|
35
|
+
|
|
36
|
+
// Набор символа в группу с буфером, начатым при входе в неё: '1' → 01, '2' → 12.
|
|
37
|
+
// Число выше max зажимается; переход дальше - когда буфер полон или следующая цифра
|
|
38
|
+
// гарантированно вывела бы за max (4 в дне: 40 > 31 - значит, 04)
|
|
39
|
+
export function type_ahead(g, buffer, char) {
|
|
40
|
+
let { max } = g.opts, ranged = g.digits && max != null;
|
|
41
|
+
buffer += char;
|
|
42
|
+
if (ranged && +buffer > max) buffer = String(max);
|
|
43
|
+
|
|
44
|
+
return {
|
|
45
|
+
buffer,
|
|
46
|
+
cells: fit(g, buffer),
|
|
47
|
+
advance: buffer.length >= g.fmts.length || ranged && +buffer * 10 > max
|
|
48
|
+
};
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
// При уходе из группы: заполненное число ниже min поднимается до min (00 в дне → 01)
|
|
52
|
+
export function settle(g, cells) {
|
|
53
|
+
let { min } = g.opts, n = g.fmts.length;
|
|
54
|
+
if (!g.digits || min == null || cells.includes(null) || +cells.join('') >= min) return cells;
|
|
55
|
+
return fit(g, String(min).padStart(n, '0'));
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
// ↑/↓: шаг по кругу в пределах min…max (без них - 0…99…9). Пустая группа: ↑ → min, ↓ → max.
|
|
59
|
+
// У нецифровой группы шага нет - null
|
|
60
|
+
export function step(g, cells, dir) {
|
|
61
|
+
if (!g.digits) return null;
|
|
62
|
+
|
|
63
|
+
let n = g.fmts.length, text = cells.join('');
|
|
64
|
+
let { min = null, max = null } = g.opts;
|
|
65
|
+
min ??= 0;
|
|
66
|
+
max ??= 10 ** n - 1;
|
|
67
|
+
|
|
68
|
+
let v = text === '' ? (dir > 0 ? min : max) : +text + dir;
|
|
69
|
+
if (v > max) v = min;
|
|
70
|
+
else if (v < min) v = max;
|
|
71
|
+
|
|
72
|
+
return fit(g, String(v).padStart(n, '0'));
|
|
73
|
+
}
|
|
74
|
+
|
|
75
|
+
// Укладывается ли значение каждой группы в её min/max. Незаполненная или нецифровая
|
|
76
|
+
// группа диапазон не нарушает - за полноту отвечает сама маска
|
|
77
|
+
export function in_range(names, values, params) {
|
|
78
|
+
return (names.length ? names : [null]).every(name => {
|
|
79
|
+
let o = { min: params.min, max: params.max, ...(name != null && params.groups?.[name]) };
|
|
80
|
+
let v = values[name];
|
|
81
|
+
if (o.min == null && o.max == null || !/^\d+$/.test(v ?? '')) return true;
|
|
82
|
+
return (o.min == null || +v >= o.min) && (o.max == null || +v <= o.max);
|
|
83
|
+
});
|
|
84
|
+
}
|
package/src/mask/index.js
CHANGED
|
@@ -1,5 +1,6 @@
|
|
|
1
|
-
import { element, elements, expose, find, own } from '../_traits/hasInstanceSymbol.js';
|
|
2
|
-
import { build, run, run_all, render, caret_for, cap, prepare
|
|
1
|
+
import { disown, element, elements, expose, find, own } from '../_traits/hasInstanceSymbol.js';
|
|
2
|
+
import { build, run, run_all, render, caret_for, cap, prepare } from './_engine.js';
|
|
3
|
+
import { spans, type_ahead, settle, step, in_range } from './_groups.js';
|
|
3
4
|
|
|
4
5
|
const CALLBACKS = ['before_init', 'on_init', 'before_char', 'before_slot', 'before_input',
|
|
5
6
|
'on_input', 'before_paste', 'on_paste', 'on_accept', 'on_complete', 'on_incomplete', 'on_mask_change'];
|
|
@@ -37,6 +38,7 @@ export default class Mask {
|
|
|
37
38
|
#defs = null;
|
|
38
39
|
#states = new WeakMap();
|
|
39
40
|
#inputs = [];
|
|
41
|
+
#abort = new AbortController();
|
|
40
42
|
|
|
41
43
|
static find = find;
|
|
42
44
|
|
|
@@ -55,8 +57,12 @@ export default class Mask {
|
|
|
55
57
|
numeral: null,
|
|
56
58
|
filler: '_',
|
|
57
59
|
placeholder: true,
|
|
58
|
-
|
|
59
|
-
|
|
60
|
+
edit: 'free',
|
|
61
|
+
pad: null,
|
|
62
|
+
align: 'left',
|
|
63
|
+
min: null,
|
|
64
|
+
max: null,
|
|
65
|
+
groups: {},
|
|
60
66
|
caret: true,
|
|
61
67
|
coerce_type: true,
|
|
62
68
|
max_raw: null,
|
|
@@ -105,6 +111,26 @@ export default class Mask {
|
|
|
105
111
|
|
|
106
112
|
clear(target = this.#inputs) { this.set(target, ''); }
|
|
107
113
|
|
|
114
|
+
// Разобрать: снять обработчики (в том числе reset на форме) и вернуть полю то, что
|
|
115
|
+
// поменяла привязка: type (number/email), maxlength, caret-color. Значение остаётся.
|
|
116
|
+
destroy() {
|
|
117
|
+
this.#abort.abort();
|
|
118
|
+
|
|
119
|
+
for (let input of this.#inputs) {
|
|
120
|
+
let { original } = this.#states.get(input) ?? {};
|
|
121
|
+
if (original) {
|
|
122
|
+
if (input.type != original.type) input.type = original.type;
|
|
123
|
+
if (original.maxlength != null) input.setAttribute('maxlength', original.maxlength);
|
|
124
|
+
input.style.removeProperty('caret-color');
|
|
125
|
+
if (original.caret[0]) input.style.setProperty('caret-color', ...original.caret);
|
|
126
|
+
}
|
|
127
|
+
this.#states.delete(input);
|
|
128
|
+
disown(input, this, ['raw', 'state', 'set', 'clear', 'set_mask']);
|
|
129
|
+
}
|
|
130
|
+
|
|
131
|
+
this.#inputs = [];
|
|
132
|
+
}
|
|
133
|
+
|
|
108
134
|
#only() {
|
|
109
135
|
if (this.#inputs.length != 1)
|
|
110
136
|
throw new Error(`Mask: маска привязана к ${this.#inputs.length} полям — укажите поле явно`);
|
|
@@ -120,7 +146,7 @@ export default class Mask {
|
|
|
120
146
|
let st = this.#states.get(input);
|
|
121
147
|
if (!st) continue;
|
|
122
148
|
st.defs = defs;
|
|
123
|
-
st.
|
|
149
|
+
st.seg = null;
|
|
124
150
|
this.#reconcile(input, st.stream, {});
|
|
125
151
|
}
|
|
126
152
|
}
|
|
@@ -128,6 +154,7 @@ export default class Mask {
|
|
|
128
154
|
#base() {
|
|
129
155
|
return {
|
|
130
156
|
filler: this.#params.filler,
|
|
157
|
+
groups: this.#params.groups,
|
|
131
158
|
before_char: this.before_char,
|
|
132
159
|
before_slot: this.before_slot
|
|
133
160
|
};
|
|
@@ -145,6 +172,14 @@ export default class Mask {
|
|
|
145
172
|
if (find(input)) throw new Error("Маска уже привязана к этому полю");
|
|
146
173
|
own(input, this);
|
|
147
174
|
|
|
175
|
+
let signal = this.#abort.signal;
|
|
176
|
+
// Что поле теряет при привязке — destroy() вернёт.
|
|
177
|
+
let original = {
|
|
178
|
+
type: input.type,
|
|
179
|
+
maxlength: input.getAttribute('maxlength'),
|
|
180
|
+
caret: [input.style.getPropertyValue('caret-color'), input.style.getPropertyPriority('caret-color')],
|
|
181
|
+
};
|
|
182
|
+
|
|
148
183
|
let coerced = null;
|
|
149
184
|
if (this.#params.coerce_type !== false && (input.type == 'number' || input.type == 'email')) {
|
|
150
185
|
coerced = input.type;
|
|
@@ -168,7 +203,7 @@ export default class Mask {
|
|
|
168
203
|
}
|
|
169
204
|
|
|
170
205
|
let numeric = coerced == 'number' || this.#params.numeral != null;
|
|
171
|
-
let st = { defs, def: null, stream: '', result: null, mask_id: null, rendered: '',
|
|
206
|
+
let st = { defs, def: null, stream: '', result: null, mask_id: null, rendered: '', seg: null, composing: false, handled: false, coerced, max_raw, numeric, original };
|
|
172
207
|
this.#states.set(input, st);
|
|
173
208
|
this.#inputs.push(input);
|
|
174
209
|
|
|
@@ -184,12 +219,17 @@ export default class Mask {
|
|
|
184
219
|
&& input.style.setProperty('caret-color', 'transparent', 'important');
|
|
185
220
|
hide();
|
|
186
221
|
|
|
187
|
-
input.addEventListener('beforeinput', event => this.#before(input, event));
|
|
222
|
+
input.addEventListener('beforeinput', event => this.#before(input, event), { signal });
|
|
188
223
|
|
|
189
|
-
|
|
190
|
-
|
|
224
|
+
let edits = [this.#params.edit, ...Object.values(this.#params.groups ?? {}).map(g => g?.edit)];
|
|
225
|
+
if (edits.includes('whole') && (this.#params.placeholder != 'always' || defs.some(d => !d.fixed && !d.fn)))
|
|
226
|
+
console.warn("Mask: edit: 'whole' работает с фиксированной маской и placeholder: 'always' - иначе ведёт себя как 'end'", input);
|
|
227
|
+
|
|
228
|
+
if (edits.some(edit => edit && edit != 'free')) {
|
|
229
|
+
let pin = event => this.#pin(input, event.type == 'click');
|
|
191
230
|
for (let event of ['selectionchange', 'click', 'keyup', 'select'])
|
|
192
|
-
input.addEventListener(event, pin);
|
|
231
|
+
input.addEventListener(event, pin, { signal });
|
|
232
|
+
input.addEventListener('keydown', event => this.#key(input, event), { signal });
|
|
193
233
|
}
|
|
194
234
|
|
|
195
235
|
let refresh = () => {
|
|
@@ -197,19 +237,24 @@ export default class Mask {
|
|
|
197
237
|
if (st.composing) return;
|
|
198
238
|
this.#refresh(input);
|
|
199
239
|
};
|
|
200
|
-
input.addEventListener('input', refresh);
|
|
201
|
-
input.addEventListener('change', refresh);
|
|
240
|
+
input.addEventListener('input', refresh, { signal });
|
|
241
|
+
input.addEventListener('change', refresh, { signal });
|
|
202
242
|
|
|
203
|
-
input.addEventListener('compositionstart', () => st.composing = true);
|
|
204
|
-
input.addEventListener('compositionend', () => { st.composing = false; this.#refresh(input); });
|
|
243
|
+
input.addEventListener('compositionstart', () => st.composing = true, { signal });
|
|
244
|
+
input.addEventListener('compositionend', () => { st.composing = false; this.#refresh(input); }, { signal });
|
|
205
245
|
|
|
206
|
-
input.addEventListener('focus',
|
|
246
|
+
input.addEventListener('focus', event => {
|
|
207
247
|
hide();
|
|
208
248
|
this.#reconcile(input, st.stream, { prefix: st.stream, silent: true });
|
|
209
|
-
|
|
210
|
-
|
|
249
|
+
this.#enter(input, event.relatedTarget);
|
|
250
|
+
}, { signal });
|
|
251
|
+
input.addEventListener('blur', () => {
|
|
252
|
+
this.#settle(input);
|
|
253
|
+
st.seg = null;
|
|
254
|
+
this.#reconcile(input, st.stream, { silent: true });
|
|
255
|
+
}, { signal });
|
|
211
256
|
|
|
212
|
-
input.closest('form')?.addEventListener('reset', () => queueMicrotask(() => this.#refresh(input)));
|
|
257
|
+
input.closest('form')?.addEventListener('reset', () => queueMicrotask(() => this.#refresh(input)), { signal });
|
|
213
258
|
|
|
214
259
|
this.#reconcile(input, input.value, { silent: true });
|
|
215
260
|
}
|
|
@@ -226,9 +271,11 @@ export default class Mask {
|
|
|
226
271
|
if (type == 'historyUndo' || type == 'historyRedo') return;
|
|
227
272
|
|
|
228
273
|
let start = input.selectionStart ?? 0, end = input.selectionEnd ?? start;
|
|
274
|
+
let { g, edit } = this.#mode(st, start, end);
|
|
229
275
|
|
|
230
|
-
if (
|
|
231
|
-
start
|
|
276
|
+
if (edit == 'end' && st.result && !(start == 0 && end == input.value.length)
|
|
277
|
+
&& !(g && start == g.start && end == g.end))
|
|
278
|
+
start = end = this.#tail_of(input, st, g);
|
|
232
279
|
|
|
233
280
|
event.preventDefault();
|
|
234
281
|
st.handled = true;
|
|
@@ -256,9 +303,9 @@ export default class Mask {
|
|
|
256
303
|
|
|
257
304
|
let was = input.value;
|
|
258
305
|
|
|
259
|
-
this.#
|
|
260
|
-
|
|
261
|
-
|
|
306
|
+
if (edit == 'whole') this.#segment(input, type, is_delete ? '' : insert);
|
|
307
|
+
else if (this.#layout_of(st)) this.#grid(input, type, start, end, is_delete ? '' : insert);
|
|
308
|
+
else this.#edit(input, start, end, is_delete ? '' : insert, type);
|
|
262
309
|
|
|
263
310
|
if (type == 'insertFromPaste') this.on_paste(input, this.#state_of(input, st));
|
|
264
311
|
|
|
@@ -298,145 +345,272 @@ export default class Mask {
|
|
|
298
345
|
|
|
299
346
|
#grid(input, type, fmt_start, fmt_end, insert) {
|
|
300
347
|
let st = this.#states.get(input), def = st.def;
|
|
301
|
-
let layout =
|
|
302
|
-
let
|
|
303
|
-
let flow = this.#params.flow, rewrite = this.#params.rewrite;
|
|
348
|
+
let layout = this.#layout_of(st);
|
|
349
|
+
let { slots, parts } = layout, n = slots.length;
|
|
304
350
|
|
|
305
|
-
let cells =
|
|
351
|
+
let cells = this.#cells(st, layout);
|
|
306
352
|
|
|
307
353
|
let at = fmt => { let k = slots.findIndex(slot => slot.fmt >= fmt); return k < 0 ? n : k; };
|
|
308
354
|
let gap = i => layout.template.slice(slots[i - 1].fmt + 1, slots[i].fmt);
|
|
309
|
-
let k
|
|
355
|
+
let k;
|
|
310
356
|
|
|
311
357
|
if (fmt_start != fmt_end) {
|
|
312
358
|
k = at(fmt_start);
|
|
313
359
|
for (let i = k; i < n && slots[i].fmt < fmt_end; i++) cells[i] = null;
|
|
314
|
-
st.run = null;
|
|
315
360
|
} else if (!insert && type.startsWith('delete')) {
|
|
316
361
|
if (type.includes('Forward')) {
|
|
317
|
-
|
|
318
|
-
let limit = parts[k];
|
|
362
|
+
k = at(fmt_start);
|
|
319
363
|
while (k < n && cells[k] == null) k++;
|
|
320
|
-
if (k >= n
|
|
364
|
+
if (k >= n) return;
|
|
321
365
|
} else {
|
|
322
|
-
|
|
323
|
-
for (let i = 0; i < n; i++) if (slots[i].fmt < fmt_start)
|
|
324
|
-
if (edge < 0) return;
|
|
325
|
-
k = edge;
|
|
366
|
+
k = -1;
|
|
367
|
+
for (let i = 0; i < n; i++) if (slots[i].fmt < fmt_start) k = i;
|
|
326
368
|
while (k >= 0 && cells[k] == null) k--;
|
|
327
|
-
if (k < 0
|
|
369
|
+
if (k < 0) return;
|
|
328
370
|
}
|
|
329
371
|
cells[k] = null;
|
|
330
372
|
} else {
|
|
331
373
|
k = at(fmt_start);
|
|
332
374
|
if (k >= n && (k = cells.indexOf(null)) < 0) k = n;
|
|
333
|
-
|
|
375
|
+
}
|
|
376
|
+
|
|
377
|
+
for (let c of prepare(def, insert, { input })) {
|
|
378
|
+
if (k >= n) break;
|
|
334
379
|
|
|
335
|
-
if (
|
|
336
|
-
|
|
337
|
-
|
|
380
|
+
if (!slots[k].node.test.test(c)) {
|
|
381
|
+
// Разделитель следующего блока переводит набор в этот блок
|
|
382
|
+
let end = parts.lastIndexOf(parts[k]);
|
|
383
|
+
if (end + 1 < n && gap(end + 1).includes(c)) k = end + 1;
|
|
384
|
+
continue;
|
|
338
385
|
}
|
|
386
|
+
|
|
387
|
+
cells[k++] = c;
|
|
339
388
|
}
|
|
340
389
|
|
|
341
|
-
|
|
342
|
-
let
|
|
390
|
+
let stream = this.#stream(layout, cells);
|
|
391
|
+
let pos = Math.min(run(def, stream.slice(0, k), { input }).stream.length, n);
|
|
392
|
+
this.#reconcile(input, stream, { caret_fmt: pos < n ? slots[pos].fmt : slots[n - 1].fmt + 1 });
|
|
393
|
+
}
|
|
343
394
|
|
|
344
|
-
|
|
345
|
-
|
|
346
|
-
|
|
347
|
-
|
|
395
|
+
// edit: 'whole' - набор в выделенную группу как в <input type=date>: буфер группы
|
|
396
|
+
// начинается с нуля при входе в неё, заполненная группа передаёт набор следующей,
|
|
397
|
+
// разделитель закрывает группу досрочно, удаление очищает группу целиком
|
|
398
|
+
#segment(input, type, insert) {
|
|
399
|
+
let st = this.#states.get(input), layout = this.#layout_of(st), groups = layout.spans;
|
|
400
|
+
let seg = this.#seg(input, st);
|
|
401
|
+
let cells = this.#cells(st, layout);
|
|
402
|
+
let part = g => cells.slice(g.first, g.last + 1);
|
|
403
|
+
let put = (g, values) => cells.splice(g.first, values.length, ...values);
|
|
404
|
+
let g = groups[seg.gi];
|
|
405
|
+
|
|
406
|
+
if (type.startsWith('delete')) {
|
|
407
|
+
if (part(g).every(cell => cell == null)) {
|
|
408
|
+
if (type.includes('Backward') && seg.gi > 0) this.#select(input, seg.gi - 1);
|
|
409
|
+
return;
|
|
348
410
|
}
|
|
349
|
-
|
|
350
|
-
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
|
|
411
|
+
put(g, part(g).fill(null));
|
|
412
|
+
seg.buffer = '';
|
|
413
|
+
} else {
|
|
414
|
+
if (type == 'insertFromPaste') seg.buffer = '';
|
|
415
|
+
|
|
416
|
+
for (let c of prepare(st.def, insert, { input })) {
|
|
417
|
+
g = groups[seg.gi];
|
|
418
|
+
let next = groups[seg.gi + 1];
|
|
419
|
+
|
|
420
|
+
if (next && layout.template.slice(g.end, next.start).includes(c)) {
|
|
421
|
+
if (seg.buffer) {
|
|
422
|
+
put(g, settle(g, part(g)));
|
|
423
|
+
seg.gi++;
|
|
424
|
+
seg.buffer = '';
|
|
425
|
+
}
|
|
355
426
|
continue;
|
|
356
427
|
}
|
|
357
|
-
if (restart == null) continue;
|
|
358
|
-
k = parts.indexOf(restart);
|
|
359
|
-
}
|
|
360
428
|
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
|
|
429
|
+
let slot = layout.slots[g.first + Math.min(seg.buffer.length, g.fmts.length - 1)];
|
|
430
|
+
if (!slot.node.test.test(c)) continue;
|
|
431
|
+
|
|
432
|
+
let typed = type_ahead(g, seg.buffer, c);
|
|
433
|
+
put(g, typed.cells);
|
|
434
|
+
seg.buffer = typed.buffer;
|
|
435
|
+
|
|
436
|
+
if (typed.advance) {
|
|
437
|
+
put(g, settle(g, part(g)));
|
|
438
|
+
seg.buffer = '';
|
|
439
|
+
if (next) seg.gi++;
|
|
368
440
|
}
|
|
369
|
-
continue;
|
|
370
441
|
}
|
|
442
|
+
}
|
|
371
443
|
|
|
372
|
-
|
|
373
|
-
|
|
374
|
-
|
|
375
|
-
|
|
376
|
-
|
|
444
|
+
this.#reconcile(input, this.#stream(layout, cells), {});
|
|
445
|
+
this.#select(input, seg.gi, false);
|
|
446
|
+
}
|
|
447
|
+
|
|
448
|
+
// Клавиши режима 'whole': ←/→, Home/End и Tab/Shift+Tab ходят по группам (Tab с крайней
|
|
449
|
+
// группы уводит из поля как обычно), ↑/↓ меняют значение группы по кругу
|
|
450
|
+
#key(input, event) {
|
|
451
|
+
let st = this.#states.get(input);
|
|
452
|
+
if (event.altKey || event.ctrlKey || event.metaKey || !st?.result) return;
|
|
453
|
+
|
|
454
|
+
let { g, edit } = this.#mode(st, input.selectionStart ?? 0, input.selectionEnd ?? 0);
|
|
455
|
+
if (edit != 'whole') return;
|
|
456
|
+
|
|
457
|
+
let groups = this.#layout_of(st).spans, last = groups.length - 1;
|
|
458
|
+
let gi = this.#seg(input, st).gi, to;
|
|
459
|
+
|
|
460
|
+
switch (event.key) {
|
|
461
|
+
case 'ArrowLeft': to = gi - 1; break;
|
|
462
|
+
case 'ArrowRight': to = gi + 1; break;
|
|
463
|
+
case 'Home': to = 0; break;
|
|
464
|
+
case 'End': to = last; break;
|
|
465
|
+
case 'Tab':
|
|
466
|
+
to = gi + (event.shiftKey ? -1 : 1);
|
|
467
|
+
if (to < 0 || to > last) return;
|
|
468
|
+
break;
|
|
469
|
+
case 'ArrowUp':
|
|
470
|
+
case 'ArrowDown': {
|
|
471
|
+
event.preventDefault();
|
|
472
|
+
let layout = this.#layout_of(st), cells = this.#cells(st, layout);
|
|
473
|
+
let next = step(groups[gi], cells.slice(groups[gi].first, groups[gi].last + 1),
|
|
474
|
+
event.key == 'ArrowUp' ? 1 : -1);
|
|
475
|
+
if (!next) return;
|
|
476
|
+
|
|
477
|
+
cells.splice(groups[gi].first, next.length, ...next);
|
|
478
|
+
let was = input.value;
|
|
479
|
+
this.#reconcile(input, this.#stream(layout, cells), {});
|
|
480
|
+
this.#select(input, gi);
|
|
481
|
+
if (input.value !== was) {
|
|
482
|
+
st.handled = true;
|
|
483
|
+
input.dispatchEvent(new InputEvent('input', { bubbles: true, inputType: 'insertReplacementText' }));
|
|
484
|
+
}
|
|
485
|
+
return;
|
|
377
486
|
}
|
|
487
|
+
default: return;
|
|
488
|
+
}
|
|
378
489
|
|
|
379
|
-
|
|
490
|
+
event.preventDefault();
|
|
491
|
+
this.#select(input, Math.max(0, Math.min(to, last)));
|
|
492
|
+
}
|
|
493
|
+
|
|
494
|
+
// Выделить группу gi целиком. Уход из группы, в которой набирали, - сначала дотянуть её
|
|
495
|
+
// до min; новая группа (или reset) начинает набор с пустого буфера
|
|
496
|
+
#select(input, gi, reset = true) {
|
|
497
|
+
let st = this.#states.get(input);
|
|
498
|
+
if (st.seg && st.seg.gi !== gi) this.#settle(input);
|
|
499
|
+
if (reset || st.seg?.gi !== gi) st.seg = { gi, buffer: '' };
|
|
500
|
+
|
|
501
|
+
let g = this.#layout_of(st).spans[gi];
|
|
502
|
+
if (document.activeElement === input) input.setSelectionRange(g.start, g.end);
|
|
503
|
+
}
|
|
504
|
+
|
|
505
|
+
// Группа набора - та, что выделена сейчас; сменилась (выделение поставили программно,
|
|
506
|
+
// а selectionchange ещё не пришёл) - буфер начинается заново
|
|
507
|
+
#seg(input, st) {
|
|
508
|
+
let { g } = this.#mode(st, input.selectionStart ?? 0, input.selectionEnd ?? 0);
|
|
509
|
+
let gi = this.#layout_of(st).spans.indexOf(g);
|
|
510
|
+
if (st.seg?.gi !== gi) {
|
|
511
|
+
this.#settle(input);
|
|
512
|
+
st.seg = { gi, buffer: '' };
|
|
380
513
|
}
|
|
514
|
+
return st.seg;
|
|
515
|
+
}
|
|
381
516
|
|
|
382
|
-
|
|
383
|
-
let
|
|
517
|
+
#settle(input) {
|
|
518
|
+
let st = this.#states.get(input), layout = this.#layout_of(st);
|
|
519
|
+
if (!st.seg?.buffer || !layout) return;
|
|
384
520
|
|
|
385
|
-
let
|
|
386
|
-
let
|
|
387
|
-
|
|
388
|
-
|
|
389
|
-
|
|
521
|
+
let g = layout.spans[st.seg.gi], cells = this.#cells(st, layout);
|
|
522
|
+
let part = cells.slice(g.first, g.last + 1), next = settle(g, part);
|
|
523
|
+
st.seg.buffer = '';
|
|
524
|
+
if (next === part) return;
|
|
525
|
+
|
|
526
|
+
cells.splice(g.first, next.length, ...next);
|
|
527
|
+
this.#reconcile(input, this.#stream(layout, cells), {});
|
|
528
|
+
}
|
|
529
|
+
|
|
530
|
+
// Фокус в поле с группами 'whole': Tab выделяет первую группу, Shift+Tab (фокус пришёл
|
|
531
|
+
// от следующего элемента) - последнюю. Клик дальше сам выделит группу под курсором
|
|
532
|
+
#enter(input, from) {
|
|
533
|
+
let st = this.#states.get(input), layout = this.#layout_of(st);
|
|
534
|
+
if (!layout || this.#mode(st, 0).edit != 'whole') return;
|
|
390
535
|
|
|
391
|
-
let
|
|
392
|
-
|
|
393
|
-
: { part: this.#anchor_at(layout, kn, caret) ?? parts[Math.min(kn, n - 1)], k: kn };
|
|
394
|
-
this.#reconcile(input, stream, { caret_fmt: caret });
|
|
536
|
+
let back = from && input.compareDocumentPosition(from) & Node.DOCUMENT_POSITION_FOLLOWING;
|
|
537
|
+
this.#select(input, back ? layout.spans.length - 1 : 0);
|
|
395
538
|
}
|
|
396
539
|
|
|
397
|
-
#pin(input) {
|
|
540
|
+
#pin(input, clicked = false) {
|
|
398
541
|
let st = this.#states.get(input);
|
|
399
542
|
if (document.activeElement !== input || !st?.result) return;
|
|
400
543
|
|
|
401
544
|
let start = input.selectionStart, end = input.selectionEnd;
|
|
402
545
|
if (start == null) return;
|
|
403
546
|
|
|
547
|
+
let { g, edit } = this.#mode(st, start, end);
|
|
548
|
+
|
|
549
|
+
if (edit == 'whole') {
|
|
550
|
+
let gi = this.#layout_of(st).spans.indexOf(g);
|
|
551
|
+
if (!clicked && st.seg?.gi === gi && start == g.start && end == g.end) return;
|
|
552
|
+
return this.#select(input, gi, clicked || st.seg?.gi !== gi);
|
|
553
|
+
}
|
|
554
|
+
|
|
555
|
+
if (edit != 'end') return;
|
|
556
|
+
|
|
557
|
+
// Писать в середину нельзя - значит, и выделять её: частичное выделение расширяется
|
|
558
|
+
// до группы под кареткой (без групп - до всего значения)
|
|
404
559
|
if (start !== end) {
|
|
405
|
-
|
|
560
|
+
let [from, to] = g ? [g.start, g.end] : [0, input.value.length];
|
|
561
|
+
if ((start != 0 || end != input.value.length) && (start != from || end != to))
|
|
562
|
+
input.setSelectionRange(from, to);
|
|
406
563
|
return;
|
|
407
564
|
}
|
|
408
565
|
|
|
409
566
|
if (start === st.caret) return;
|
|
410
567
|
|
|
411
|
-
let target = this.#tail_of(input, st,
|
|
568
|
+
let target = this.#tail_of(input, st, g);
|
|
412
569
|
if (start !== target) input.setSelectionRange(target, target);
|
|
413
570
|
st.caret = target;
|
|
414
571
|
}
|
|
415
572
|
|
|
416
|
-
|
|
417
|
-
|
|
573
|
+
// Куда прижата каретка в режиме 'end': первая пустая ячейка начиная с группы (заполненная
|
|
574
|
+
// группа отдаёт набор дальше, а не перезаписывает соседнюю); без раскладки - конец набранного
|
|
575
|
+
#tail_of(input, st, g) {
|
|
576
|
+
if (g) {
|
|
577
|
+
let slots = this.#layout_of(st).slots;
|
|
578
|
+
for (let i = g.first; i < slots.length; i++)
|
|
579
|
+
if (st.result.cells?.[i] == null) return slots[i].fmt;
|
|
580
|
+
return slots.at(-1).fmt + 1;
|
|
581
|
+
}
|
|
582
|
+
return Math.min(st.result.stop_fmt, input.value.length);
|
|
583
|
+
}
|
|
418
584
|
|
|
419
|
-
|
|
420
|
-
|
|
421
|
-
|
|
422
|
-
|
|
423
|
-
|
|
585
|
+
// Раскладка фиксированной маски со скелетом: позиции слотов, блоки между разделителями
|
|
586
|
+
// и группы. Без placeholder: 'always' или у маски переменной длины раскладки нет
|
|
587
|
+
#layout_of(st) {
|
|
588
|
+
let def = st.def;
|
|
589
|
+
if (this.#params.placeholder != 'always' || !def?.fixed) return null;
|
|
424
590
|
|
|
425
|
-
|
|
426
|
-
|
|
427
|
-
|
|
428
|
-
|
|
591
|
+
let layout = def.layout ??= Mask.#layout(def);
|
|
592
|
+
layout.spans ??= spans(layout, this.#params);
|
|
593
|
+
return layout;
|
|
594
|
+
}
|
|
429
595
|
|
|
430
|
-
|
|
431
|
-
|
|
596
|
+
// Группа под выделением и её режим: выделенная целиком группа, иначе группа под началом.
|
|
597
|
+
// Позиция сразу за группой относится к ней ('12|.03' - ДД), так что каретка в конце
|
|
598
|
+
// группы её не покидает
|
|
599
|
+
#mode(st, start, end = start) {
|
|
600
|
+
let groups = this.#layout_of(st)?.spans ?? [];
|
|
601
|
+
let g = groups.find(g => start != end && g.start == start && g.end == end)
|
|
602
|
+
?? groups.find(g => start <= g.end) ?? groups.at(-1) ?? null;
|
|
603
|
+
let edit = g ? g.opts.edit : this.#params.edit;
|
|
604
|
+
return { g, edit: edit == 'whole' && !g ? 'end' : edit };
|
|
605
|
+
}
|
|
432
606
|
|
|
433
|
-
|
|
607
|
+
#cells(st, layout) {
|
|
608
|
+
return layout.slots.map((_, i) => st.result?.cells?.[i] ?? null);
|
|
434
609
|
}
|
|
435
610
|
|
|
436
|
-
#
|
|
437
|
-
let
|
|
438
|
-
return
|
|
439
|
-
&& parts[k] != parts[k - 1] && fmt == slots[k - 1].fmt + 1 ? parts[k - 1] : null;
|
|
611
|
+
#stream(layout, cells) {
|
|
612
|
+
let last = cells.reduce((acc, cell, i) => cell != null ? i : acc, -1);
|
|
613
|
+
return cells.slice(0, last + 1).map((cell, i) => cell ?? layout.slots[i].fill).join('');
|
|
440
614
|
}
|
|
441
615
|
|
|
442
616
|
#stream_pos(units, fmt) {
|
|
@@ -450,7 +624,7 @@ export default class Mask {
|
|
|
450
624
|
let st = this.#states.get(input);
|
|
451
625
|
if (input.value === st.rendered) return;
|
|
452
626
|
|
|
453
|
-
st.
|
|
627
|
+
st.seg = null;
|
|
454
628
|
let sel = input.selectionStart ?? input.value.length;
|
|
455
629
|
this.#reconcile(input, input.value, { prefix: input.value.slice(0, sel) });
|
|
456
630
|
}
|
|
@@ -468,6 +642,9 @@ export default class Mask {
|
|
|
468
642
|
({ result, def, mask_id } = best);
|
|
469
643
|
}
|
|
470
644
|
|
|
645
|
+
if (!def.numeral && !in_range(def.names, { ...result.groups, null: result.raw }, this.#params))
|
|
646
|
+
result.complete = false;
|
|
647
|
+
|
|
471
648
|
let text = this.#text_for(input, result);
|
|
472
649
|
|
|
473
650
|
if (input.value !== text) input.value = text;
|
|
@@ -519,7 +696,8 @@ export default class Mask {
|
|
|
519
696
|
formatted: input.value,
|
|
520
697
|
complete: st.result?.complete ?? false,
|
|
521
698
|
mask_id: st.mask_id,
|
|
522
|
-
progress: st.result?.raw.length ?? 0
|
|
699
|
+
progress: st.result?.raw.length ?? 0,
|
|
700
|
+
groups: { ...st.result?.groups }
|
|
523
701
|
};
|
|
524
702
|
}
|
|
525
703
|
|