@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/_engine.js
CHANGED
|
@@ -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
|
-
|
|
133
|
-
|
|
134
|
-
|
|
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++,
|
|
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
|
-
|
|
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
|
+
}
|