@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/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, filler } from './_engine.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'];
@@ -55,8 +56,12 @@ export default class Mask {
55
56
  numeral: null,
56
57
  filler: '_',
57
58
  placeholder: true,
58
- flow: true,
59
- rewrite: false,
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.run = null;
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: '', run: null, composing: false, handled: false, coerced, max_raw, numeric };
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
- if (this.#params.caret !== true) {
190
- let pin = () => this.#pin(input);
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 (this.#params.caret !== true && st.result && !(start == 0 && end == input.value.length))
231
- start = end = this.#tail_of(input, st, 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.#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);
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 = 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;
319
+ let layout = this.#layout_of(st);
320
+ let { slots, parts } = layout, n = slots.length;
304
321
 
305
- let cells = Array.from({ length: n }, (_, i) => st.result?.cells?.[i] ?? null);
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, anchor = null, restart = null;
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
- if ((k = at(fmt_start)) >= n) return;
318
- let limit = parts[k];
333
+ k = at(fmt_start);
319
334
  while (k < n && cells[k] == null) k++;
320
- if (k >= n || !flow && parts[k] != limit) return;
335
+ if (k >= n) return;
321
336
  } 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;
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 || !flow && (parts[k] != parts[edge] || fmt_start > slots[edge].fmt + 1)) return;
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
- anchor = this.#anchor_at(layout, k, fmt_start);
346
+ }
334
347
 
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;
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
- anchor ??= k < n ? parts[k] : null;
342
- let crossed = null;
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
- for (let c of prepare(def, insert, { input })) {
345
- if (k >= n) {
346
- if (restart == null) break;
347
- k = parts.indexOf(restart);
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
- if (!flow && parts[k] != anchor) {
351
- if (gap(k).includes(c)) {
352
- anchor = parts[k];
353
- crossed = k;
354
- restart = rewrite ? parts[k] : null;
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
- 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;
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
- 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;
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
- cells[k++] = c;
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
- 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('');
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 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;
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
- 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 });
497
+ cells.splice(g.first, next.length, ...next);
498
+ this.#reconcile(input, this.#stream(layout, cells), {});
395
499
  }
396
500
 
397
- #pin(input) {
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
- if (start != 0 || end != input.value.length) input.setSelectionRange(0, input.value.length);
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, start);
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
- #tail_of(input, st, fmt) {
417
- let def = st.def;
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
- 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;
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
- 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;
562
+ let layout = def.layout ??= Mask.#layout(def);
563
+ layout.spans ??= spans(layout, this.#params);
564
+ return layout;
565
+ }
429
566
 
430
- return slots[last].fmt + 1;
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
- return Math.min(st.result.stop_fmt, input.value.length);
578
+ #cells(st, layout) {
579
+ return layout.slots.map((_, i) => st.result?.cells?.[i] ?? null);
434
580
  }
435
581
 
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;
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.run = null;
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