@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.
@@ -33,12 +33,24 @@ function last_top(body, needle) {
33
33
  return found;
34
34
  }
35
35
 
36
+ // Помечает узлы группы её именем. Группы не вкладываются: узел с чужой меткой - отказ
37
+ function tag(nodes, name) {
38
+ return nodes.every(node => node.group == null
39
+ && (node.group = name, !node.children || tag(node.children, name)));
40
+ }
41
+
36
42
  function classify(body) {
37
43
  let fail = () => {
38
44
  console.warn('Некорректный блок маски', `{${body}}`);
39
45
  return [...`{${body}}`].map(char => ({ type: 'literal', char }));
40
46
  };
41
47
 
48
+ let named = /^([A-Za-z_]\w*):/.exec(body);
49
+ if (named) {
50
+ let children = compile(body.slice(named[0].length));
51
+ return tag(children, named[1]) ? children : fail();
52
+ }
53
+
42
54
  let semi = last_top(body, ';');
43
55
  if (semi > 0) {
44
56
  let range = body.slice(semi + 1);
@@ -92,6 +104,14 @@ function is_fixed(nodes) {
92
104
  || node.type == 'repeat' && node.min == node.max && is_fixed(node.children));
93
105
  }
94
106
 
107
+ function group_names(nodes, names = new Set()) {
108
+ for (let node of nodes) {
109
+ if (node.group != null) names.add(node.group);
110
+ if (node.children) group_names(node.children, names);
111
+ }
112
+ return names;
113
+ }
114
+
95
115
  export function build(mask, base = {}) {
96
116
  if (mask && typeof mask == 'object' && !Array.isArray(mask) && !(mask instanceof RegExp)
97
117
  && mask.pattern == null && mask.filter == null && mask.numeral == null)
@@ -114,8 +134,13 @@ export function build(mask, base = {}) {
114
134
  : [{ type: 'repeat', min: 0, max: m.max_length ?? Infinity, greedy: true,
115
135
  children: [{ type: 'slot', test: no_g(m.filter) }] }];
116
136
 
137
+ let groups = m.groups ?? base.groups ?? {};
138
+
117
139
  return {
118
140
  nodes,
141
+ names: [...group_names(nodes)],
142
+ fills: Object.fromEntries(Object.entries(groups)
143
+ .filter(([, g]) => g?.filler != null).map(([name, g]) => [name, g.filler])),
119
144
  fixed: m.pattern != null && is_fixed(nodes),
120
145
  valid: m.valid ? no_g(m.valid) : (m.filter ? /./ : null),
121
146
  message: m.message,
@@ -129,9 +154,12 @@ export function build(mask, base = {}) {
129
154
  return defs;
130
155
  }
131
156
 
132
- export function filler(def, ordinal) {
133
- let f = def.filler ?? '_';
134
- return f[ordinal] ?? f.at(-1) ?? '_';
157
+ // Заполнитель слота: у группы со своим filler - по номеру слота внутри группы,
158
+ // иначе - по сквозному номеру слота из filler маски
159
+ export function filler(def, ordinal, group, local) {
160
+ let f = def.fills?.[group];
161
+ if (f == null) f = def.filler ?? '_', local = ordinal;
162
+ return f[local] ?? f.at(-1) ?? '_';
135
163
  }
136
164
 
137
165
  export function prepare(def, input_string, ctx) {
@@ -167,14 +195,15 @@ function consumes(nodes, c, s, entry) {
167
195
  return entry ? nodes.some(node => node.type == 'literal' && node.char === c) : false;
168
196
  }
169
197
 
170
- function accept(s, text, fmt_text, kind = 'char', ordinal = null) {
198
+ function accept(s, text, fmt_text, kind = 'char', ordinal = null, group = null) {
171
199
  s.units.push({
172
- kind, ordinal,
200
+ kind, ordinal, group,
173
201
  stream_start: s.stream.length, stream_end: s.stream.length + text.length,
174
202
  fmt_start: s.formatted.length, fmt_end: s.formatted.length + fmt_text.length
175
203
  });
176
204
  s.stream += text;
177
205
  if (kind == 'char') s.raw += text;
206
+ if (kind == 'char' && group != null) s.groups[group] += text;
178
207
  if (ordinal != null) s.cells[ordinal] = kind == 'char' ? text : null;
179
208
  s.formatted += fmt_text;
180
209
  }
@@ -212,9 +241,11 @@ function walk(nodes, s, def) {
212
241
  } else s.tail += node.char;
213
242
 
214
243
  } else if (node.type == 'slot') {
215
- let ordinal = s.ordinal++, fill = filler(def, ordinal);
244
+ let ordinal = s.ordinal++, group = node.group ?? null;
245
+ let local = group == null ? null : s.local[group] = (s.local[group] ?? -1) + 1;
246
+ let fill = filler(def, ordinal, group, local);
216
247
  if (s.done) {
217
- s.ph_slots.push({ fmt: s.formatted.length + s.tail.length + s.ph.length, node });
248
+ s.ph_slots.push({ fmt: s.formatted.length + s.tail.length + s.ph.length, node, fill });
218
249
  s.ph += fill;
219
250
  continue;
220
251
  }
@@ -222,7 +253,7 @@ function walk(nodes, s, def) {
222
253
  for (;;) {
223
254
  if (s.ip >= s.input.length) {
224
255
  exhaust(s);
225
- s.ph_slots.push({ fmt: s.formatted.length + s.tail.length, node });
256
+ s.ph_slots.push({ fmt: s.formatted.length + s.tail.length, node, fill });
226
257
  s.ph += fill;
227
258
  break;
228
259
  }
@@ -238,10 +269,10 @@ function walk(nodes, s, def) {
238
269
  continue;
239
270
  }
240
271
  }
241
- accept(s, c, c, 'char', ordinal);
272
+ accept(s, c, c, 'char', ordinal, group);
242
273
  } else if (c === fill) {
243
274
  s.complete = false;
244
- accept(s, c, c, 'hole', ordinal);
275
+ accept(s, c, c, 'hole', ordinal, group);
245
276
  } else { s.ip++; continue; }
246
277
  s.ip++;
247
278
  s.consumed++;
@@ -335,8 +366,8 @@ function numeral(def, input_string) {
335
366
  body += o.decimal;
336
367
  for (let i = 1; i <= o.fraction; i++) body += filler(def, i);
337
368
  }
338
- return { stream: '', raw: '', formatted: '', tail: '', ph: body + o.suffix,
339
- ph_slots: [], complete: false, consumed: 0, lead: 0, units: [], cells: [], stop_fmt: body.length };
369
+ return { stream: '', raw: '', formatted: '', tail: '', ph: body + o.suffix, ph_slots: [],
370
+ complete: false, consumed: 0, lead: 0, units: [], cells: [], groups: {}, stop_fmt: body.length };
340
371
  }
341
372
 
342
373
  let f = o.fraction;
@@ -373,7 +404,7 @@ function numeral(def, input_string) {
373
404
  let complete = (o.min == null || value >= o.min) && (o.max == null || value <= o.max);
374
405
 
375
406
  return { stream: raw, raw, formatted, tail: '', ph: '', ph_slots: [],
376
- complete, consumed: raw.length, lead: 0, units, cells: [], stop_fmt };
407
+ complete, consumed: raw.length, lead: 0, units, cells: [], groups: {}, stop_fmt };
377
408
  }
378
409
 
379
410
  export function run(def, input_string, ctx) {
@@ -385,6 +416,7 @@ export function run(def, input_string, ctx) {
385
416
  ip: 0,
386
417
  stream: '', raw: '', formatted: '', tail: '', ph: '',
387
418
  ph_slots: [], units: [], cells: [],
419
+ groups: Object.fromEntries((def.names ?? []).map(name => [name, ''])), local: {},
388
420
  consumed: 0, lead: 0, diverged: false, ordinal: 0,
389
421
  complete: true, done: false, stop_fmt: -1
390
422
  };
@@ -396,7 +428,7 @@ export function run(def, input_string, ctx) {
396
428
  return {
397
429
  stream: s.stream, raw: s.raw, formatted: s.formatted, tail: s.tail,
398
430
  ph: s.ph, ph_slots: s.ph_slots, complete: s.complete, consumed: s.consumed,
399
- lead: s.lead, units: s.units, cells: s.cells, stop_fmt: s.stop_fmt
431
+ lead: s.lead, units: s.units, cells: s.cells, groups: s.groups, stop_fmt: s.stop_fmt
400
432
  };
401
433
  }
402
434
 
@@ -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
+ }