@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.
Files changed (48) hide show
  1. package/dist/loader.esm.min.js +1 -1
  2. package/dist/loader.esm.min.js.map +1 -1
  3. package/dist/loader.min.js +1 -1
  4. package/dist/loader.min.js.map +1 -1
  5. package/dist/mask.esm.min.js +1 -1
  6. package/dist/mask.esm.min.js.map +4 -4
  7. package/dist/mask.min.js +1 -1
  8. package/dist/mask.min.js.map +4 -4
  9. package/dist/modal.esm.min.js +1 -1
  10. package/dist/modal.esm.min.js.map +3 -3
  11. package/dist/modal.min.js +1 -1
  12. package/dist/modal.min.js.map +3 -3
  13. package/dist/observer.esm.min.js +1 -1
  14. package/dist/observer.esm.min.js.map +1 -1
  15. package/dist/observer.min.js +1 -1
  16. package/dist/observer.min.js.map +1 -1
  17. package/dist/route.esm.min.js.map +2 -2
  18. package/dist/route.min.js.map +2 -2
  19. package/dist/select.esm.min.js +1 -1
  20. package/dist/select.esm.min.js.map +3 -3
  21. package/dist/select.min.js +1 -1
  22. package/dist/select.min.js.map +3 -3
  23. package/dist/toggle.esm.min.js +1 -1
  24. package/dist/toggle.esm.min.js.map +3 -3
  25. package/dist/toggle.min.js +1 -1
  26. package/dist/toggle.min.js.map +3 -3
  27. package/dist/typograf.esm.min.js +1 -1
  28. package/dist/typograf.esm.min.js.map +1 -1
  29. package/dist/typograf.min.js +1 -1
  30. package/dist/typograf.min.js.map +1 -1
  31. package/dist/uploader.esm.min.js +1 -1
  32. package/dist/uploader.esm.min.js.map +3 -3
  33. package/dist/uploader.min.js +1 -1
  34. package/dist/uploader.min.js.map +3 -3
  35. package/dist/validator.esm.min.js +1 -1
  36. package/dist/validator.esm.min.js.map +3 -3
  37. package/dist/validator.min.js +1 -1
  38. package/dist/validator.min.js.map +3 -3
  39. package/package.json +1 -1
  40. package/src/_traits/hasInstanceSymbol.js +16 -0
  41. package/src/mask/_engine.js +46 -14
  42. package/src/mask/_groups.js +84 -0
  43. package/src/mask/index.js +282 -104
  44. package/src/modal/index.js +69 -15
  45. package/src/select/index.js +57 -12
  46. package/src/toggle/index.js +24 -9
  47. package/src/uploader/index.js +22 -8
  48. 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, filler } from './_engine.js';
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
- flow: true,
59
- rewrite: false,
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.run = null;
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: '', run: null, composing: false, handled: false, coerced, max_raw, numeric };
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
- if (this.#params.caret !== true) {
190
- let pin = () => this.#pin(input);
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
- input.addEventListener('blur', () => { st.run = null; this.#reconcile(input, st.stream, { silent: true }); });
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 (this.#params.caret !== true && st.result && !(start == 0 && end == input.value.length))
231
- start = end = this.#tail_of(input, st, 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.#params.placeholder == 'always' && st.def?.fixed
260
- ? this.#grid(input, type, start, end, is_delete ? '' : insert)
261
- : this.#edit(input, start, end, is_delete ? '' : insert, type);
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 = def.layout ??= Mask.#layout(def);
302
- let slots = layout.slots, parts = layout.parts, n = slots.length;
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 = Array.from({ length: n }, (_, i) => st.result?.cells?.[i] ?? null);
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, anchor = null, restart = null;
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
- if ((k = at(fmt_start)) >= n) return;
318
- let limit = parts[k];
362
+ k = at(fmt_start);
319
363
  while (k < n && cells[k] == null) k++;
320
- if (k >= n || !flow && parts[k] != limit) return;
364
+ if (k >= n) return;
321
365
  } else {
322
- let edge = -1;
323
- for (let i = 0; i < n; i++) if (slots[i].fmt < fmt_start) edge = i;
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 || !flow && (parts[k] != parts[edge] || fmt_start > slots[edge].fmt + 1)) return;
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
- anchor = this.#anchor_at(layout, k, fmt_start);
375
+ }
376
+
377
+ for (let c of prepare(def, insert, { input })) {
378
+ if (k >= n) break;
334
379
 
335
- if (rewrite) {
336
- let part = anchor ?? parts[Math.min(k, n - 1)];
337
- if (st.run?.part !== part || st.run.k !== k || parts[k] !== part) restart = part;
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
- anchor ??= k < n ? parts[k] : null;
342
- let crossed = null;
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
- for (let c of prepare(def, insert, { input })) {
345
- if (k >= n) {
346
- if (restart == null) break;
347
- k = parts.indexOf(restart);
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
- if (!flow && parts[k] != anchor) {
351
- if (gap(k).includes(c)) {
352
- anchor = parts[k];
353
- crossed = k;
354
- restart = rewrite ? parts[k] : null;
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
- if (!slots[k].node.test.test(c)) {
362
- let end = parts.lastIndexOf(parts[k]);
363
- if (end + 1 < n && gap(end + 1).includes(c)) {
364
- k = end + 1;
365
- anchor = parts[k];
366
- crossed = k;
367
- restart = rewrite ? parts[k] : null;
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
- if (restart != null) {
373
- for (let i = 0; i < n; i++) if (parts[i] == restart) cells[i] = null;
374
- k = parts.indexOf(restart);
375
- anchor = restart;
376
- restart = null;
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
- cells[k++] = c;
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
- let last = cells.reduce((acc, cell, i) => cell != null ? i : acc, -1);
383
- let stream = cells.slice(0, last + 1).map((cell, i) => cell ?? filler(def, i)).join('');
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 pos = Math.min(run(def, stream.slice(0, k), { input }).stream.length, n);
386
- let caret = pos < n ? slots[pos].fmt : slots[n - 1].fmt + 1;
387
- if (!flow && insert && pos > 0 && pos < n && parts[pos] != parts[pos - 1])
388
- caret = slots[pos - 1].fmt + 1;
389
- if (crossed != null && k == crossed) caret = slots[crossed].fmt;
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 kn = at(caret);
392
- st.run = crossed != null ? null
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
- if (start != 0 || end != input.value.length) input.setSelectionRange(0, input.value.length);
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, start);
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
- #tail_of(input, st, fmt) {
417
- let def = st.def;
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
- if (this.#params.placeholder == 'always' && def?.fixed && !this.#params.flow) {
420
- let layout = def.layout ??= Mask.#layout(def);
421
- let { slots, parts } = layout;
422
- let k = slots.findIndex(slot => slot.fmt >= fmt);
423
- if (k < 0) k = slots.length - 1;
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
- let part = this.#anchor_at(layout, k, fmt) ?? parts[k];
426
- let first = parts.indexOf(part), last = parts.lastIndexOf(part);
427
- for (let i = first; i <= last; i++)
428
- if (st.result.cells?.[i] == null) return slots[i].fmt;
591
+ let layout = def.layout ??= Mask.#layout(def);
592
+ layout.spans ??= spans(layout, this.#params);
593
+ return layout;
594
+ }
429
595
 
430
- return slots[last].fmt + 1;
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
- return Math.min(st.result.stop_fmt, input.value.length);
607
+ #cells(st, layout) {
608
+ return layout.slots.map((_, i) => st.result?.cells?.[i] ?? null);
434
609
  }
435
610
 
436
- #anchor_at(layout, k, fmt) {
437
- let { slots, parts } = layout;
438
- return !this.#params.flow && k > 0 && k < slots.length
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.run = null;
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