@crubal/engine 0.0.0-stage → 0.4.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/LICENSE +202 -0
- package/README.md +97 -2
- package/dist/bin/crubal.d.ts +2 -0
- package/dist/bin/crubal.js +103 -0
- package/dist/bin/crubal.js.map +1 -0
- package/dist/src/access.d.ts +149 -0
- package/dist/src/access.js +584 -0
- package/dist/src/access.js.map +1 -0
- package/dist/src/acts.d.ts +531 -0
- package/dist/src/acts.js +1466 -0
- package/dist/src/acts.js.map +1 -0
- package/dist/src/address.d.ts +29 -0
- package/dist/src/address.js +59 -0
- package/dist/src/address.js.map +1 -0
- package/dist/src/arrival.d.ts +55 -0
- package/dist/src/arrival.js +127 -0
- package/dist/src/arrival.js.map +1 -0
- package/dist/src/browser.d.ts +10 -0
- package/dist/src/browser.js +13 -0
- package/dist/src/browser.js.map +1 -0
- package/dist/src/bundle.d.ts +74 -0
- package/dist/src/bundle.js +1108 -0
- package/dist/src/bundle.js.map +1 -0
- package/dist/src/canonical.d.ts +6 -0
- package/dist/src/canonical.js +47 -0
- package/dist/src/canonical.js.map +1 -0
- package/dist/src/carriers.d.ts +7 -0
- package/dist/src/carriers.js +33 -0
- package/dist/src/carriers.js.map +1 -0
- package/dist/src/conditions.d.ts +28 -0
- package/dist/src/conditions.js +227 -0
- package/dist/src/conditions.js.map +1 -0
- package/dist/src/corpus.d.ts +8 -0
- package/dist/src/corpus.js +1207 -0
- package/dist/src/corpus.js.map +1 -0
- package/dist/src/defs.d.ts +174 -0
- package/dist/src/defs.js +690 -0
- package/dist/src/defs.js.map +1 -0
- package/dist/src/dictionary.d.ts +77 -0
- package/dist/src/dictionary.js +629 -0
- package/dist/src/dictionary.js.map +1 -0
- package/dist/src/exchange.d.ts +259 -0
- package/dist/src/exchange.js +1088 -0
- package/dist/src/exchange.js.map +1 -0
- package/dist/src/forms.d.ts +16 -0
- package/dist/src/forms.js +181 -0
- package/dist/src/forms.js.map +1 -0
- package/dist/src/index.d.ts +32 -0
- package/dist/src/index.js +34 -0
- package/dist/src/index.js.map +1 -0
- package/dist/src/lex.d.ts +21 -0
- package/dist/src/lex.js +142 -0
- package/dist/src/lex.js.map +1 -0
- package/dist/src/lifecycle.d.ts +92 -0
- package/dist/src/lifecycle.js +451 -0
- package/dist/src/lifecycle.js.map +1 -0
- package/dist/src/log.d.ts +91 -0
- package/dist/src/log.js +629 -0
- package/dist/src/log.js.map +1 -0
- package/dist/src/migrate.d.ts +129 -0
- package/dist/src/migrate.js +415 -0
- package/dist/src/migrate.js.map +1 -0
- package/dist/src/model.d.ts +81 -0
- package/dist/src/model.js +188 -0
- package/dist/src/model.js.map +1 -0
- package/dist/src/packages.d.ts +372 -0
- package/dist/src/packages.js +1158 -0
- package/dist/src/packages.js.map +1 -0
- package/dist/src/print-text.d.ts +7 -0
- package/dist/src/print-text.js +223 -0
- package/dist/src/print-text.js.map +1 -0
- package/dist/src/publish.d.ts +27 -0
- package/dist/src/publish.js +279 -0
- package/dist/src/publish.js.map +1 -0
- package/dist/src/read-text.d.ts +10 -0
- package/dist/src/read-text.js +400 -0
- package/dist/src/read-text.js.map +1 -0
- package/dist/src/records.d.ts +32 -0
- package/dist/src/records.js +104 -0
- package/dist/src/records.js.map +1 -0
- package/dist/src/review.d.ts +22 -0
- package/dist/src/review.js +198 -0
- package/dist/src/review.js.map +1 -0
- package/dist/src/rules.d.ts +101 -0
- package/dist/src/rules.js +670 -0
- package/dist/src/rules.js.map +1 -0
- package/dist/src/schedule.d.ts +24 -0
- package/dist/src/schedule.js +126 -0
- package/dist/src/schedule.js.map +1 -0
- package/dist/src/std-packages.d.ts +9 -0
- package/dist/src/std-packages.js +268 -0
- package/dist/src/std-packages.js.map +1 -0
- package/dist/src/store.d.ts +191 -0
- package/dist/src/store.js +671 -0
- package/dist/src/store.js.map +1 -0
- package/dist/src/surface.d.ts +47 -0
- package/dist/src/surface.js +92 -0
- package/dist/src/surface.js.map +1 -0
- package/dist/src/tree.d.ts +35 -0
- package/dist/src/tree.js +159 -0
- package/dist/src/tree.js.map +1 -0
- package/dist/src/units-table.d.ts +1 -0
- package/dist/src/units-table.js +200 -0
- package/dist/src/units-table.js.map +1 -0
- package/dist/src/units.d.ts +42 -0
- package/dist/src/units.js +98 -0
- package/dist/src/units.js.map +1 -0
- package/dist/src/versions.d.ts +10 -0
- package/dist/src/versions.js +27 -0
- package/dist/src/versions.js.map +1 -0
- package/dist/src/views.d.ts +372 -0
- package/dist/src/views.js +1170 -0
- package/dist/src/views.js.map +1 -0
- package/package.json +60 -4
package/dist/src/defs.js
ADDED
|
@@ -0,0 +1,690 @@
|
|
|
1
|
+
// defs.ts: facet, class and kind definitions (spec chapters 4, 5 and 11.2), read from the long form and
|
|
2
|
+
// the shorthand into one model. The Reader uses only a facet's type, how many, unit, words, children and
|
|
3
|
+
// identity; the Dictionary level uses the rest.
|
|
4
|
+
import { CrubalError, readTree } from "./tree.js";
|
|
5
|
+
import { readList, splitTop } from "./lex.js";
|
|
6
|
+
import { unitOf } from "./units.js";
|
|
7
|
+
/** The table's unit for a spelling (`hr` → `h`); a currency, `currency` or an unknown word as written. */
|
|
8
|
+
const canonicalUnit = (u) => unitOf(u) ?? u;
|
|
9
|
+
export const TYPES = ["text", "number", "date", "time", "yes-no", "choice", "link", "image", "color", "compound"];
|
|
10
|
+
export function emptyDictionary() {
|
|
11
|
+
const d = { facets: new Map(), classes: new Map(), kinds: new Map(), levels: new Map(), vary: new Map(), varyLines: new Map(), trust: [], facetTrust: new Map(), identify: new Map(), match: new Map(), archive: new Map() };
|
|
12
|
+
// Core facets (spec 1.6, 5.6).
|
|
13
|
+
d.facets.set("crubal:count", { ...blank("crubal:count", "number") });
|
|
14
|
+
const notables = blank("crubal:notables", "compound");
|
|
15
|
+
notables.many = true;
|
|
16
|
+
notables.pick = "any";
|
|
17
|
+
notables.children = new Map([
|
|
18
|
+
["key", blank("key", "text")],
|
|
19
|
+
["value", blank("value", "text")],
|
|
20
|
+
]);
|
|
21
|
+
d.facets.set("crubal:notables", notables);
|
|
22
|
+
// The core's list facet (12.2): a hand-made list holds ordered links to the records it shows.
|
|
23
|
+
const items = blank("crubal:items", "link");
|
|
24
|
+
items.many = true;
|
|
25
|
+
items.pick = "any";
|
|
26
|
+
items.ordered = true;
|
|
27
|
+
items.label = "Items";
|
|
28
|
+
d.facets.set("crubal:items", items);
|
|
29
|
+
// The core's read-through link (7.8 observed): the presenter's record this one reads, never copied.
|
|
30
|
+
const observes = blank("crubal:observes", "link");
|
|
31
|
+
observes.label = "Observes";
|
|
32
|
+
d.facets.set("crubal:observes", observes);
|
|
33
|
+
return d;
|
|
34
|
+
}
|
|
35
|
+
export function blank(key, type) {
|
|
36
|
+
return { key, type, many: false, pick: "1", ordered: false, aliases: [], sameAs: [], qualifiers: [], accepts: [], extra: {} };
|
|
37
|
+
}
|
|
38
|
+
const KEY = /^(?:[a-z][a-z0-9-]*:)?[A-Za-z_]\w*/;
|
|
39
|
+
const PRECISION = {
|
|
40
|
+
y: "year", ym: "month", ymd: "day", ymdh: "hour", ymdhm: "minute", ymdhms: "second", any: "any", "": "any",
|
|
41
|
+
hm: "minute", hms: "second",
|
|
42
|
+
};
|
|
43
|
+
/** Tokens of a shorthand line: split on spaces outside quotes, braces and parentheses. */
|
|
44
|
+
export function tokens(s, line) {
|
|
45
|
+
const out = [];
|
|
46
|
+
let depth = 0;
|
|
47
|
+
let quoted = false;
|
|
48
|
+
let cur = "";
|
|
49
|
+
for (let i = 0; i < s.length; i++) {
|
|
50
|
+
const ch = s[i];
|
|
51
|
+
if (quoted && ch === "\\") {
|
|
52
|
+
cur += ch + (s[i + 1] ?? "");
|
|
53
|
+
i++;
|
|
54
|
+
continue;
|
|
55
|
+
}
|
|
56
|
+
if (ch === '"')
|
|
57
|
+
quoted = !quoted;
|
|
58
|
+
if (!quoted && (ch === "{" || ch === "("))
|
|
59
|
+
depth++;
|
|
60
|
+
if (!quoted && (ch === "}" || ch === ")"))
|
|
61
|
+
depth--;
|
|
62
|
+
if (!quoted && depth === 0 && ch === " ") {
|
|
63
|
+
if (cur)
|
|
64
|
+
out.push(cur);
|
|
65
|
+
cur = "";
|
|
66
|
+
continue;
|
|
67
|
+
}
|
|
68
|
+
cur += ch;
|
|
69
|
+
}
|
|
70
|
+
if (quoted || depth !== 0)
|
|
71
|
+
throw new CrubalError(`an unbalanced line: ${s}`, line);
|
|
72
|
+
if (cur)
|
|
73
|
+
out.push(cur);
|
|
74
|
+
return out;
|
|
75
|
+
}
|
|
76
|
+
function closing(s, start, open, close, line) {
|
|
77
|
+
let depth = 0;
|
|
78
|
+
let quoted = false;
|
|
79
|
+
for (let i = start; i < s.length; i++) {
|
|
80
|
+
const ch = s[i];
|
|
81
|
+
if (quoted && ch === "\\") {
|
|
82
|
+
i++;
|
|
83
|
+
continue;
|
|
84
|
+
}
|
|
85
|
+
if (ch === '"')
|
|
86
|
+
quoted = !quoted;
|
|
87
|
+
if (quoted)
|
|
88
|
+
continue;
|
|
89
|
+
if (ch === open)
|
|
90
|
+
depth++;
|
|
91
|
+
if (ch === close && --depth === 0)
|
|
92
|
+
return i;
|
|
93
|
+
}
|
|
94
|
+
throw new CrubalError(`"${open}" is not closed in ${s}`, line);
|
|
95
|
+
}
|
|
96
|
+
/** A quoted value's text (2.5); an unquoted one as it is. */
|
|
97
|
+
export const unquote = (s) => (s.startsWith('"') ? JSON.parse(s) : s);
|
|
98
|
+
/** A choice list's inside: `DVD~"DVD Video"|Blu-ray~BD|...` */
|
|
99
|
+
function readChoices(inner, line) {
|
|
100
|
+
const parts = splitOutside(inner, "|", line);
|
|
101
|
+
let open = false;
|
|
102
|
+
const values = [];
|
|
103
|
+
for (const p of parts) {
|
|
104
|
+
if (p === "...") {
|
|
105
|
+
open = true;
|
|
106
|
+
continue;
|
|
107
|
+
}
|
|
108
|
+
const [v, ...aliases] = splitOutside(p, "~", line);
|
|
109
|
+
values.push({ value: unquote(v ?? ""), aliases: aliases.map(unquote) });
|
|
110
|
+
}
|
|
111
|
+
return { values, open };
|
|
112
|
+
}
|
|
113
|
+
function splitOutside(s, sep, line) {
|
|
114
|
+
const out = [];
|
|
115
|
+
let quoted = false;
|
|
116
|
+
let cur = "";
|
|
117
|
+
for (let i = 0; i < s.length; i++) {
|
|
118
|
+
const ch = s[i];
|
|
119
|
+
if (quoted && ch === "\\") {
|
|
120
|
+
cur += ch + (s[i + 1] ?? "");
|
|
121
|
+
i++;
|
|
122
|
+
continue;
|
|
123
|
+
}
|
|
124
|
+
if (ch === '"')
|
|
125
|
+
quoted = !quoted;
|
|
126
|
+
if (!quoted && ch === sep) {
|
|
127
|
+
out.push(cur.trim());
|
|
128
|
+
cur = "";
|
|
129
|
+
continue;
|
|
130
|
+
}
|
|
131
|
+
cur += ch;
|
|
132
|
+
}
|
|
133
|
+
if (quoted)
|
|
134
|
+
throw new CrubalError(`a quote is not closed in ${s}`, line);
|
|
135
|
+
out.push(cur.trim());
|
|
136
|
+
return out;
|
|
137
|
+
}
|
|
138
|
+
function parseLine(text, line) {
|
|
139
|
+
let s = text.trim();
|
|
140
|
+
let whenText;
|
|
141
|
+
const w = s.search(/ when /);
|
|
142
|
+
if (w >= 0) {
|
|
143
|
+
whenText = s.slice(w + 6).trim();
|
|
144
|
+
s = s.slice(0, w).trim();
|
|
145
|
+
}
|
|
146
|
+
let required = false;
|
|
147
|
+
if (s.startsWith("!")) {
|
|
148
|
+
required = true;
|
|
149
|
+
s = s.slice(1);
|
|
150
|
+
}
|
|
151
|
+
let level;
|
|
152
|
+
const lv = s.match(/^([a-z]\w*)::/);
|
|
153
|
+
if (lv) {
|
|
154
|
+
level = lv[1];
|
|
155
|
+
s = s.slice(lv[0].length);
|
|
156
|
+
}
|
|
157
|
+
const keyMatch = s.match(KEY);
|
|
158
|
+
if (!keyMatch)
|
|
159
|
+
throw new CrubalError(`a facet line must start with a key: ${text}`, line);
|
|
160
|
+
const key = keyMatch[0];
|
|
161
|
+
let rest = s.slice(key.length);
|
|
162
|
+
const facet = blank(key, "text");
|
|
163
|
+
facet.line = line;
|
|
164
|
+
if (required)
|
|
165
|
+
facet.required = true;
|
|
166
|
+
let marked = true;
|
|
167
|
+
const mark = rest[0];
|
|
168
|
+
if (mark === "$") {
|
|
169
|
+
const len = rest.slice(1).match(/^\d+/);
|
|
170
|
+
if (len)
|
|
171
|
+
facet.length = Number(len[0]);
|
|
172
|
+
rest = rest.slice(1 + (len?.[0].length ?? 0));
|
|
173
|
+
}
|
|
174
|
+
else if (mark === "#") {
|
|
175
|
+
facet.type = "number";
|
|
176
|
+
const unit = rest.slice(1).match(/^[A-Za-z%°µ/]+/);
|
|
177
|
+
if (unit)
|
|
178
|
+
facet.unit = canonicalUnit(unit[0]);
|
|
179
|
+
rest = rest.slice(1 + (unit?.[0].length ?? 0));
|
|
180
|
+
}
|
|
181
|
+
else if (mark === "@") {
|
|
182
|
+
// The letters run y, m, d, h, m, s: `@ymdhm` is a date with a time to the minute, `@hm` a time of day.
|
|
183
|
+
const p = rest.slice(1).match(/^(ymdhms|ymdhm|ymdh|ymd|ym|y|hms|hm|any)?/)?.[0] ?? "";
|
|
184
|
+
facet.type = p.startsWith("h") ? "time" : "date";
|
|
185
|
+
facet.precision = PRECISION[p];
|
|
186
|
+
rest = rest.slice(1 + p.length);
|
|
187
|
+
}
|
|
188
|
+
else if (mark === "?") {
|
|
189
|
+
facet.type = "yes-no";
|
|
190
|
+
rest = rest.slice(1);
|
|
191
|
+
}
|
|
192
|
+
else if (mark === "{") {
|
|
193
|
+
facet.type = "choice";
|
|
194
|
+
const end = closing(rest, 0, "{", "}", line);
|
|
195
|
+
const { values, open } = readChoices(rest.slice(1, end), line);
|
|
196
|
+
facet.values = values;
|
|
197
|
+
if (open)
|
|
198
|
+
facet.open = true;
|
|
199
|
+
rest = rest.slice(end + 1);
|
|
200
|
+
}
|
|
201
|
+
else if (mark === "&") {
|
|
202
|
+
facet.type = "link";
|
|
203
|
+
const to = rest.slice(1).match(/^[^\s*]+/);
|
|
204
|
+
if (to)
|
|
205
|
+
facet.to = checkLinkTo(to[0], line);
|
|
206
|
+
rest = rest.slice(1 + (to?.[0].length ?? 0));
|
|
207
|
+
}
|
|
208
|
+
else if (mark === "^") {
|
|
209
|
+
facet.type = "image";
|
|
210
|
+
rest = rest.slice(1);
|
|
211
|
+
}
|
|
212
|
+
else if (mark === "%") {
|
|
213
|
+
facet.type = "color";
|
|
214
|
+
rest = rest.slice(1);
|
|
215
|
+
}
|
|
216
|
+
else if (mark === "(") {
|
|
217
|
+
facet.type = "compound";
|
|
218
|
+
const end = closing(rest, 0, "(", ")", line);
|
|
219
|
+
facet.children = new Map();
|
|
220
|
+
for (const child of tokens(rest.slice(1, end), line)) {
|
|
221
|
+
const c = parseLine(child, line).facet;
|
|
222
|
+
facet.children.set(c.key, c);
|
|
223
|
+
}
|
|
224
|
+
rest = rest.slice(end + 1);
|
|
225
|
+
}
|
|
226
|
+
else {
|
|
227
|
+
marked = false;
|
|
228
|
+
}
|
|
229
|
+
let count = null;
|
|
230
|
+
const cm = rest.match(/^\*(\d*)/);
|
|
231
|
+
if (cm) {
|
|
232
|
+
count = cm[1] || "any";
|
|
233
|
+
facet.pick = count;
|
|
234
|
+
facet.many = count !== "1";
|
|
235
|
+
rest = rest.slice(cm[0].length);
|
|
236
|
+
}
|
|
237
|
+
const tails = tokens(rest, line);
|
|
238
|
+
let frame;
|
|
239
|
+
for (let i = 0; i < tails.length; i++) {
|
|
240
|
+
const t = tails[i];
|
|
241
|
+
if (t === "frame:") {
|
|
242
|
+
// Placement (5.3.3): the photo slots an image facet fills, in order (revision 19: one or several, comma
|
|
243
|
+
// separated, one image each); a class line's setting, never the facet's.
|
|
244
|
+
const slots = [];
|
|
245
|
+
while (i + 1 < tails.length) {
|
|
246
|
+
const next = tails[++i];
|
|
247
|
+
slots.push(next.replace(/,$/, ""));
|
|
248
|
+
if (!next.endsWith(","))
|
|
249
|
+
break;
|
|
250
|
+
}
|
|
251
|
+
frame = slots.filter(Boolean).join(", ");
|
|
252
|
+
continue;
|
|
253
|
+
}
|
|
254
|
+
if (t.startsWith("~"))
|
|
255
|
+
facet.aliases.push(unquote(t.slice(1)));
|
|
256
|
+
else if (t.startsWith("="))
|
|
257
|
+
facet.sameAs.push(t.slice(1));
|
|
258
|
+
else if (t.startsWith("+"))
|
|
259
|
+
facet.combine = t.slice(1);
|
|
260
|
+
else if (t.startsWith("/"))
|
|
261
|
+
facet.version = t.slice(1);
|
|
262
|
+
else if (/^-?[\d.]+\.\.-?[\d.]+$/.test(t)) {
|
|
263
|
+
const [min, max] = t.split("..");
|
|
264
|
+
facet.range = { min: min, max: max };
|
|
265
|
+
if (tails[i + 1] === "step") {
|
|
266
|
+
facet.range.step = tails[i + 2];
|
|
267
|
+
i += 2;
|
|
268
|
+
}
|
|
269
|
+
}
|
|
270
|
+
else if (t.endsWith(":")) {
|
|
271
|
+
// A value runs on after a trailing comma: `accepts: g, lb, oz`.
|
|
272
|
+
let value = tails[i + 1] ?? "";
|
|
273
|
+
i++;
|
|
274
|
+
while (value.endsWith(",") && i + 1 < tails.length)
|
|
275
|
+
value += ` ${tails[++i]}`;
|
|
276
|
+
applySetting(facet, t.slice(0, -1), value, line);
|
|
277
|
+
}
|
|
278
|
+
else if (/^[a-z][\w-]*$/.test(t))
|
|
279
|
+
applySetting(facet, t, "yes", line);
|
|
280
|
+
else
|
|
281
|
+
throw new CrubalError(`unknown tail ${t} in ${text}`, line);
|
|
282
|
+
}
|
|
283
|
+
return { facet, marked, count, whenText, level, required, ...(frame ? { frame } : {}) };
|
|
284
|
+
}
|
|
285
|
+
/** Read one shorthand facet line (spec 4.5). */
|
|
286
|
+
export function readShorthand(text, line) {
|
|
287
|
+
const p = parseLine(text, line);
|
|
288
|
+
if (p.level)
|
|
289
|
+
throw new CrubalError("the level mark belongs to class lines, not a facet's definition", line);
|
|
290
|
+
if (p.whenText)
|
|
291
|
+
p.facet.when = p.whenText;
|
|
292
|
+
return p.facet;
|
|
293
|
+
}
|
|
294
|
+
const yes = (v) => v === "yes" || v === "true";
|
|
295
|
+
function applySetting(f, name, value, line) {
|
|
296
|
+
const v = value.trim();
|
|
297
|
+
switch (name) {
|
|
298
|
+
case "type":
|
|
299
|
+
if (!TYPES.includes(v))
|
|
300
|
+
throw new CrubalError(`unknown type ${v}`, line);
|
|
301
|
+
f.type = v;
|
|
302
|
+
if (v === "compound" && !f.children)
|
|
303
|
+
f.children = new Map();
|
|
304
|
+
return;
|
|
305
|
+
case "pick":
|
|
306
|
+
f.pick = v;
|
|
307
|
+
f.many = v !== "1";
|
|
308
|
+
return;
|
|
309
|
+
case "ordered":
|
|
310
|
+
f.ordered = yes(v);
|
|
311
|
+
return;
|
|
312
|
+
case "unit":
|
|
313
|
+
// A unit is a spelling (4.2); the definition keeps the table's unit so values convert and compare by it.
|
|
314
|
+
f.unit = canonicalUnit(v);
|
|
315
|
+
return;
|
|
316
|
+
case "identity":
|
|
317
|
+
f.identity = v;
|
|
318
|
+
return;
|
|
319
|
+
case "words": {
|
|
320
|
+
const [a, b] = splitTop(v, ",", line);
|
|
321
|
+
if (a && b)
|
|
322
|
+
f.words = [unquote(a), unquote(b)];
|
|
323
|
+
return;
|
|
324
|
+
}
|
|
325
|
+
case "to":
|
|
326
|
+
f.to = checkLinkTo(unquote(v), line);
|
|
327
|
+
return;
|
|
328
|
+
case "label":
|
|
329
|
+
case "ask":
|
|
330
|
+
case "describe":
|
|
331
|
+
case "version":
|
|
332
|
+
case "combine":
|
|
333
|
+
case "when":
|
|
334
|
+
f[name] = unquote(v);
|
|
335
|
+
return;
|
|
336
|
+
case "agree-by":
|
|
337
|
+
f.agreeBy = v;
|
|
338
|
+
return;
|
|
339
|
+
case "zone":
|
|
340
|
+
if (v !== "local")
|
|
341
|
+
throw new CrubalError(`zone is "local" or absent, not ${v}`, line);
|
|
342
|
+
f.zone = v;
|
|
343
|
+
return;
|
|
344
|
+
case "state":
|
|
345
|
+
if (v !== "candidate" && v !== "active" && v !== "retired")
|
|
346
|
+
throw new CrubalError(`unknown state ${v}`, line);
|
|
347
|
+
f.state = v;
|
|
348
|
+
return;
|
|
349
|
+
case "aliases":
|
|
350
|
+
f.aliases.push(...readList(v, line).map((p) => p.text));
|
|
351
|
+
return;
|
|
352
|
+
case "same-as":
|
|
353
|
+
f.sameAs.push(...readList(v, line).map((p) => p.text));
|
|
354
|
+
return;
|
|
355
|
+
case "qualifiers":
|
|
356
|
+
f.qualifiers.push(...readList(v, line).map((p) => p.text));
|
|
357
|
+
return;
|
|
358
|
+
case "accepts":
|
|
359
|
+
f.accepts.push(...readList(v, line).map((p) => canonicalUnit(p.text)));
|
|
360
|
+
return;
|
|
361
|
+
case "length":
|
|
362
|
+
f.length = Number(v);
|
|
363
|
+
return;
|
|
364
|
+
case "places":
|
|
365
|
+
f.places = Number(v);
|
|
366
|
+
return;
|
|
367
|
+
case "precision":
|
|
368
|
+
f.precision = v;
|
|
369
|
+
return;
|
|
370
|
+
case "range": {
|
|
371
|
+
const m = v.match(/^(-?[\d.]+)\.\.(-?[\d.]+)(?: step (\S+))?$/);
|
|
372
|
+
if (!m)
|
|
373
|
+
throw new CrubalError(`a range is "min..max": ${v}`, line);
|
|
374
|
+
f.range = { min: m[1], max: m[2] };
|
|
375
|
+
if (m[3])
|
|
376
|
+
f.range.step = m[3];
|
|
377
|
+
return;
|
|
378
|
+
}
|
|
379
|
+
case "values": {
|
|
380
|
+
f.values = [];
|
|
381
|
+
for (const piece of splitTop(v, ",", line)) {
|
|
382
|
+
if (piece === "...") {
|
|
383
|
+
f.open = true;
|
|
384
|
+
continue;
|
|
385
|
+
}
|
|
386
|
+
const [val, ...al] = splitOutside(piece, "~", line);
|
|
387
|
+
f.values.push({ value: unquote(val ?? ""), aliases: al.map(unquote) });
|
|
388
|
+
}
|
|
389
|
+
return;
|
|
390
|
+
}
|
|
391
|
+
case "fixed":
|
|
392
|
+
case "ranked":
|
|
393
|
+
case "scored":
|
|
394
|
+
case "required":
|
|
395
|
+
case "na":
|
|
396
|
+
case "unique":
|
|
397
|
+
case "open":
|
|
398
|
+
case "transitions":
|
|
399
|
+
f[name] = yes(v);
|
|
400
|
+
return;
|
|
401
|
+
case "fungible":
|
|
402
|
+
case "match":
|
|
403
|
+
return; // part-slot settings; read by the class reader
|
|
404
|
+
}
|
|
405
|
+
if (name.includes(":")) {
|
|
406
|
+
f.extra[name] = v;
|
|
407
|
+
return;
|
|
408
|
+
}
|
|
409
|
+
throw new CrubalError(`unknown setting ${name}`, line);
|
|
410
|
+
}
|
|
411
|
+
/** Read a `facet: key` block (spec 4.2). */
|
|
412
|
+
function readLongForm(node) {
|
|
413
|
+
const f = blank(node.value.trim(), "text");
|
|
414
|
+
f.line = node.line;
|
|
415
|
+
for (const child of node.children) {
|
|
416
|
+
if (child.kind !== "pair" || !child.key)
|
|
417
|
+
throw new CrubalError(`expected "setting: value": ${child.text}`, child.line);
|
|
418
|
+
if (child.key === "facets") {
|
|
419
|
+
f.children ??= new Map();
|
|
420
|
+
for (const c of child.children) {
|
|
421
|
+
const cf = c.kind === "pair" && c.key === "facet" ? readLongForm(c) : readShorthand(c.text, c.line);
|
|
422
|
+
f.children.set(cf.key, cf);
|
|
423
|
+
}
|
|
424
|
+
continue;
|
|
425
|
+
}
|
|
426
|
+
applySetting(f, child.key, child.value, child.line);
|
|
427
|
+
}
|
|
428
|
+
return f;
|
|
429
|
+
}
|
|
430
|
+
export function readClassLine(text, line, section) {
|
|
431
|
+
const p = parseLine(text, line);
|
|
432
|
+
const f = p.facet;
|
|
433
|
+
// A line narrows; it never sets what the facet means (5.3.1).
|
|
434
|
+
const meaning = ["label", "ask", "describe"].find((k) => f[k] !== undefined) ?? (f.aliases.length ? "aliases" : f.sameAs.length ? "same-as" : f.values?.some((v) => v.aliases.length) ? "value aliases" : undefined);
|
|
435
|
+
if (meaning)
|
|
436
|
+
throw new CrubalError(`the class line ${text.trim()} sets ${meaning}, which is the facet's meaning, not a narrowing`, line);
|
|
437
|
+
const cl = { facet: f.key, line, text: text.trim() };
|
|
438
|
+
if (p.required)
|
|
439
|
+
cl.required = true;
|
|
440
|
+
if (p.level)
|
|
441
|
+
cl.level = p.level;
|
|
442
|
+
if (p.whenText)
|
|
443
|
+
cl.when = p.whenText;
|
|
444
|
+
if (p.frame)
|
|
445
|
+
cl.frame = p.frame;
|
|
446
|
+
if (section)
|
|
447
|
+
cl.section = section;
|
|
448
|
+
if (p.marked) {
|
|
449
|
+
cl.type = f.type;
|
|
450
|
+
if (f.values)
|
|
451
|
+
cl.values = f.values.map((v) => v.value);
|
|
452
|
+
if (f.length !== undefined)
|
|
453
|
+
cl.length = f.length;
|
|
454
|
+
if (f.precision && f.type === "date")
|
|
455
|
+
cl.precision = f.precision;
|
|
456
|
+
}
|
|
457
|
+
if (p.count)
|
|
458
|
+
cl.pick = p.count;
|
|
459
|
+
if (f.range)
|
|
460
|
+
cl.range = { min: f.range.min, max: f.range.max };
|
|
461
|
+
return cl;
|
|
462
|
+
}
|
|
463
|
+
function readClass(node) {
|
|
464
|
+
const c = { name: node.value.trim(), line: node.line, for: [], uses: [], lines: [], parts: [], extra: {} };
|
|
465
|
+
for (const child of node.children) {
|
|
466
|
+
if (child.kind !== "pair" || !child.key)
|
|
467
|
+
throw new CrubalError(`expected "setting: value": ${child.text}`, child.line);
|
|
468
|
+
switch (child.key) {
|
|
469
|
+
case "for":
|
|
470
|
+
c.for = readList(child.value, child.line).map((p) => p.text);
|
|
471
|
+
break;
|
|
472
|
+
case "uses":
|
|
473
|
+
c.uses = readList(child.value, child.line).map((p) => p.text);
|
|
474
|
+
break;
|
|
475
|
+
case "label":
|
|
476
|
+
c.label = unquote(child.value);
|
|
477
|
+
break;
|
|
478
|
+
case "describe":
|
|
479
|
+
c.describe = unquote(child.value);
|
|
480
|
+
break;
|
|
481
|
+
case "version":
|
|
482
|
+
c.version = child.value;
|
|
483
|
+
break;
|
|
484
|
+
case "state":
|
|
485
|
+
c.state = child.value;
|
|
486
|
+
break;
|
|
487
|
+
case "facets": {
|
|
488
|
+
let section;
|
|
489
|
+
for (const l of child.children) {
|
|
490
|
+
if (l.kind === "pair" && l.key === "section") {
|
|
491
|
+
section = unquote(l.value);
|
|
492
|
+
continue;
|
|
493
|
+
}
|
|
494
|
+
c.lines.push(readClassLine(l.text, l.line, section));
|
|
495
|
+
}
|
|
496
|
+
break;
|
|
497
|
+
}
|
|
498
|
+
case "parts":
|
|
499
|
+
for (const l of child.children) {
|
|
500
|
+
const pair = l.kind === "pair" && l.key ? { key: l.key, value: l.value } : null;
|
|
501
|
+
if (!pair)
|
|
502
|
+
throw new CrubalError(`a part slot is "slot: Class": ${l.text}`, l.line);
|
|
503
|
+
const t = tokens(pair.value, l.line);
|
|
504
|
+
const wears = t[0] ?? "";
|
|
505
|
+
const slot = { slot: pair.key, wears, many: false, fungible: false, line: l.line };
|
|
506
|
+
for (let i = 1; i < t.length; i++) {
|
|
507
|
+
const tok = t[i];
|
|
508
|
+
if (tok.startsWith("*"))
|
|
509
|
+
slot.many = tok !== "*1";
|
|
510
|
+
else if (tok === "fungible:")
|
|
511
|
+
slot.fungible = yes(t[++i] ?? "");
|
|
512
|
+
else if (tok === "match:")
|
|
513
|
+
slot.match = t[++i];
|
|
514
|
+
else if (tok === "fungible")
|
|
515
|
+
slot.fungible = true;
|
|
516
|
+
}
|
|
517
|
+
c.parts.push(slot);
|
|
518
|
+
}
|
|
519
|
+
break;
|
|
520
|
+
default:
|
|
521
|
+
if (!child.key.includes(":"))
|
|
522
|
+
throw new CrubalError(`unknown class setting ${child.key}`, child.line);
|
|
523
|
+
c.extra[child.key] = child.value.trim();
|
|
524
|
+
}
|
|
525
|
+
}
|
|
526
|
+
return c;
|
|
527
|
+
}
|
|
528
|
+
const SKIP = new Set(["rule", "contract", "view", "shape", "display", "print", "filter", "role", "migration", "package", "resolve", "permissions", "ownership", "emergency", "edge", "instructions", "utility", "group", "lane", "flow", "act", "subject"]); // "subject": the lane's first name (revision 9), carried unchanged in text already published
|
|
529
|
+
/** Read definition text (facets, classes and kinds) into a dictionary. Other blocks are skipped. */
|
|
530
|
+
/** The sorts of definition a link may name (4.2.2, revision 20): `&def:facet` holds a facet's key, never a record. */
|
|
531
|
+
export const DEFINITION_SORTS = ["kind", "class", "facet", "utility", "event", "package", "lane", "form", "view", "print"];
|
|
532
|
+
/** A link's target as written, refused when it names a definition sort the language doesn't have. */
|
|
533
|
+
function checkLinkTo(to, line) {
|
|
534
|
+
if (to.startsWith("def:") && !DEFINITION_SORTS.includes(to.slice(4)))
|
|
535
|
+
throw new CrubalError(`a definition link names one of ${DEFINITION_SORTS.join(", ")}, not ${to.slice(4) || "nothing"}`, line);
|
|
536
|
+
return to;
|
|
537
|
+
}
|
|
538
|
+
/** The sort a link facet's values name when it links to definitions, or nothing for a record link. */
|
|
539
|
+
export function definitionSortOf(f) {
|
|
540
|
+
return f.type === "link" && f.to?.startsWith("def:") ? f.to.slice(4) : undefined;
|
|
541
|
+
}
|
|
542
|
+
export function readDefinitions(source, into = emptyDictionary()) {
|
|
543
|
+
for (const node of readTree(source)) {
|
|
544
|
+
if (node.kind === "pair" && node.key) {
|
|
545
|
+
if (node.key === "facet") {
|
|
546
|
+
const f = readLongForm(node);
|
|
547
|
+
into.facets.set(f.key, f);
|
|
548
|
+
continue;
|
|
549
|
+
}
|
|
550
|
+
if (node.key === "class") {
|
|
551
|
+
const c = readClass(node);
|
|
552
|
+
into.classes.set(c.name, c);
|
|
553
|
+
continue;
|
|
554
|
+
}
|
|
555
|
+
if (node.key === "trust") {
|
|
556
|
+
into.trust = node.children.map((c) => c.text.trim());
|
|
557
|
+
continue;
|
|
558
|
+
}
|
|
559
|
+
if (node.key === "facet-trust") {
|
|
560
|
+
for (const c of node.children)
|
|
561
|
+
if (c.key)
|
|
562
|
+
into.facetTrust.set(c.key, readList(c.value, c.line).map((p) => p.text));
|
|
563
|
+
continue;
|
|
564
|
+
}
|
|
565
|
+
if (node.key === "kind") {
|
|
566
|
+
const kind = node.value.trim();
|
|
567
|
+
const levels = node.children.find((c) => c.key === "levels");
|
|
568
|
+
const names = levels ? splitTop(levels.value, ",", levels.line) : [kind];
|
|
569
|
+
for (const level of names) {
|
|
570
|
+
// Level names are unique across the kinds of one package (1.2), so a level names its kind.
|
|
571
|
+
const had = into.levels.get(level);
|
|
572
|
+
if (had && had !== kind)
|
|
573
|
+
throw new CrubalError(`${level} is already a level of ${had}`, levels?.line ?? node.line);
|
|
574
|
+
into.levels.set(level, kind);
|
|
575
|
+
}
|
|
576
|
+
const def = { name: kind, line: node.line, levels: names };
|
|
577
|
+
const base = node.children.find((c) => c.key === "base");
|
|
578
|
+
if (base)
|
|
579
|
+
def.base = base.value.trim();
|
|
580
|
+
const schema = node.children.find((c) => c.key === "schema");
|
|
581
|
+
if (schema)
|
|
582
|
+
def.schema = schema.children.length ? Object.fromEntries(schema.children.filter((c) => c.key).map((c) => [c.key, c.value.trim()])) : schema.value.trim();
|
|
583
|
+
const follows = node.children.find((c) => c.key === "follows");
|
|
584
|
+
if (follows)
|
|
585
|
+
def.follows = Object.fromEntries(follows.children.filter((c) => c.key).map((c) => [c.key, c.value.trim()]));
|
|
586
|
+
// Revision 31: `follow:`, per level the aspects a follower may choose, lower-case words, the first the default.
|
|
587
|
+
const follow = node.children.find((c) => c.key === "follow");
|
|
588
|
+
if (follow) {
|
|
589
|
+
def.follow = {};
|
|
590
|
+
def.followLine = follow.line;
|
|
591
|
+
for (const l of follow.children) {
|
|
592
|
+
if (!l.key)
|
|
593
|
+
continue;
|
|
594
|
+
if (!names.includes(l.key))
|
|
595
|
+
throw new CrubalError(`follow names ${l.key}, which isn't a level of ${kind}`, l.line);
|
|
596
|
+
const aspects = splitTop(l.value, ",", l.line).filter(Boolean);
|
|
597
|
+
if (!aspects.length)
|
|
598
|
+
throw new CrubalError(`follow at ${l.key} names no aspect`, l.line);
|
|
599
|
+
for (const a of aspects)
|
|
600
|
+
if (!/^[a-z][\w-]*$/.test(a))
|
|
601
|
+
throw new CrubalError(`follow at ${l.key}: an aspect is a lower-case word, not ${a}`, l.line);
|
|
602
|
+
if (new Set(aspects).size !== aspects.length)
|
|
603
|
+
throw new CrubalError(`follow at ${l.key} names an aspect twice`, l.line);
|
|
604
|
+
def.follow[l.key] = aspects;
|
|
605
|
+
}
|
|
606
|
+
}
|
|
607
|
+
// Revision 35: `shares:`, per level the facet that is its quantity: a record there may be taken in part.
|
|
608
|
+
const shares = node.children.find((c) => c.key === "shares");
|
|
609
|
+
if (shares) {
|
|
610
|
+
def.shares = {};
|
|
611
|
+
def.sharesLine = shares.line;
|
|
612
|
+
for (const l of shares.children) {
|
|
613
|
+
if (!l.key)
|
|
614
|
+
continue;
|
|
615
|
+
if (!names.includes(l.key))
|
|
616
|
+
throw new CrubalError(`shares names ${l.key}, which isn't a level of ${kind}`, l.line);
|
|
617
|
+
const facet = l.value.trim();
|
|
618
|
+
if (!/^[\w:-]+$/.test(facet))
|
|
619
|
+
throw new CrubalError(`shares at ${l.key} names one facet, its quantity: ${facet}`, l.line);
|
|
620
|
+
def.shares[l.key] = facet;
|
|
621
|
+
}
|
|
622
|
+
}
|
|
623
|
+
// Revision 56: `face:`, per level the face a record's card wears, a surface's own lower-case word.
|
|
624
|
+
const face = node.children.find((c) => c.key === "face");
|
|
625
|
+
if (face) {
|
|
626
|
+
def.face = {};
|
|
627
|
+
for (const l of face.children) {
|
|
628
|
+
if (!l.key)
|
|
629
|
+
continue;
|
|
630
|
+
if (!names.includes(l.key))
|
|
631
|
+
throw new CrubalError(`face names ${l.key}, which isn't a level of ${kind}`, l.line);
|
|
632
|
+
const word = l.value.trim();
|
|
633
|
+
if (!/^[a-z][a-z0-9-]*$/.test(word))
|
|
634
|
+
throw new CrubalError(`face at ${l.key} is one lower-case word, a surface's name for the card: ${word}`, l.line);
|
|
635
|
+
def.face[l.key] = word;
|
|
636
|
+
}
|
|
637
|
+
}
|
|
638
|
+
into.kinds.set(kind, def);
|
|
639
|
+
const vary = node.children.find((c) => c.key === "vary");
|
|
640
|
+
for (const step of vary?.children ?? []) {
|
|
641
|
+
if (!step.key)
|
|
642
|
+
continue;
|
|
643
|
+
const set = into.vary.get(step.key) ?? new Set();
|
|
644
|
+
for (const k of splitTop(step.value, ",", step.line))
|
|
645
|
+
if (k)
|
|
646
|
+
set.add(k);
|
|
647
|
+
into.vary.set(step.key, set);
|
|
648
|
+
into.varyLines.set(step.key, step.line);
|
|
649
|
+
}
|
|
650
|
+
// Arrival keys (9.2a) and the archive cascade (1.12).
|
|
651
|
+
const identify = node.children.find((c) => c.key === "identify");
|
|
652
|
+
for (const l of identify?.children ?? [])
|
|
653
|
+
if (l.key)
|
|
654
|
+
into.identify.set(l.key, splitTop(l.value, ",", l.line).filter(Boolean));
|
|
655
|
+
const match = node.children.find((c) => c.key === "match");
|
|
656
|
+
for (const l of match?.children ?? []) {
|
|
657
|
+
if (!l.key)
|
|
658
|
+
continue;
|
|
659
|
+
const groups = l.value.split(";").map((g) => g.split("+").map((k) => k.trim()).filter(Boolean)).filter((g) => g.length);
|
|
660
|
+
into.match.set(l.key, groups);
|
|
661
|
+
}
|
|
662
|
+
const archive = node.children.find((c) => c.key === "archive");
|
|
663
|
+
if (archive) {
|
|
664
|
+
const a = archive.value.trim();
|
|
665
|
+
if (!["independent", "cascade of", "cascade within", "cascade both"].includes(a))
|
|
666
|
+
throw new CrubalError(`archive is independent, cascade of, cascade within or cascade both, not ${a}`, archive.line);
|
|
667
|
+
into.archive.set(kind, a);
|
|
668
|
+
}
|
|
669
|
+
continue;
|
|
670
|
+
}
|
|
671
|
+
if (SKIP.has(node.key) || node.key === "crubal" || node.key === "owner")
|
|
672
|
+
continue;
|
|
673
|
+
}
|
|
674
|
+
const f = readShorthand(node.text, node.line);
|
|
675
|
+
into.facets.set(f.key, f);
|
|
676
|
+
}
|
|
677
|
+
return into;
|
|
678
|
+
}
|
|
679
|
+
/** Split a case input into its definitions part and its data part (the data starts at `crubal:`). */
|
|
680
|
+
export function splitCaseInput(source) {
|
|
681
|
+
const lines = source.split(/\r?\n/);
|
|
682
|
+
const at = lines.findIndex((l) => /^crubal: /.test(l));
|
|
683
|
+
if (at < 0)
|
|
684
|
+
return { defs: source, data: "", dataLine: 0 };
|
|
685
|
+
// Blank the other part's lines instead of cutting them, so line numbers stay true.
|
|
686
|
+
const defs = lines.map((l, i) => (i < at ? l : "")).join("\n");
|
|
687
|
+
const data = lines.map((l, i) => (i >= at ? l : "")).join("\n");
|
|
688
|
+
return { defs, data, dataLine: at + 1 };
|
|
689
|
+
}
|
|
690
|
+
//# sourceMappingURL=defs.js.map
|