@cat-of-summer/st-script 1.1.0 → 1.2.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/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/package.json +1 -1
- package/src/index.js +0 -1
- package/src/mask/_engine.js +46 -14
- package/src/mask/_groups.js +84 -0
- package/src/mask/index.js +244 -95
package/src/mask/index.js
CHANGED
|
@@ -1,5 +1,6 @@
|
|
|
1
1
|
import { element, elements, expose, find, own } from '../_traits/hasInstanceSymbol.js';
|
|
2
|
-
import { build, run, run_all, render, caret_for, cap, prepare
|
|
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'];
|
|
@@ -55,8 +56,12 @@ export default class Mask {
|
|
|
55
56
|
numeral: null,
|
|
56
57
|
filler: '_',
|
|
57
58
|
placeholder: true,
|
|
58
|
-
|
|
59
|
-
|
|
59
|
+
edit: 'free',
|
|
60
|
+
pad: null,
|
|
61
|
+
align: 'left',
|
|
62
|
+
min: null,
|
|
63
|
+
max: null,
|
|
64
|
+
groups: {},
|
|
60
65
|
caret: true,
|
|
61
66
|
coerce_type: true,
|
|
62
67
|
max_raw: null,
|
|
@@ -120,7 +125,7 @@ export default class Mask {
|
|
|
120
125
|
let st = this.#states.get(input);
|
|
121
126
|
if (!st) continue;
|
|
122
127
|
st.defs = defs;
|
|
123
|
-
st.
|
|
128
|
+
st.seg = null;
|
|
124
129
|
this.#reconcile(input, st.stream, {});
|
|
125
130
|
}
|
|
126
131
|
}
|
|
@@ -128,6 +133,7 @@ export default class Mask {
|
|
|
128
133
|
#base() {
|
|
129
134
|
return {
|
|
130
135
|
filler: this.#params.filler,
|
|
136
|
+
groups: this.#params.groups,
|
|
131
137
|
before_char: this.before_char,
|
|
132
138
|
before_slot: this.before_slot
|
|
133
139
|
};
|
|
@@ -168,7 +174,7 @@ export default class Mask {
|
|
|
168
174
|
}
|
|
169
175
|
|
|
170
176
|
let numeric = coerced == 'number' || this.#params.numeral != null;
|
|
171
|
-
let st = { defs, def: null, stream: '', result: null, mask_id: null, rendered: '',
|
|
177
|
+
let st = { defs, def: null, stream: '', result: null, mask_id: null, rendered: '', seg: null, composing: false, handled: false, coerced, max_raw, numeric };
|
|
172
178
|
this.#states.set(input, st);
|
|
173
179
|
this.#inputs.push(input);
|
|
174
180
|
|
|
@@ -186,10 +192,15 @@ export default class Mask {
|
|
|
186
192
|
|
|
187
193
|
input.addEventListener('beforeinput', event => this.#before(input, event));
|
|
188
194
|
|
|
189
|
-
|
|
190
|
-
|
|
195
|
+
let edits = [this.#params.edit, ...Object.values(this.#params.groups ?? {}).map(g => g?.edit)];
|
|
196
|
+
if (edits.includes('whole') && (this.#params.placeholder != 'always' || defs.some(d => !d.fixed && !d.fn)))
|
|
197
|
+
console.warn("Mask: edit: 'whole' работает с фиксированной маской и placeholder: 'always' - иначе ведёт себя как 'end'", input);
|
|
198
|
+
|
|
199
|
+
if (edits.some(edit => edit && edit != 'free')) {
|
|
200
|
+
let pin = event => this.#pin(input, event.type == 'click');
|
|
191
201
|
for (let event of ['selectionchange', 'click', 'keyup', 'select'])
|
|
192
202
|
input.addEventListener(event, pin);
|
|
203
|
+
input.addEventListener('keydown', event => this.#key(input, event));
|
|
193
204
|
}
|
|
194
205
|
|
|
195
206
|
let refresh = () => {
|
|
@@ -203,11 +214,16 @@ export default class Mask {
|
|
|
203
214
|
input.addEventListener('compositionstart', () => st.composing = true);
|
|
204
215
|
input.addEventListener('compositionend', () => { st.composing = false; this.#refresh(input); });
|
|
205
216
|
|
|
206
|
-
input.addEventListener('focus',
|
|
217
|
+
input.addEventListener('focus', event => {
|
|
207
218
|
hide();
|
|
208
219
|
this.#reconcile(input, st.stream, { prefix: st.stream, silent: true });
|
|
220
|
+
this.#enter(input, event.relatedTarget);
|
|
221
|
+
});
|
|
222
|
+
input.addEventListener('blur', () => {
|
|
223
|
+
this.#settle(input);
|
|
224
|
+
st.seg = null;
|
|
225
|
+
this.#reconcile(input, st.stream, { silent: true });
|
|
209
226
|
});
|
|
210
|
-
input.addEventListener('blur', () => { st.run = null; this.#reconcile(input, st.stream, { silent: true }); });
|
|
211
227
|
|
|
212
228
|
input.closest('form')?.addEventListener('reset', () => queueMicrotask(() => this.#refresh(input)));
|
|
213
229
|
|
|
@@ -226,9 +242,11 @@ export default class Mask {
|
|
|
226
242
|
if (type == 'historyUndo' || type == 'historyRedo') return;
|
|
227
243
|
|
|
228
244
|
let start = input.selectionStart ?? 0, end = input.selectionEnd ?? start;
|
|
245
|
+
let { g, edit } = this.#mode(st, start, end);
|
|
229
246
|
|
|
230
|
-
if (
|
|
231
|
-
start
|
|
247
|
+
if (edit == 'end' && st.result && !(start == 0 && end == input.value.length)
|
|
248
|
+
&& !(g && start == g.start && end == g.end))
|
|
249
|
+
start = end = this.#tail_of(input, st, g);
|
|
232
250
|
|
|
233
251
|
event.preventDefault();
|
|
234
252
|
st.handled = true;
|
|
@@ -256,9 +274,9 @@ export default class Mask {
|
|
|
256
274
|
|
|
257
275
|
let was = input.value;
|
|
258
276
|
|
|
259
|
-
this.#
|
|
260
|
-
|
|
261
|
-
|
|
277
|
+
if (edit == 'whole') this.#segment(input, type, is_delete ? '' : insert);
|
|
278
|
+
else if (this.#layout_of(st)) this.#grid(input, type, start, end, is_delete ? '' : insert);
|
|
279
|
+
else this.#edit(input, start, end, is_delete ? '' : insert, type);
|
|
262
280
|
|
|
263
281
|
if (type == 'insertFromPaste') this.on_paste(input, this.#state_of(input, st));
|
|
264
282
|
|
|
@@ -298,145 +316,272 @@ export default class Mask {
|
|
|
298
316
|
|
|
299
317
|
#grid(input, type, fmt_start, fmt_end, insert) {
|
|
300
318
|
let st = this.#states.get(input), def = st.def;
|
|
301
|
-
let layout =
|
|
302
|
-
let
|
|
303
|
-
let flow = this.#params.flow, rewrite = this.#params.rewrite;
|
|
319
|
+
let layout = this.#layout_of(st);
|
|
320
|
+
let { slots, parts } = layout, n = slots.length;
|
|
304
321
|
|
|
305
|
-
let cells =
|
|
322
|
+
let cells = this.#cells(st, layout);
|
|
306
323
|
|
|
307
324
|
let at = fmt => { let k = slots.findIndex(slot => slot.fmt >= fmt); return k < 0 ? n : k; };
|
|
308
325
|
let gap = i => layout.template.slice(slots[i - 1].fmt + 1, slots[i].fmt);
|
|
309
|
-
let k
|
|
326
|
+
let k;
|
|
310
327
|
|
|
311
328
|
if (fmt_start != fmt_end) {
|
|
312
329
|
k = at(fmt_start);
|
|
313
330
|
for (let i = k; i < n && slots[i].fmt < fmt_end; i++) cells[i] = null;
|
|
314
|
-
st.run = null;
|
|
315
331
|
} else if (!insert && type.startsWith('delete')) {
|
|
316
332
|
if (type.includes('Forward')) {
|
|
317
|
-
|
|
318
|
-
let limit = parts[k];
|
|
333
|
+
k = at(fmt_start);
|
|
319
334
|
while (k < n && cells[k] == null) k++;
|
|
320
|
-
if (k >= n
|
|
335
|
+
if (k >= n) return;
|
|
321
336
|
} else {
|
|
322
|
-
|
|
323
|
-
for (let i = 0; i < n; i++) if (slots[i].fmt < fmt_start)
|
|
324
|
-
if (edge < 0) return;
|
|
325
|
-
k = edge;
|
|
337
|
+
k = -1;
|
|
338
|
+
for (let i = 0; i < n; i++) if (slots[i].fmt < fmt_start) k = i;
|
|
326
339
|
while (k >= 0 && cells[k] == null) k--;
|
|
327
|
-
if (k < 0
|
|
340
|
+
if (k < 0) return;
|
|
328
341
|
}
|
|
329
342
|
cells[k] = null;
|
|
330
343
|
} else {
|
|
331
344
|
k = at(fmt_start);
|
|
332
345
|
if (k >= n && (k = cells.indexOf(null)) < 0) k = n;
|
|
333
|
-
|
|
346
|
+
}
|
|
334
347
|
|
|
335
|
-
|
|
336
|
-
|
|
337
|
-
|
|
348
|
+
for (let c of prepare(def, insert, { input })) {
|
|
349
|
+
if (k >= n) break;
|
|
350
|
+
|
|
351
|
+
if (!slots[k].node.test.test(c)) {
|
|
352
|
+
// Разделитель следующего блока переводит набор в этот блок
|
|
353
|
+
let end = parts.lastIndexOf(parts[k]);
|
|
354
|
+
if (end + 1 < n && gap(end + 1).includes(c)) k = end + 1;
|
|
355
|
+
continue;
|
|
338
356
|
}
|
|
357
|
+
|
|
358
|
+
cells[k++] = c;
|
|
339
359
|
}
|
|
340
360
|
|
|
341
|
-
|
|
342
|
-
let
|
|
361
|
+
let stream = this.#stream(layout, cells);
|
|
362
|
+
let pos = Math.min(run(def, stream.slice(0, k), { input }).stream.length, n);
|
|
363
|
+
this.#reconcile(input, stream, { caret_fmt: pos < n ? slots[pos].fmt : slots[n - 1].fmt + 1 });
|
|
364
|
+
}
|
|
343
365
|
|
|
344
|
-
|
|
345
|
-
|
|
346
|
-
|
|
347
|
-
|
|
366
|
+
// edit: 'whole' - набор в выделенную группу как в <input type=date>: буфер группы
|
|
367
|
+
// начинается с нуля при входе в неё, заполненная группа передаёт набор следующей,
|
|
368
|
+
// разделитель закрывает группу досрочно, удаление очищает группу целиком
|
|
369
|
+
#segment(input, type, insert) {
|
|
370
|
+
let st = this.#states.get(input), layout = this.#layout_of(st), groups = layout.spans;
|
|
371
|
+
let seg = this.#seg(input, st);
|
|
372
|
+
let cells = this.#cells(st, layout);
|
|
373
|
+
let part = g => cells.slice(g.first, g.last + 1);
|
|
374
|
+
let put = (g, values) => cells.splice(g.first, values.length, ...values);
|
|
375
|
+
let g = groups[seg.gi];
|
|
376
|
+
|
|
377
|
+
if (type.startsWith('delete')) {
|
|
378
|
+
if (part(g).every(cell => cell == null)) {
|
|
379
|
+
if (type.includes('Backward') && seg.gi > 0) this.#select(input, seg.gi - 1);
|
|
380
|
+
return;
|
|
348
381
|
}
|
|
349
|
-
|
|
350
|
-
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
|
|
382
|
+
put(g, part(g).fill(null));
|
|
383
|
+
seg.buffer = '';
|
|
384
|
+
} else {
|
|
385
|
+
if (type == 'insertFromPaste') seg.buffer = '';
|
|
386
|
+
|
|
387
|
+
for (let c of prepare(st.def, insert, { input })) {
|
|
388
|
+
g = groups[seg.gi];
|
|
389
|
+
let next = groups[seg.gi + 1];
|
|
390
|
+
|
|
391
|
+
if (next && layout.template.slice(g.end, next.start).includes(c)) {
|
|
392
|
+
if (seg.buffer) {
|
|
393
|
+
put(g, settle(g, part(g)));
|
|
394
|
+
seg.gi++;
|
|
395
|
+
seg.buffer = '';
|
|
396
|
+
}
|
|
355
397
|
continue;
|
|
356
398
|
}
|
|
357
|
-
if (restart == null) continue;
|
|
358
|
-
k = parts.indexOf(restart);
|
|
359
|
-
}
|
|
360
399
|
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
|
|
400
|
+
let slot = layout.slots[g.first + Math.min(seg.buffer.length, g.fmts.length - 1)];
|
|
401
|
+
if (!slot.node.test.test(c)) continue;
|
|
402
|
+
|
|
403
|
+
let typed = type_ahead(g, seg.buffer, c);
|
|
404
|
+
put(g, typed.cells);
|
|
405
|
+
seg.buffer = typed.buffer;
|
|
406
|
+
|
|
407
|
+
if (typed.advance) {
|
|
408
|
+
put(g, settle(g, part(g)));
|
|
409
|
+
seg.buffer = '';
|
|
410
|
+
if (next) seg.gi++;
|
|
368
411
|
}
|
|
369
|
-
continue;
|
|
370
412
|
}
|
|
413
|
+
}
|
|
371
414
|
|
|
372
|
-
|
|
373
|
-
|
|
374
|
-
|
|
375
|
-
|
|
376
|
-
|
|
415
|
+
this.#reconcile(input, this.#stream(layout, cells), {});
|
|
416
|
+
this.#select(input, seg.gi, false);
|
|
417
|
+
}
|
|
418
|
+
|
|
419
|
+
// Клавиши режима 'whole': ←/→, Home/End и Tab/Shift+Tab ходят по группам (Tab с крайней
|
|
420
|
+
// группы уводит из поля как обычно), ↑/↓ меняют значение группы по кругу
|
|
421
|
+
#key(input, event) {
|
|
422
|
+
let st = this.#states.get(input);
|
|
423
|
+
if (event.altKey || event.ctrlKey || event.metaKey || !st?.result) return;
|
|
424
|
+
|
|
425
|
+
let { g, edit } = this.#mode(st, input.selectionStart ?? 0, input.selectionEnd ?? 0);
|
|
426
|
+
if (edit != 'whole') return;
|
|
427
|
+
|
|
428
|
+
let groups = this.#layout_of(st).spans, last = groups.length - 1;
|
|
429
|
+
let gi = this.#seg(input, st).gi, to;
|
|
430
|
+
|
|
431
|
+
switch (event.key) {
|
|
432
|
+
case 'ArrowLeft': to = gi - 1; break;
|
|
433
|
+
case 'ArrowRight': to = gi + 1; break;
|
|
434
|
+
case 'Home': to = 0; break;
|
|
435
|
+
case 'End': to = last; break;
|
|
436
|
+
case 'Tab':
|
|
437
|
+
to = gi + (event.shiftKey ? -1 : 1);
|
|
438
|
+
if (to < 0 || to > last) return;
|
|
439
|
+
break;
|
|
440
|
+
case 'ArrowUp':
|
|
441
|
+
case 'ArrowDown': {
|
|
442
|
+
event.preventDefault();
|
|
443
|
+
let layout = this.#layout_of(st), cells = this.#cells(st, layout);
|
|
444
|
+
let next = step(groups[gi], cells.slice(groups[gi].first, groups[gi].last + 1),
|
|
445
|
+
event.key == 'ArrowUp' ? 1 : -1);
|
|
446
|
+
if (!next) return;
|
|
447
|
+
|
|
448
|
+
cells.splice(groups[gi].first, next.length, ...next);
|
|
449
|
+
let was = input.value;
|
|
450
|
+
this.#reconcile(input, this.#stream(layout, cells), {});
|
|
451
|
+
this.#select(input, gi);
|
|
452
|
+
if (input.value !== was) {
|
|
453
|
+
st.handled = true;
|
|
454
|
+
input.dispatchEvent(new InputEvent('input', { bubbles: true, inputType: 'insertReplacementText' }));
|
|
455
|
+
}
|
|
456
|
+
return;
|
|
377
457
|
}
|
|
458
|
+
default: return;
|
|
459
|
+
}
|
|
378
460
|
|
|
379
|
-
|
|
461
|
+
event.preventDefault();
|
|
462
|
+
this.#select(input, Math.max(0, Math.min(to, last)));
|
|
463
|
+
}
|
|
464
|
+
|
|
465
|
+
// Выделить группу gi целиком. Уход из группы, в которой набирали, - сначала дотянуть её
|
|
466
|
+
// до min; новая группа (или reset) начинает набор с пустого буфера
|
|
467
|
+
#select(input, gi, reset = true) {
|
|
468
|
+
let st = this.#states.get(input);
|
|
469
|
+
if (st.seg && st.seg.gi !== gi) this.#settle(input);
|
|
470
|
+
if (reset || st.seg?.gi !== gi) st.seg = { gi, buffer: '' };
|
|
471
|
+
|
|
472
|
+
let g = this.#layout_of(st).spans[gi];
|
|
473
|
+
if (document.activeElement === input) input.setSelectionRange(g.start, g.end);
|
|
474
|
+
}
|
|
475
|
+
|
|
476
|
+
// Группа набора - та, что выделена сейчас; сменилась (выделение поставили программно,
|
|
477
|
+
// а selectionchange ещё не пришёл) - буфер начинается заново
|
|
478
|
+
#seg(input, st) {
|
|
479
|
+
let { g } = this.#mode(st, input.selectionStart ?? 0, input.selectionEnd ?? 0);
|
|
480
|
+
let gi = this.#layout_of(st).spans.indexOf(g);
|
|
481
|
+
if (st.seg?.gi !== gi) {
|
|
482
|
+
this.#settle(input);
|
|
483
|
+
st.seg = { gi, buffer: '' };
|
|
380
484
|
}
|
|
485
|
+
return st.seg;
|
|
486
|
+
}
|
|
381
487
|
|
|
382
|
-
|
|
383
|
-
let
|
|
488
|
+
#settle(input) {
|
|
489
|
+
let st = this.#states.get(input), layout = this.#layout_of(st);
|
|
490
|
+
if (!st.seg?.buffer || !layout) return;
|
|
384
491
|
|
|
385
|
-
let
|
|
386
|
-
let
|
|
387
|
-
|
|
388
|
-
|
|
389
|
-
if (crossed != null && k == crossed) caret = slots[crossed].fmt;
|
|
492
|
+
let g = layout.spans[st.seg.gi], cells = this.#cells(st, layout);
|
|
493
|
+
let part = cells.slice(g.first, g.last + 1), next = settle(g, part);
|
|
494
|
+
st.seg.buffer = '';
|
|
495
|
+
if (next === part) return;
|
|
390
496
|
|
|
391
|
-
|
|
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 });
|
|
497
|
+
cells.splice(g.first, next.length, ...next);
|
|
498
|
+
this.#reconcile(input, this.#stream(layout, cells), {});
|
|
395
499
|
}
|
|
396
500
|
|
|
397
|
-
|
|
501
|
+
// Фокус в поле с группами 'whole': Tab выделяет первую группу, Shift+Tab (фокус пришёл
|
|
502
|
+
// от следующего элемента) - последнюю. Клик дальше сам выделит группу под курсором
|
|
503
|
+
#enter(input, from) {
|
|
504
|
+
let st = this.#states.get(input), layout = this.#layout_of(st);
|
|
505
|
+
if (!layout || this.#mode(st, 0).edit != 'whole') return;
|
|
506
|
+
|
|
507
|
+
let back = from && input.compareDocumentPosition(from) & Node.DOCUMENT_POSITION_FOLLOWING;
|
|
508
|
+
this.#select(input, back ? layout.spans.length - 1 : 0);
|
|
509
|
+
}
|
|
510
|
+
|
|
511
|
+
#pin(input, clicked = false) {
|
|
398
512
|
let st = this.#states.get(input);
|
|
399
513
|
if (document.activeElement !== input || !st?.result) return;
|
|
400
514
|
|
|
401
515
|
let start = input.selectionStart, end = input.selectionEnd;
|
|
402
516
|
if (start == null) return;
|
|
403
517
|
|
|
518
|
+
let { g, edit } = this.#mode(st, start, end);
|
|
519
|
+
|
|
520
|
+
if (edit == 'whole') {
|
|
521
|
+
let gi = this.#layout_of(st).spans.indexOf(g);
|
|
522
|
+
if (!clicked && st.seg?.gi === gi && start == g.start && end == g.end) return;
|
|
523
|
+
return this.#select(input, gi, clicked || st.seg?.gi !== gi);
|
|
524
|
+
}
|
|
525
|
+
|
|
526
|
+
if (edit != 'end') return;
|
|
527
|
+
|
|
528
|
+
// Писать в середину нельзя - значит, и выделять её: частичное выделение расширяется
|
|
529
|
+
// до группы под кареткой (без групп - до всего значения)
|
|
404
530
|
if (start !== end) {
|
|
405
|
-
|
|
531
|
+
let [from, to] = g ? [g.start, g.end] : [0, input.value.length];
|
|
532
|
+
if ((start != 0 || end != input.value.length) && (start != from || end != to))
|
|
533
|
+
input.setSelectionRange(from, to);
|
|
406
534
|
return;
|
|
407
535
|
}
|
|
408
536
|
|
|
409
537
|
if (start === st.caret) return;
|
|
410
538
|
|
|
411
|
-
let target = this.#tail_of(input, st,
|
|
539
|
+
let target = this.#tail_of(input, st, g);
|
|
412
540
|
if (start !== target) input.setSelectionRange(target, target);
|
|
413
541
|
st.caret = target;
|
|
414
542
|
}
|
|
415
543
|
|
|
416
|
-
|
|
417
|
-
|
|
544
|
+
// Куда прижата каретка в режиме 'end': первая пустая ячейка начиная с группы (заполненная
|
|
545
|
+
// группа отдаёт набор дальше, а не перезаписывает соседнюю); без раскладки - конец набранного
|
|
546
|
+
#tail_of(input, st, g) {
|
|
547
|
+
if (g) {
|
|
548
|
+
let slots = this.#layout_of(st).slots;
|
|
549
|
+
for (let i = g.first; i < slots.length; i++)
|
|
550
|
+
if (st.result.cells?.[i] == null) return slots[i].fmt;
|
|
551
|
+
return slots.at(-1).fmt + 1;
|
|
552
|
+
}
|
|
553
|
+
return Math.min(st.result.stop_fmt, input.value.length);
|
|
554
|
+
}
|
|
418
555
|
|
|
419
|
-
|
|
420
|
-
|
|
421
|
-
|
|
422
|
-
|
|
423
|
-
|
|
556
|
+
// Раскладка фиксированной маски со скелетом: позиции слотов, блоки между разделителями
|
|
557
|
+
// и группы. Без placeholder: 'always' или у маски переменной длины раскладки нет
|
|
558
|
+
#layout_of(st) {
|
|
559
|
+
let def = st.def;
|
|
560
|
+
if (this.#params.placeholder != 'always' || !def?.fixed) return null;
|
|
424
561
|
|
|
425
|
-
|
|
426
|
-
|
|
427
|
-
|
|
428
|
-
|
|
562
|
+
let layout = def.layout ??= Mask.#layout(def);
|
|
563
|
+
layout.spans ??= spans(layout, this.#params);
|
|
564
|
+
return layout;
|
|
565
|
+
}
|
|
429
566
|
|
|
430
|
-
|
|
431
|
-
|
|
567
|
+
// Группа под выделением и её режим: выделенная целиком группа, иначе группа под началом.
|
|
568
|
+
// Позиция сразу за группой относится к ней ('12|.03' - ДД), так что каретка в конце
|
|
569
|
+
// группы её не покидает
|
|
570
|
+
#mode(st, start, end = start) {
|
|
571
|
+
let groups = this.#layout_of(st)?.spans ?? [];
|
|
572
|
+
let g = groups.find(g => start != end && g.start == start && g.end == end)
|
|
573
|
+
?? groups.find(g => start <= g.end) ?? groups.at(-1) ?? null;
|
|
574
|
+
let edit = g ? g.opts.edit : this.#params.edit;
|
|
575
|
+
return { g, edit: edit == 'whole' && !g ? 'end' : edit };
|
|
576
|
+
}
|
|
432
577
|
|
|
433
|
-
|
|
578
|
+
#cells(st, layout) {
|
|
579
|
+
return layout.slots.map((_, i) => st.result?.cells?.[i] ?? null);
|
|
434
580
|
}
|
|
435
581
|
|
|
436
|
-
#
|
|
437
|
-
let
|
|
438
|
-
return
|
|
439
|
-
&& parts[k] != parts[k - 1] && fmt == slots[k - 1].fmt + 1 ? parts[k - 1] : null;
|
|
582
|
+
#stream(layout, cells) {
|
|
583
|
+
let last = cells.reduce((acc, cell, i) => cell != null ? i : acc, -1);
|
|
584
|
+
return cells.slice(0, last + 1).map((cell, i) => cell ?? layout.slots[i].fill).join('');
|
|
440
585
|
}
|
|
441
586
|
|
|
442
587
|
#stream_pos(units, fmt) {
|
|
@@ -450,7 +595,7 @@ export default class Mask {
|
|
|
450
595
|
let st = this.#states.get(input);
|
|
451
596
|
if (input.value === st.rendered) return;
|
|
452
597
|
|
|
453
|
-
st.
|
|
598
|
+
st.seg = null;
|
|
454
599
|
let sel = input.selectionStart ?? input.value.length;
|
|
455
600
|
this.#reconcile(input, input.value, { prefix: input.value.slice(0, sel) });
|
|
456
601
|
}
|
|
@@ -468,6 +613,9 @@ export default class Mask {
|
|
|
468
613
|
({ result, def, mask_id } = best);
|
|
469
614
|
}
|
|
470
615
|
|
|
616
|
+
if (!def.numeral && !in_range(def.names, { ...result.groups, null: result.raw }, this.#params))
|
|
617
|
+
result.complete = false;
|
|
618
|
+
|
|
471
619
|
let text = this.#text_for(input, result);
|
|
472
620
|
|
|
473
621
|
if (input.value !== text) input.value = text;
|
|
@@ -519,7 +667,8 @@ export default class Mask {
|
|
|
519
667
|
formatted: input.value,
|
|
520
668
|
complete: st.result?.complete ?? false,
|
|
521
669
|
mask_id: st.mask_id,
|
|
522
|
-
progress: st.result?.raw.length ?? 0
|
|
670
|
+
progress: st.result?.raw.length ?? 0,
|
|
671
|
+
groups: { ...st.result?.groups }
|
|
523
672
|
};
|
|
524
673
|
}
|
|
525
674
|
|