@steedos/odata-v4-parser 2.5.3-beta.2 → 2.5.3-beta.21

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.
Files changed (7) hide show
  1. package/package.json +2 -2
  2. package/src/json.ts +371 -371
  3. package/src/nameOrIdentifier.ts +748 -748
  4. package/src/odataUri.ts +37 -37
  5. package/src/primitiveLiteral.ts +684 -684
  6. package/src/resourcePath.ts +461 -461
  7. package/src/utils.ts +36 -36
package/src/primitiveLiteral.ts CHANGED
@@ -1,684 +1,684 @@
1
- import Utils from "./utils";
2
- import Lexer from "./lexer";
3
- import NameOrIdentifier from "./nameOrIdentifier";
4
-
5
- export namespace PrimitiveLiteral {
6
- export function nullValue(value: Utils.SourceArray, index: number): Lexer.Token {
7
- if (Utils.equals(value, index, "null")) return Lexer.tokenize(value, index, index + 4, "null", Lexer.TokenType.Literal);
8
- }
9
- export function booleanValue(value: Utils.SourceArray, index: number): Lexer.Token {
10
- if (Utils.equals(value, index, "true")) return Lexer.tokenize(value, index, index + 4, "Edm.Boolean", Lexer.TokenType.Literal);
11
- if (Utils.equals(value, index, "false")) return Lexer.tokenize(value, index, index + 5, "Edm.Boolean", Lexer.TokenType.Literal);
12
- }
13
- export function guidValue(value, index): Lexer.Token {
14
- if (Utils.required(value, index, Lexer.HEXDIG, 8, 8) &&
15
- value[index + 8] === 0x2d &&
16
- Utils.required(value, index + 9, Lexer.HEXDIG, 4, 4) &&
17
- value[index + 13] === 0x2d &&
18
- Utils.required(value, index + 14, Lexer.HEXDIG, 4, 4) &&
19
- value[index + 18] === 0x2d &&
20
- Utils.required(value, index + 19, Lexer.HEXDIG, 4, 4) &&
21
- value[index + 23] === 0x2d &&
22
- Utils.required(value, index + 24, Lexer.HEXDIG, 12)) return Lexer.tokenize(value, index, index + 36, "Edm.Guid", Lexer.TokenType.Literal);
23
- }
24
- export function sbyteValue(value: Utils.SourceArray, index: number): Lexer.Token {
25
- let start = index;
26
- let sign = Lexer.SIGN(value, index);
27
- if (sign) index = sign;
28
-
29
- let next = Utils.required(value, index, Lexer.DIGIT, 1, 3);
30
- if (next) {
31
- if (Lexer.DIGIT(value[next])) return;
32
- let val = parseInt(Utils.stringify(value, start, next), 10);
33
- if (val >= -128 && val <= 127) return Lexer.tokenize(value, start, next, "Edm.SByte", Lexer.TokenType.Literal);
34
- }
35
- }
36
- export function byteValue(value: Utils.SourceArray, index: number): Lexer.Token {
37
- let next = Utils.required(value, index, Lexer.DIGIT, 1, 3);
38
- if (next) {
39
- if (Lexer.DIGIT(value[next])) return;
40
- let val = parseInt(Utils.stringify(value, index, next), 10);
41
- if (val >= 0 && val <= 255) return Lexer.tokenize(value, index, next, "Edm.Byte", Lexer.TokenType.Literal);
42
- }
43
- }
44
- export function int16Value(value: Utils.SourceArray, index: number): Lexer.Token {
45
- let start = index;
46
- let sign = Lexer.SIGN(value, index);
47
- if (sign) index = sign;
48
-
49
- let next = Utils.required(value, index, Lexer.DIGIT, 1, 5);
50
- if (next) {
51
- if (Lexer.DIGIT(value[next])) return;
52
- let val = parseInt(Utils.stringify(value, start, next), 10);
53
- if (val >= -32768 && val <= 32767) return Lexer.tokenize(value, start, next, "Edm.Int16", Lexer.TokenType.Literal);
54
- }
55
- }
56
- export function int32Value(value: Utils.SourceArray, index: number): Lexer.Token {
57
- let start = index;
58
- let sign = Lexer.SIGN(value, index);
59
- if (sign) index = sign;
60
-
61
- let next = Utils.required(value, index, Lexer.DIGIT, 1, 10);
62
- if (next) {
63
- if (Lexer.DIGIT(value[next])) return;
64
- let val = parseInt(Utils.stringify(value, start, next), 10);
65
- if (val >= -2147483648 && val <= 2147483647) return Lexer.tokenize(value, start, next, "Edm.Int32", Lexer.TokenType.Literal);
66
- }
67
- }
68
- export function int64Value(value: Utils.SourceArray, index: number): Lexer.Token {
69
- let start = index;
70
- let sign = Lexer.SIGN(value, index);
71
- if (sign) index = sign;
72
-
73
- let next = Utils.required(value, index, Lexer.DIGIT, 1, 19);
74
- if (next) {
75
- if (Lexer.DIGIT(value[next])) return;
76
- let val = Utils.stringify(value, index, next);
77
- if (val >= "0" && val <= (value[start] === 0x2d ? "9223372036854775808" : "9223372036854775807")) return Lexer.tokenize(value, start, next, "Edm.Int64", Lexer.TokenType.Literal);
78
- }
79
- }
80
- export function decimalValue(value: Utils.SourceArray, index: number): Lexer.Token {
81
- let start = index;
82
- let sign = Lexer.SIGN(value, index);
83
- if (sign) index = sign;
84
-
85
- let intNext = Utils.required(value, index, Lexer.DIGIT, 1);
86
- if (!intNext) return;
87
-
88
- let end = intNext;
89
- if (value[intNext] === 0x2e) {
90
- end = Utils.required(value, intNext + 1, Lexer.DIGIT, 1);
91
- if (!end || end === intNext + 1) return;
92
- } else return;
93
-
94
- // TODO: detect only decimal value, no double/single detection here
95
- if (value[end] === 0x65) return;
96
-
97
- return Lexer.tokenize(value, start, end, "Edm.Decimal", Lexer.TokenType.Literal);
98
- }
99
- export function doubleValue(value: Utils.SourceArray, index: number): Lexer.Token {
100
- let start = index;
101
- let end = index;
102
- let nanInfLen = Lexer.nanInfinity(value, index);
103
- if (nanInfLen) {
104
- end += nanInfLen;
105
- } else {
106
- // TODO: use decimalValue function
107
- // var token = decimalValue(value, index);
108
- let sign = Lexer.SIGN(value, index);
109
- if (sign) index = sign;
110
-
111
- let intNext = Utils.required(value, index, Lexer.DIGIT, 1);
112
- if (!intNext) return;
113
-
114
- let decimalNext = intNext;
115
- if (value[intNext] === 0x2e) {
116
- decimalNext = Utils.required(value, intNext + 1, Lexer.DIGIT, 1);
117
- if (decimalNext === intNext + 1) return;
118
- } else return;
119
-
120
- if (value[decimalNext] === 0x65) {
121
- let next = decimalNext + 1;
122
- let sign = Lexer.SIGN(value, next);
123
- if (sign) next = sign;
124
-
125
- let digitNext = Utils.required(value, next, Lexer.DIGIT, 1);
126
- if (digitNext) {
127
- end = digitNext;
128
- }
129
- } else end = decimalNext;
130
- }
131
-
132
- return Lexer.tokenize(value, start, end, "Edm.Double", Lexer.TokenType.Literal);
133
- }
134
- export function singleValue(value: Utils.SourceArray, index: number): Lexer.Token {
135
- let token = PrimitiveLiteral.doubleValue(value, index);
136
- if (token) {
137
- token.value = "Edm.Single";
138
- }
139
- return token;
140
- }
141
- export function stringValue(value: Utils.SourceArray, index: number): Lexer.Token {
142
- let start = index;
143
- let squote = Lexer.SQUOTE(value, start);
144
- if (squote) {
145
- index = squote;
146
- while (index < value.length) {
147
- squote = Lexer.SQUOTE(value, index);
148
- if (squote) {
149
- index = squote;
150
- squote = Lexer.SQUOTE(value, index);
151
- if (!squote) {
152
- let close = Lexer.CLOSE(value, index);
153
- let comma = Lexer.COMMA(value, index);
154
- let amp = value[index] === 0x26;
155
- if (Lexer.pcharNoSQUOTE(value, index) > index && !amp && !close && !comma && Lexer.RWS(value, index) === index) return;
156
- break;
157
- } else {
158
- index = squote;
159
- }
160
- } else {
161
- let nextIndex = Math.max(Lexer.RWS(value, index), Lexer.pcharNoSQUOTE(value, index));
162
- if (nextIndex === index) return;
163
- index = nextIndex;
164
- }
165
- }
166
-
167
- squote = Lexer.SQUOTE(value, index - 1) || Lexer.SQUOTE(value, index - 3);
168
- if (!squote) return;
169
- index = squote;
170
-
171
- return Lexer.tokenize(value, start, index, "Edm.String", Lexer.TokenType.Literal);
172
- }
173
- }
174
-
175
-
176
- export function arrayValue(value: Utils.SourceArray, index: number): Lexer.Token {
177
- if (!Utils.equals(value, index, "(") || !(Utils.equals(value, index-3, "in") || Utils.equals(value, index-3, "notin"))) return;
178
- let start = index;
179
- let squote = Lexer.OPEN(value, start);
180
- if (squote) {
181
- index = squote;
182
- while (index < value.length) {
183
- squote = Lexer.CLOSE(value, index);
184
- if (squote) {
185
- index = squote;
186
- squote = Lexer.OPEN(value, index);
187
- if (!squote) {
188
- let close = Lexer.CLOSE(value, index);
189
- let comma = Lexer.COMMA(value, index);
190
- let amp = value[index] === 0x26;
191
- if (Lexer.pcharNoSQUOTE(value, index) > index && !amp && !close && !comma && Lexer.RWS(value, index) === index) return;
192
- break;
193
- } else {
194
- index = squote;
195
- }
196
- } else {
197
- let nextIndex = index + 1;
198
- if (nextIndex === index) return;
199
- index = nextIndex;
200
- }
201
- }
202
- // console.log(`--->index`, index)
203
- // squote = Lexer.SQUOTE(value, index - 1) || Lexer.SQUOTE(value, index - 3);
204
- // console.log(`--->squote`, squote)
205
- // if (!squote) return;
206
- // index = squote;
207
- return Lexer.tokenize(value, start, index, "Edm.Array", Lexer.TokenType.Literal);
208
- }
209
- }
210
-
211
- export function durationValue(value: Utils.SourceArray, index: number): Lexer.Token {
212
- if (!Utils.equals(value, index, "duration")) return;
213
- let start = index;
214
- index += 8;
215
-
216
- let squote = Lexer.SQUOTE(value, index);
217
- if (!squote) return;
218
- index = squote;
219
-
220
- let sign = Lexer.SIGN(value, index);
221
- if (sign) index = sign;
222
-
223
- if (value[index] !== 0x50) return;
224
- index++;
225
- let dayNext = Utils.required(value, index, Lexer.DIGIT, 1);
226
- if (dayNext === index && value[index + 1] !== 0x54) return;
227
- index = dayNext;
228
- if (value[index] === 0x44) index++;
229
- let end = index;
230
- if (value[index] === 0x54) {
231
- index++;
232
- const parseTimeFn = function () {
233
- let squote = Lexer.SQUOTE(value, index);
234
- if (squote) return index;
235
- let digitNext = Utils.required(value, index, Lexer.DIGIT, 1);
236
- if (digitNext === index) return;
237
- index = digitNext;
238
- if (value[index] === 0x53) {
239
- end = index + 1;
240
- return end;
241
- } else if (value[index] === 0x2e) {
242
- index++;
243
- let fractionalSecondsNext = Utils.required(value, index, Lexer.DIGIT, 1);
244
- if (fractionalSecondsNext === index || value[fractionalSecondsNext] !== 0x53) return;
245
- end = fractionalSecondsNext + 1;
246
- return end;
247
- } else if (value[index] === 0x48) {
248
- index++;
249
- end = index;
250
- return parseTimeFn();
251
- } else if (value[index] === 0x4d) {
252
- index++;
253
- end = index;
254
- return parseTimeFn();
255
- }
256
- };
257
- let next = parseTimeFn();
258
- if (!next) return;
259
- }
260
-
261
- squote = Lexer.SQUOTE(value, end);
262
- if (!squote) return;
263
- end = squote;
264
-
265
- return Lexer.tokenize(value, start, end, "Edm.Duration", Lexer.TokenType.Literal);
266
- }
267
- export function binaryValue(value: Utils.SourceArray, index: number): Lexer.Token {
268
- let start = index;
269
- if (!Utils.equals(value, index, "binary")) return;
270
- index += 6;
271
-
272
- let squote = Lexer.SQUOTE(value, index);
273
- if (!squote) return;
274
- index = squote;
275
-
276
- while (index < value.length && !(squote = Lexer.SQUOTE(value, index))) {
277
- let end = Math.max(Lexer.base64b16(value, index), Lexer.base64b8(value, index));
278
- if (end > index) index = end;
279
- else if (Lexer.base64char(value[index]) &&
280
- Lexer.base64char(value[index + 1]) &&
281
- Lexer.base64char(value[index + 2]) &&
282
- Lexer.base64char(value[index + 3])) index += 4;
283
- else index++;
284
- }
285
- index = squote;
286
-
287
- return Lexer.tokenize(value, start, index, "Edm.Binary", Lexer.TokenType.Literal);
288
- }
289
- export function dateValue(value: Utils.SourceArray, index: number): Lexer.Token {
290
- let yearNext = Lexer.year(value, index);
291
- if (yearNext === index || value[yearNext] !== 0x2d) return;
292
- let monthNext = Lexer.month(value, yearNext + 1);
293
- if ((monthNext === yearNext + 1) || value[monthNext] !== 0x2d) return;
294
- let dayNext = Lexer.day(value, monthNext + 1);
295
- // TODO: join dateValue and dateTimeOffsetValue for optimalization
296
- if (dayNext === monthNext + 1 || value[dayNext] === 0x54) return;
297
- return Lexer.tokenize(value, index, dayNext, "Edm.Date", Lexer.TokenType.Literal);
298
- }
299
- export function dateTimeOffsetValue(value: Utils.SourceArray, index: number): Lexer.Token {
300
- let yearNext = Lexer.year(value, index);
301
- if (yearNext === index || value[yearNext] !== 0x2d) return;
302
- let monthNext = Lexer.month(value, yearNext + 1);
303
- if ((monthNext === yearNext + 1) || value[monthNext] !== 0x2d) return;
304
- let dayNext = Lexer.day(value, monthNext + 1);
305
- if (dayNext === monthNext + 1 || value[dayNext] !== 0x54) return;
306
- let hourNext = Lexer.hour(value, dayNext + 1);
307
-
308
- let colon = Lexer.COLON(value, hourNext);
309
- if (hourNext === colon || !colon) return;
310
- let minuteNext = Lexer.minute(value, hourNext + 1);
311
- if (minuteNext === hourNext + 1) return;
312
-
313
- let end = minuteNext;
314
- colon = Lexer.COLON(value, minuteNext);
315
- if (colon) {
316
- let secondNext = Lexer.second(value, colon);
317
- if (secondNext === colon) return;
318
- if (value[secondNext] === 0x2e) {
319
- let fractionalSecondsNext = Lexer.fractionalSeconds(value, secondNext + 1);
320
- if (fractionalSecondsNext === secondNext + 1) return;
321
- end = fractionalSecondsNext;
322
- } else end = secondNext;
323
- }
324
-
325
- let sign = Lexer.SIGN(value, end);
326
- if (value[end] === 0x5a) {
327
- end++;
328
- } else if (sign) {
329
- let zHourNext = Lexer.hour(value, sign);
330
- let colon = Lexer.COLON(value, zHourNext);
331
- if (zHourNext === sign || !colon) return;
332
- let zMinuteNext = Lexer.minute(value, colon);
333
- if (zMinuteNext === colon) return;
334
- end = zMinuteNext;
335
- } else return;
336
-
337
- return Lexer.tokenize(value, index, end, "Edm.DateTimeOffset", Lexer.TokenType.Literal);
338
- }
339
- export function timeOfDayValue(value: Utils.SourceArray, index: number): Lexer.Token {
340
- let hourNext = Lexer.hour(value, index);
341
- let colon = Lexer.COLON(value, hourNext);
342
- if (hourNext === index || !colon) return;
343
- let minuteNext = Lexer.minute(value, colon);
344
- if (minuteNext === colon) return;
345
-
346
- let end = minuteNext;
347
- colon = Lexer.COLON(value, minuteNext);
348
- if (colon) {
349
- let secondNext = Lexer.second(value, colon);
350
- if (secondNext === colon) return;
351
- if (value[secondNext] === 0x2e) {
352
- let fractionalSecondsNext = Lexer.fractionalSeconds(value, secondNext + 1);
353
- if (fractionalSecondsNext === secondNext + 1) return;
354
- end = fractionalSecondsNext;
355
- } else end = secondNext;
356
- }
357
-
358
- return Lexer.tokenize(value, index, end, "Edm.TimeOfDay", Lexer.TokenType.Literal);
359
- }
360
-
361
- // geography and geometry literals
362
- export function positionLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
363
- let longitude = PrimitiveLiteral.doubleValue(value, index);
364
- if (!longitude) return;
365
-
366
- let next = Lexer.RWS(value, longitude.next);
367
- if (next === longitude.next) return;
368
-
369
- let latitude = PrimitiveLiteral.doubleValue(value, next);
370
- if (!latitude) return;
371
-
372
- return Lexer.tokenize(value, index, latitude.next, { longitude, latitude }, Lexer.TokenType.Literal);
373
- }
374
- export function pointData(value: Utils.SourceArray, index: number): Lexer.Token {
375
- let open = Lexer.OPEN(value, index);
376
- if (!open) return;
377
- let start = index;
378
- index = open;
379
-
380
- let position = PrimitiveLiteral.positionLiteral(value, index);
381
- if (!position) return;
382
- index = position.next;
383
-
384
- let close = Lexer.CLOSE(value, index);
385
- if (!close) return;
386
- index = close;
387
-
388
- return Lexer.tokenize(value, start, index, position, Lexer.TokenType.Literal);
389
- }
390
- export function lineStringData(value: Utils.SourceArray, index: number): Lexer.Token {
391
- return PrimitiveLiteral.multiGeoLiteralFactory(value, index, "", PrimitiveLiteral.positionLiteral);
392
- }
393
- export function ringLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
394
- return PrimitiveLiteral.multiGeoLiteralFactory(value, index, "", PrimitiveLiteral.positionLiteral);
395
- // Within each ringLiteral, the first and last positionLiteral elements MUST be an exact syntactic match to each other.
396
- // Within the polygonData, the ringLiterals MUST specify their points in appropriate winding order.
397
- // In order of traversal, points to the left side of the ring are interpreted as being in the polygon.
398
- }
399
- export function polygonData(value: Utils.SourceArray, index: number): Lexer.Token {
400
- return PrimitiveLiteral.multiGeoLiteralFactory(value, index, "", PrimitiveLiteral.ringLiteral);
401
- }
402
- export function sridLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
403
- if (!Utils.equals(value, index, "SRID")) return;
404
- let start = index;
405
- index += 4;
406
-
407
- let eq = Lexer.EQ(value, index);
408
- if (!eq) return;
409
- index++;
410
-
411
- let digit = Utils.required(value, index, Lexer.DIGIT, 1, 5);
412
- if (!digit) return;
413
- index = digit;
414
-
415
- let semi = Lexer.SEMI(value, index);
416
- if (!semi) return;
417
- index = semi;
418
-
419
- return Lexer.tokenize(value, start, index, "SRID", Lexer.TokenType.Literal);
420
- }
421
- export function pointLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
422
- if (!Utils.equals(value, index, "Point")) return;
423
- let start = index;
424
- index += 5;
425
-
426
- let data = PrimitiveLiteral.pointData(value, index);
427
- if (!data) return;
428
-
429
- return Lexer.tokenize(value, start, data.next, data, Lexer.TokenType.Literal);
430
- }
431
- export function polygonLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
432
- if (!Utils.equals(value, index, "Polygon")) return;
433
- let start = index;
434
- index += 7;
435
-
436
- let data = PrimitiveLiteral.polygonData(value, index);
437
- if (!data) return;
438
-
439
- return Lexer.tokenize(value, start, data.next, data, Lexer.TokenType.Literal);
440
- }
441
- export function collectionLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
442
- return PrimitiveLiteral.multiGeoLiteralFactory(value, index, "Collection", PrimitiveLiteral.geoLiteral);
443
- }
444
- export function lineStringLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
445
- if (!Utils.equals(value, index, "LineString")) return;
446
- let start = index;
447
- index += 10;
448
-
449
- let data = PrimitiveLiteral.lineStringData(value, index);
450
- if (!data) return;
451
- index = data.next;
452
-
453
- return Lexer.tokenize(value, start, index, data, Lexer.TokenType.Literal);
454
- }
455
- export function multiLineStringLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
456
- return PrimitiveLiteral.multiGeoLiteralOptionalFactory(value, index, "MultiLineString", PrimitiveLiteral.lineStringData);
457
- }
458
- export function multiPointLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
459
- return PrimitiveLiteral.multiGeoLiteralOptionalFactory(value, index, "MultiPoint", PrimitiveLiteral.pointData);
460
- }
461
- export function multiPolygonLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
462
- return PrimitiveLiteral.multiGeoLiteralOptionalFactory(value, index, "MultiPolygon", PrimitiveLiteral.polygonData);
463
- }
464
- export function multiGeoLiteralFactory(value: Utils.SourceArray, index: number, prefix: string, itemLiteral: Function): Lexer.Token {
465
- if (!Utils.equals(value, index, prefix + "(")) return;
466
- let start = index;
467
- index += prefix.length + 1;
468
-
469
- let items = [];
470
- let geo = itemLiteral(value, index);
471
- if (!geo) return;
472
- index = geo.next;
473
-
474
- while (geo) {
475
- items.push(geo);
476
-
477
- let close = Lexer.CLOSE(value, index);
478
- if (close) {
479
- index = close;
480
- break;
481
- }
482
-
483
- let comma = Lexer.COMMA(value, index);
484
- if (!comma) return;
485
- index = comma;
486
-
487
- geo = itemLiteral(value, index);
488
- if (!geo) return;
489
- index = geo.next;
490
- }
491
-
492
- return Lexer.tokenize(value, start, index, { items }, Lexer.TokenType.Literal);
493
- }
494
- export function multiGeoLiteralOptionalFactory(value: Utils.SourceArray, index: number, prefix: string, itemLiteral: Function): Lexer.Token {
495
- if (!Utils.equals(value, index, prefix + "(")) return;
496
- let start = index;
497
- index += prefix.length + 1;
498
-
499
- let items = [];
500
- let close = Lexer.CLOSE(value, index);
501
- if (!close) {
502
- let geo = itemLiteral(value, index);
503
- if (!geo) return;
504
- index = geo.next;
505
-
506
- while (geo) {
507
- items.push(geo);
508
-
509
- close = Lexer.CLOSE(value, index);
510
- if (close) {
511
- index = close;
512
- break;
513
- }
514
-
515
- let comma = Lexer.COMMA(value, index);
516
- if (!comma) return;
517
- index = comma;
518
-
519
- geo = itemLiteral(value, index);
520
- if (!geo) return;
521
- index = geo.next;
522
- }
523
- }else index++;
524
-
525
- return Lexer.tokenize(value, start, index, { items }, Lexer.TokenType.Literal);
526
- }
527
- export function geoLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
528
- return PrimitiveLiteral.collectionLiteral(value, index) ||
529
- PrimitiveLiteral.lineStringLiteral(value, index) ||
530
- PrimitiveLiteral.multiPointLiteral(value, index) ||
531
- PrimitiveLiteral.multiLineStringLiteral(value, index) ||
532
- PrimitiveLiteral.multiPolygonLiteral(value, index) ||
533
- PrimitiveLiteral.pointLiteral(value, index) ||
534
- PrimitiveLiteral.polygonLiteral(value, index);
535
- }
536
- export function fullPointLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
537
- return PrimitiveLiteral.fullGeoLiteralFactory(value, index, PrimitiveLiteral.pointLiteral);
538
- }
539
- export function fullCollectionLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
540
- return PrimitiveLiteral.fullGeoLiteralFactory(value, index, PrimitiveLiteral.collectionLiteral);
541
- }
542
- export function fullLineStringLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
543
- return PrimitiveLiteral.fullGeoLiteralFactory(value, index, PrimitiveLiteral.lineStringLiteral);
544
- }
545
- export function fullMultiLineStringLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
546
- return PrimitiveLiteral.fullGeoLiteralFactory(value, index, PrimitiveLiteral.multiLineStringLiteral);
547
- }
548
- export function fullMultiPointLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
549
- return PrimitiveLiteral.fullGeoLiteralFactory(value, index, PrimitiveLiteral.multiPointLiteral);
550
- }
551
- export function fullMultiPolygonLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
552
- return PrimitiveLiteral.fullGeoLiteralFactory(value, index, PrimitiveLiteral.multiPolygonLiteral);
553
- }
554
- export function fullPolygonLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
555
- return PrimitiveLiteral.fullGeoLiteralFactory(value, index, PrimitiveLiteral.polygonLiteral);
556
- }
557
- export function fullGeoLiteralFactory(value: Utils.SourceArray, index: number, literal: Function): Lexer.Token {
558
- let srid = PrimitiveLiteral.sridLiteral(value, index);
559
- if (!srid) return;
560
-
561
- let token = literal(value, srid.next);
562
- if (!token) return;
563
-
564
- return Lexer.tokenize(value, index, token.next, { srid, value: token }, Lexer.TokenType.Literal);
565
- }
566
-
567
- export function geographyCollection(value: Utils.SourceArray, index: number): Lexer.Token {
568
- let prefix = Lexer.geographyPrefix(value, index);
569
- if (prefix === index) return;
570
- let start = index;
571
- index = prefix;
572
-
573
- let squote = Lexer.SQUOTE(value, index);
574
- if (!squote) return;
575
- index = squote;
576
-
577
- let point = PrimitiveLiteral.fullCollectionLiteral(value, index);
578
- if (!point) return;
579
- index = point.next;
580
-
581
- squote = Lexer.SQUOTE(value, index);
582
- if (!squote) return;
583
- index = squote;
584
-
585
- return Lexer.tokenize(value, start, index, "Edm.GeographyCollection", Lexer.TokenType.Literal);
586
- }
587
- export function geographyLineString(value: Utils.SourceArray, index: number): Lexer.Token {
588
- return PrimitiveLiteral.geoLiteralFactory(value, index, "Edm.GeographyLineString", Lexer.geographyPrefix, PrimitiveLiteral.fullLineStringLiteral);
589
- }
590
- export function geographyMultiLineString(value: Utils.SourceArray, index: number): Lexer.Token {
591
- return PrimitiveLiteral.geoLiteralFactory(value, index, "Edm.GeographyMultiLineString", Lexer.geographyPrefix, PrimitiveLiteral.fullMultiLineStringLiteral);
592
- }
593
- export function geographyMultiPoint(value: Utils.SourceArray, index: number): Lexer.Token {
594
- return PrimitiveLiteral.geoLiteralFactory(value, index, "Edm.GeographyMultiPoint", Lexer.geographyPrefix, PrimitiveLiteral.fullMultiPointLiteral);
595
- }
596
- export function geographyMultiPolygon(value: Utils.SourceArray, index: number): Lexer.Token {
597
- return PrimitiveLiteral.geoLiteralFactory(value, index, "Edm.GeographyMultiPolygon", Lexer.geographyPrefix, PrimitiveLiteral.fullMultiPolygonLiteral);
598
- }
599
- export function geographyPoint(value: Utils.SourceArray, index: number): Lexer.Token {
600
- return PrimitiveLiteral.geoLiteralFactory(value, index, "Edm.GeographyPoint", Lexer.geographyPrefix, PrimitiveLiteral.fullPointLiteral);
601
- }
602
- export function geographyPolygon(value: Utils.SourceArray, index: number): Lexer.Token {
603
- return PrimitiveLiteral.geoLiteralFactory(value, index, "Edm.GeographyPolygon", Lexer.geographyPrefix, PrimitiveLiteral.fullPolygonLiteral);
604
- }
605
- export function geometryCollection(value: Utils.SourceArray, index: number): Lexer.Token {
606
- return PrimitiveLiteral.geoLiteralFactory(value, index, "Edm.GeometryCollection", Lexer.geometryPrefix, PrimitiveLiteral.fullCollectionLiteral);
607
- }
608
- export function geometryLineString(value: Utils.SourceArray, index: number): Lexer.Token {
609
- return PrimitiveLiteral.geoLiteralFactory(value, index, "Edm.GeometryLineString", Lexer.geometryPrefix, PrimitiveLiteral.fullLineStringLiteral);
610
- }
611
- export function geometryMultiLineString(value: Utils.SourceArray, index: number): Lexer.Token {
612
- return PrimitiveLiteral.geoLiteralFactory(value, index, "Edm.GeometryMultiLineString", Lexer.geometryPrefix, PrimitiveLiteral.fullMultiLineStringLiteral);
613
- }
614
- export function geometryMultiPoint(value: Utils.SourceArray, index: number): Lexer.Token {
615
- return PrimitiveLiteral.geoLiteralFactory(value, index, "Edm.GeometryMultiPoint", Lexer.geometryPrefix, PrimitiveLiteral.fullMultiPointLiteral);
616
- }
617
- export function geometryMultiPolygon(value: Utils.SourceArray, index: number): Lexer.Token {
618
- return PrimitiveLiteral.geoLiteralFactory(value, index, "Edm.GeometryMultiPolygon", Lexer.geometryPrefix, PrimitiveLiteral.fullMultiPolygonLiteral);
619
- }
620
- export function geometryPoint(value: Utils.SourceArray, index: number): Lexer.Token {
621
- return PrimitiveLiteral.geoLiteralFactory(value, index, "Edm.GeometryPoint", Lexer.geometryPrefix, PrimitiveLiteral.fullPointLiteral);
622
- }
623
- export function geometryPolygon(value: Utils.SourceArray, index: number): Lexer.Token {
624
- return PrimitiveLiteral.geoLiteralFactory(value, index, "Edm.GeometryPolygon", Lexer.geometryPrefix, PrimitiveLiteral.fullPolygonLiteral);
625
- }
626
- export function geoLiteralFactory(value: Utils.SourceArray, index: number, type: string, prefix: Function, literal: Function): Lexer.Token {
627
- let prefixNext = prefix(value, index);
628
- if (prefixNext === index) return;
629
- let start = index;
630
- index = prefixNext;
631
-
632
- let squote = Lexer.SQUOTE(value, index);
633
- if (!squote) return;
634
- index = squote;
635
-
636
- let data = literal(value, index);
637
- if (!data) return;
638
- index = data.next;
639
-
640
- squote = Lexer.SQUOTE(value, index);
641
- if (!squote) return;
642
- index = squote;
643
-
644
- return Lexer.tokenize(value, start, index, type, Lexer.TokenType.Literal);
645
- }
646
-
647
- export function primitiveLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
648
- return PrimitiveLiteral.nullValue(value, index) ||
649
- PrimitiveLiteral.booleanValue(value, index) ||
650
- PrimitiveLiteral.guidValue(value, index) ||
651
- PrimitiveLiteral.dateValue(value, index) ||
652
- PrimitiveLiteral.dateTimeOffsetValue(value, index) ||
653
- PrimitiveLiteral.timeOfDayValue(value, index) ||
654
- PrimitiveLiteral.decimalValue(value, index) ||
655
- PrimitiveLiteral.doubleValue(value, index) ||
656
- PrimitiveLiteral.singleValue(value, index) ||
657
- PrimitiveLiteral.sbyteValue(value, index) ||
658
- PrimitiveLiteral.byteValue(value, index) ||
659
- PrimitiveLiteral.int16Value(value, index) ||
660
- PrimitiveLiteral.int32Value(value, index) ||
661
- PrimitiveLiteral.int64Value(value, index) ||
662
- PrimitiveLiteral.arrayValue(value, index) ||
663
- PrimitiveLiteral.stringValue(value, index) ||
664
- PrimitiveLiteral.durationValue(value, index) ||
665
- PrimitiveLiteral.binaryValue(value, index) ||
666
- NameOrIdentifier.enumeration(value, index) ||
667
- PrimitiveLiteral.geographyCollection(value, index) ||
668
- PrimitiveLiteral.geographyLineString(value, index) ||
669
- PrimitiveLiteral.geographyMultiLineString(value, index) ||
670
- PrimitiveLiteral.geographyMultiPoint(value, index) ||
671
- PrimitiveLiteral.geographyMultiPolygon(value, index) ||
672
- PrimitiveLiteral.geographyPoint(value, index) ||
673
- PrimitiveLiteral.geographyPolygon(value, index) ||
674
- PrimitiveLiteral.geometryCollection(value, index) ||
675
- PrimitiveLiteral.geometryLineString(value, index) ||
676
- PrimitiveLiteral.geometryMultiLineString(value, index) ||
677
- PrimitiveLiteral.geometryMultiPoint(value, index) ||
678
- PrimitiveLiteral.geometryMultiPolygon(value, index) ||
679
- PrimitiveLiteral.geometryPoint(value, index) ||
680
- PrimitiveLiteral.geometryPolygon(value, index);
681
- }
682
- }
683
-
684
- export default PrimitiveLiteral;
1
+ import Utils from "./utils";
2
+ import Lexer from "./lexer";
3
+ import NameOrIdentifier from "./nameOrIdentifier";
4
+
5
+ export namespace PrimitiveLiteral {
6
+ export function nullValue(value: Utils.SourceArray, index: number): Lexer.Token {
7
+ if (Utils.equals(value, index, "null")) return Lexer.tokenize(value, index, index + 4, "null", Lexer.TokenType.Literal);
8
+ }
9
+ export function booleanValue(value: Utils.SourceArray, index: number): Lexer.Token {
10
+ if (Utils.equals(value, index, "true")) return Lexer.tokenize(value, index, index + 4, "Edm.Boolean", Lexer.TokenType.Literal);
11
+ if (Utils.equals(value, index, "false")) return Lexer.tokenize(value, index, index + 5, "Edm.Boolean", Lexer.TokenType.Literal);
12
+ }
13
+ export function guidValue(value, index): Lexer.Token {
14
+ if (Utils.required(value, index, Lexer.HEXDIG, 8, 8) &&
15
+ value[index + 8] === 0x2d &&
16
+ Utils.required(value, index + 9, Lexer.HEXDIG, 4, 4) &&
17
+ value[index + 13] === 0x2d &&
18
+ Utils.required(value, index + 14, Lexer.HEXDIG, 4, 4) &&
19
+ value[index + 18] === 0x2d &&
20
+ Utils.required(value, index + 19, Lexer.HEXDIG, 4, 4) &&
21
+ value[index + 23] === 0x2d &&
22
+ Utils.required(value, index + 24, Lexer.HEXDIG, 12)) return Lexer.tokenize(value, index, index + 36, "Edm.Guid", Lexer.TokenType.Literal);
23
+ }
24
+ export function sbyteValue(value: Utils.SourceArray, index: number): Lexer.Token {
25
+ let start = index;
26
+ let sign = Lexer.SIGN(value, index);
27
+ if (sign) index = sign;
28
+
29
+ let next = Utils.required(value, index, Lexer.DIGIT, 1, 3);
30
+ if (next) {
31
+ if (Lexer.DIGIT(value[next])) return;
32
+ let val = parseInt(Utils.stringify(value, start, next), 10);
33
+ if (val >= -128 && val <= 127) return Lexer.tokenize(value, start, next, "Edm.SByte", Lexer.TokenType.Literal);
34
+ }
35
+ }
36
+ export function byteValue(value: Utils.SourceArray, index: number): Lexer.Token {
37
+ let next = Utils.required(value, index, Lexer.DIGIT, 1, 3);
38
+ if (next) {
39
+ if (Lexer.DIGIT(value[next])) return;
40
+ let val = parseInt(Utils.stringify(value, index, next), 10);
41
+ if (val >= 0 && val <= 255) return Lexer.tokenize(value, index, next, "Edm.Byte", Lexer.TokenType.Literal);
42
+ }
43
+ }
44
+ export function int16Value(value: Utils.SourceArray, index: number): Lexer.Token {
45
+ let start = index;
46
+ let sign = Lexer.SIGN(value, index);
47
+ if (sign) index = sign;
48
+
49
+ let next = Utils.required(value, index, Lexer.DIGIT, 1, 5);
50
+ if (next) {
51
+ if (Lexer.DIGIT(value[next])) return;
52
+ let val = parseInt(Utils.stringify(value, start, next), 10);
53
+ if (val >= -32768 && val <= 32767) return Lexer.tokenize(value, start, next, "Edm.Int16", Lexer.TokenType.Literal);
54
+ }
55
+ }
56
+ export function int32Value(value: Utils.SourceArray, index: number): Lexer.Token {
57
+ let start = index;
58
+ let sign = Lexer.SIGN(value, index);
59
+ if (sign) index = sign;
60
+
61
+ let next = Utils.required(value, index, Lexer.DIGIT, 1, 10);
62
+ if (next) {
63
+ if (Lexer.DIGIT(value[next])) return;
64
+ let val = parseInt(Utils.stringify(value, start, next), 10);
65
+ if (val >= -2147483648 && val <= 2147483647) return Lexer.tokenize(value, start, next, "Edm.Int32", Lexer.TokenType.Literal);
66
+ }
67
+ }
68
+ export function int64Value(value: Utils.SourceArray, index: number): Lexer.Token {
69
+ let start = index;
70
+ let sign = Lexer.SIGN(value, index);
71
+ if (sign) index = sign;
72
+
73
+ let next = Utils.required(value, index, Lexer.DIGIT, 1, 19);
74
+ if (next) {
75
+ if (Lexer.DIGIT(value[next])) return;
76
+ let val = Utils.stringify(value, index, next);
77
+ if (val >= "0" && val <= (value[start] === 0x2d ? "9223372036854775808" : "9223372036854775807")) return Lexer.tokenize(value, start, next, "Edm.Int64", Lexer.TokenType.Literal);
78
+ }
79
+ }
80
+ export function decimalValue(value: Utils.SourceArray, index: number): Lexer.Token {
81
+ let start = index;
82
+ let sign = Lexer.SIGN(value, index);
83
+ if (sign) index = sign;
84
+
85
+ let intNext = Utils.required(value, index, Lexer.DIGIT, 1);
86
+ if (!intNext) return;
87
+
88
+ let end = intNext;
89
+ if (value[intNext] === 0x2e) {
90
+ end = Utils.required(value, intNext + 1, Lexer.DIGIT, 1);
91
+ if (!end || end === intNext + 1) return;
92
+ } else return;
93
+
94
+ // TODO: detect only decimal value, no double/single detection here
95
+ if (value[end] === 0x65) return;
96
+
97
+ return Lexer.tokenize(value, start, end, "Edm.Decimal", Lexer.TokenType.Literal);
98
+ }
99
+ export function doubleValue(value: Utils.SourceArray, index: number): Lexer.Token {
100
+ let start = index;
101
+ let end = index;
102
+ let nanInfLen = Lexer.nanInfinity(value, index);
103
+ if (nanInfLen) {
104
+ end += nanInfLen;
105
+ } else {
106
+ // TODO: use decimalValue function
107
+ // var token = decimalValue(value, index);
108
+ let sign = Lexer.SIGN(value, index);
109
+ if (sign) index = sign;
110
+
111
+ let intNext = Utils.required(value, index, Lexer.DIGIT, 1);
112
+ if (!intNext) return;
113
+
114
+ let decimalNext = intNext;
115
+ if (value[intNext] === 0x2e) {
116
+ decimalNext = Utils.required(value, intNext + 1, Lexer.DIGIT, 1);
117
+ if (decimalNext === intNext + 1) return;
118
+ } else return;
119
+
120
+ if (value[decimalNext] === 0x65) {
121
+ let next = decimalNext + 1;
122
+ let sign = Lexer.SIGN(value, next);
123
+ if (sign) next = sign;
124
+
125
+ let digitNext = Utils.required(value, next, Lexer.DIGIT, 1);
126
+ if (digitNext) {
127
+ end = digitNext;
128
+ }
129
+ } else end = decimalNext;
130
+ }
131
+
132
+ return Lexer.tokenize(value, start, end, "Edm.Double", Lexer.TokenType.Literal);
133
+ }
134
+ export function singleValue(value: Utils.SourceArray, index: number): Lexer.Token {
135
+ let token = PrimitiveLiteral.doubleValue(value, index);
136
+ if (token) {
137
+ token.value = "Edm.Single";
138
+ }
139
+ return token;
140
+ }
141
+ export function stringValue(value: Utils.SourceArray, index: number): Lexer.Token {
142
+ let start = index;
143
+ let squote = Lexer.SQUOTE(value, start);
144
+ if (squote) {
145
+ index = squote;
146
+ while (index < value.length) {
147
+ squote = Lexer.SQUOTE(value, index);
148
+ if (squote) {
149
+ index = squote;
150
+ squote = Lexer.SQUOTE(value, index);
151
+ if (!squote) {
152
+ let close = Lexer.CLOSE(value, index);
153
+ let comma = Lexer.COMMA(value, index);
154
+ let amp = value[index] === 0x26;
155
+ if (Lexer.pcharNoSQUOTE(value, index) > index && !amp && !close && !comma && Lexer.RWS(value, index) === index) return;
156
+ break;
157
+ } else {
158
+ index = squote;
159
+ }
160
+ } else {
161
+ let nextIndex = Math.max(Lexer.RWS(value, index), Lexer.pcharNoSQUOTE(value, index));
162
+ if (nextIndex === index) return;
163
+ index = nextIndex;
164
+ }
165
+ }
166
+
167
+ squote = Lexer.SQUOTE(value, index - 1) || Lexer.SQUOTE(value, index - 3);
168
+ if (!squote) return;
169
+ index = squote;
170
+
171
+ return Lexer.tokenize(value, start, index, "Edm.String", Lexer.TokenType.Literal);
172
+ }
173
+ }
174
+
175
+
176
+ export function arrayValue(value: Utils.SourceArray, index: number): Lexer.Token {
177
+ if (!Utils.equals(value, index, "(") || !(Utils.equals(value, index-3, "in") || Utils.equals(value, index-3, "notin"))) return;
178
+ let start = index;
179
+ let squote = Lexer.OPEN(value, start);
180
+ if (squote) {
181
+ index = squote;
182
+ while (index < value.length) {
183
+ squote = Lexer.CLOSE(value, index);
184
+ if (squote) {
185
+ index = squote;
186
+ squote = Lexer.OPEN(value, index);
187
+ if (!squote) {
188
+ let close = Lexer.CLOSE(value, index);
189
+ let comma = Lexer.COMMA(value, index);
190
+ let amp = value[index] === 0x26;
191
+ if (Lexer.pcharNoSQUOTE(value, index) > index && !amp && !close && !comma && Lexer.RWS(value, index) === index) return;
192
+ break;
193
+ } else {
194
+ index = squote;
195
+ }
196
+ } else {
197
+ let nextIndex = index + 1;
198
+ if (nextIndex === index) return;
199
+ index = nextIndex;
200
+ }
201
+ }
202
+ // console.log(`--->index`, index)
203
+ // squote = Lexer.SQUOTE(value, index - 1) || Lexer.SQUOTE(value, index - 3);
204
+ // console.log(`--->squote`, squote)
205
+ // if (!squote) return;
206
+ // index = squote;
207
+ return Lexer.tokenize(value, start, index, "Edm.Array", Lexer.TokenType.Literal);
208
+ }
209
+ }
210
+
211
+ export function durationValue(value: Utils.SourceArray, index: number): Lexer.Token {
212
+ if (!Utils.equals(value, index, "duration")) return;
213
+ let start = index;
214
+ index += 8;
215
+
216
+ let squote = Lexer.SQUOTE(value, index);
217
+ if (!squote) return;
218
+ index = squote;
219
+
220
+ let sign = Lexer.SIGN(value, index);
221
+ if (sign) index = sign;
222
+
223
+ if (value[index] !== 0x50) return;
224
+ index++;
225
+ let dayNext = Utils.required(value, index, Lexer.DIGIT, 1);
226
+ if (dayNext === index && value[index + 1] !== 0x54) return;
227
+ index = dayNext;
228
+ if (value[index] === 0x44) index++;
229
+ let end = index;
230
+ if (value[index] === 0x54) {
231
+ index++;
232
+ const parseTimeFn = function () {
233
+ let squote = Lexer.SQUOTE(value, index);
234
+ if (squote) return index;
235
+ let digitNext = Utils.required(value, index, Lexer.DIGIT, 1);
236
+ if (digitNext === index) return;
237
+ index = digitNext;
238
+ if (value[index] === 0x53) {
239
+ end = index + 1;
240
+ return end;
241
+ } else if (value[index] === 0x2e) {
242
+ index++;
243
+ let fractionalSecondsNext = Utils.required(value, index, Lexer.DIGIT, 1);
244
+ if (fractionalSecondsNext === index || value[fractionalSecondsNext] !== 0x53) return;
245
+ end = fractionalSecondsNext + 1;
246
+ return end;
247
+ } else if (value[index] === 0x48) {
248
+ index++;
249
+ end = index;
250
+ return parseTimeFn();
251
+ } else if (value[index] === 0x4d) {
252
+ index++;
253
+ end = index;
254
+ return parseTimeFn();
255
+ }
256
+ };
257
+ let next = parseTimeFn();
258
+ if (!next) return;
259
+ }
260
+
261
+ squote = Lexer.SQUOTE(value, end);
262
+ if (!squote) return;
263
+ end = squote;
264
+
265
+ return Lexer.tokenize(value, start, end, "Edm.Duration", Lexer.TokenType.Literal);
266
+ }
267
+ export function binaryValue(value: Utils.SourceArray, index: number): Lexer.Token {
268
+ let start = index;
269
+ if (!Utils.equals(value, index, "binary")) return;
270
+ index += 6;
271
+
272
+ let squote = Lexer.SQUOTE(value, index);
273
+ if (!squote) return;
274
+ index = squote;
275
+
276
+ while (index < value.length && !(squote = Lexer.SQUOTE(value, index))) {
277
+ let end = Math.max(Lexer.base64b16(value, index), Lexer.base64b8(value, index));
278
+ if (end > index) index = end;
279
+ else if (Lexer.base64char(value[index]) &&
280
+ Lexer.base64char(value[index + 1]) &&
281
+ Lexer.base64char(value[index + 2]) &&
282
+ Lexer.base64char(value[index + 3])) index += 4;
283
+ else index++;
284
+ }
285
+ index = squote;
286
+
287
+ return Lexer.tokenize(value, start, index, "Edm.Binary", Lexer.TokenType.Literal);
288
+ }
289
+ export function dateValue(value: Utils.SourceArray, index: number): Lexer.Token {
290
+ let yearNext = Lexer.year(value, index);
291
+ if (yearNext === index || value[yearNext] !== 0x2d) return;
292
+ let monthNext = Lexer.month(value, yearNext + 1);
293
+ if ((monthNext === yearNext + 1) || value[monthNext] !== 0x2d) return;
294
+ let dayNext = Lexer.day(value, monthNext + 1);
295
+ // TODO: join dateValue and dateTimeOffsetValue for optimalization
296
+ if (dayNext === monthNext + 1 || value[dayNext] === 0x54) return;
297
+ return Lexer.tokenize(value, index, dayNext, "Edm.Date", Lexer.TokenType.Literal);
298
+ }
299
+ export function dateTimeOffsetValue(value: Utils.SourceArray, index: number): Lexer.Token {
300
+ let yearNext = Lexer.year(value, index);
301
+ if (yearNext === index || value[yearNext] !== 0x2d) return;
302
+ let monthNext = Lexer.month(value, yearNext + 1);
303
+ if ((monthNext === yearNext + 1) || value[monthNext] !== 0x2d) return;
304
+ let dayNext = Lexer.day(value, monthNext + 1);
305
+ if (dayNext === monthNext + 1 || value[dayNext] !== 0x54) return;
306
+ let hourNext = Lexer.hour(value, dayNext + 1);
307
+
308
+ let colon = Lexer.COLON(value, hourNext);
309
+ if (hourNext === colon || !colon) return;
310
+ let minuteNext = Lexer.minute(value, hourNext + 1);
311
+ if (minuteNext === hourNext + 1) return;
312
+
313
+ let end = minuteNext;
314
+ colon = Lexer.COLON(value, minuteNext);
315
+ if (colon) {
316
+ let secondNext = Lexer.second(value, colon);
317
+ if (secondNext === colon) return;
318
+ if (value[secondNext] === 0x2e) {
319
+ let fractionalSecondsNext = Lexer.fractionalSeconds(value, secondNext + 1);
320
+ if (fractionalSecondsNext === secondNext + 1) return;
321
+ end = fractionalSecondsNext;
322
+ } else end = secondNext;
323
+ }
324
+
325
+ let sign = Lexer.SIGN(value, end);
326
+ if (value[end] === 0x5a) {
327
+ end++;
328
+ } else if (sign) {
329
+ let zHourNext = Lexer.hour(value, sign);
330
+ let colon = Lexer.COLON(value, zHourNext);
331
+ if (zHourNext === sign || !colon) return;
332
+ let zMinuteNext = Lexer.minute(value, colon);
333
+ if (zMinuteNext === colon) return;
334
+ end = zMinuteNext;
335
+ } else return;
336
+
337
+ return Lexer.tokenize(value, index, end, "Edm.DateTimeOffset", Lexer.TokenType.Literal);
338
+ }
339
+ export function timeOfDayValue(value: Utils.SourceArray, index: number): Lexer.Token {
340
+ let hourNext = Lexer.hour(value, index);
341
+ let colon = Lexer.COLON(value, hourNext);
342
+ if (hourNext === index || !colon) return;
343
+ let minuteNext = Lexer.minute(value, colon);
344
+ if (minuteNext === colon) return;
345
+
346
+ let end = minuteNext;
347
+ colon = Lexer.COLON(value, minuteNext);
348
+ if (colon) {
349
+ let secondNext = Lexer.second(value, colon);
350
+ if (secondNext === colon) return;
351
+ if (value[secondNext] === 0x2e) {
352
+ let fractionalSecondsNext = Lexer.fractionalSeconds(value, secondNext + 1);
353
+ if (fractionalSecondsNext === secondNext + 1) return;
354
+ end = fractionalSecondsNext;
355
+ } else end = secondNext;
356
+ }
357
+
358
+ return Lexer.tokenize(value, index, end, "Edm.TimeOfDay", Lexer.TokenType.Literal);
359
+ }
360
+
361
+ // geography and geometry literals
362
+ export function positionLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
363
+ let longitude = PrimitiveLiteral.doubleValue(value, index);
364
+ if (!longitude) return;
365
+
366
+ let next = Lexer.RWS(value, longitude.next);
367
+ if (next === longitude.next) return;
368
+
369
+ let latitude = PrimitiveLiteral.doubleValue(value, next);
370
+ if (!latitude) return;
371
+
372
+ return Lexer.tokenize(value, index, latitude.next, { longitude, latitude }, Lexer.TokenType.Literal);
373
+ }
374
+ export function pointData(value: Utils.SourceArray, index: number): Lexer.Token {
375
+ let open = Lexer.OPEN(value, index);
376
+ if (!open) return;
377
+ let start = index;
378
+ index = open;
379
+
380
+ let position = PrimitiveLiteral.positionLiteral(value, index);
381
+ if (!position) return;
382
+ index = position.next;
383
+
384
+ let close = Lexer.CLOSE(value, index);
385
+ if (!close) return;
386
+ index = close;
387
+
388
+ return Lexer.tokenize(value, start, index, position, Lexer.TokenType.Literal);
389
+ }
390
+ export function lineStringData(value: Utils.SourceArray, index: number): Lexer.Token {
391
+ return PrimitiveLiteral.multiGeoLiteralFactory(value, index, "", PrimitiveLiteral.positionLiteral);
392
+ }
393
+ export function ringLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
394
+ return PrimitiveLiteral.multiGeoLiteralFactory(value, index, "", PrimitiveLiteral.positionLiteral);
395
+ // Within each ringLiteral, the first and last positionLiteral elements MUST be an exact syntactic match to each other.
396
+ // Within the polygonData, the ringLiterals MUST specify their points in appropriate winding order.
397
+ // In order of traversal, points to the left side of the ring are interpreted as being in the polygon.
398
+ }
399
+ export function polygonData(value: Utils.SourceArray, index: number): Lexer.Token {
400
+ return PrimitiveLiteral.multiGeoLiteralFactory(value, index, "", PrimitiveLiteral.ringLiteral);
401
+ }
402
+ export function sridLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
403
+ if (!Utils.equals(value, index, "SRID")) return;
404
+ let start = index;
405
+ index += 4;
406
+
407
+ let eq = Lexer.EQ(value, index);
408
+ if (!eq) return;
409
+ index++;
410
+
411
+ let digit = Utils.required(value, index, Lexer.DIGIT, 1, 5);
412
+ if (!digit) return;
413
+ index = digit;
414
+
415
+ let semi = Lexer.SEMI(value, index);
416
+ if (!semi) return;
417
+ index = semi;
418
+
419
+ return Lexer.tokenize(value, start, index, "SRID", Lexer.TokenType.Literal);
420
+ }
421
+ export function pointLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
422
+ if (!Utils.equals(value, index, "Point")) return;
423
+ let start = index;
424
+ index += 5;
425
+
426
+ let data = PrimitiveLiteral.pointData(value, index);
427
+ if (!data) return;
428
+
429
+ return Lexer.tokenize(value, start, data.next, data, Lexer.TokenType.Literal);
430
+ }
431
+ export function polygonLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
432
+ if (!Utils.equals(value, index, "Polygon")) return;
433
+ let start = index;
434
+ index += 7;
435
+
436
+ let data = PrimitiveLiteral.polygonData(value, index);
437
+ if (!data) return;
438
+
439
+ return Lexer.tokenize(value, start, data.next, data, Lexer.TokenType.Literal);
440
+ }
441
+ export function collectionLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
442
+ return PrimitiveLiteral.multiGeoLiteralFactory(value, index, "Collection", PrimitiveLiteral.geoLiteral);
443
+ }
444
+ export function lineStringLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
445
+ if (!Utils.equals(value, index, "LineString")) return;
446
+ let start = index;
447
+ index += 10;
448
+
449
+ let data = PrimitiveLiteral.lineStringData(value, index);
450
+ if (!data) return;
451
+ index = data.next;
452
+
453
+ return Lexer.tokenize(value, start, index, data, Lexer.TokenType.Literal);
454
+ }
455
+ export function multiLineStringLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
456
+ return PrimitiveLiteral.multiGeoLiteralOptionalFactory(value, index, "MultiLineString", PrimitiveLiteral.lineStringData);
457
+ }
458
+ export function multiPointLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
459
+ return PrimitiveLiteral.multiGeoLiteralOptionalFactory(value, index, "MultiPoint", PrimitiveLiteral.pointData);
460
+ }
461
+ export function multiPolygonLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
462
+ return PrimitiveLiteral.multiGeoLiteralOptionalFactory(value, index, "MultiPolygon", PrimitiveLiteral.polygonData);
463
+ }
464
+ export function multiGeoLiteralFactory(value: Utils.SourceArray, index: number, prefix: string, itemLiteral: Function): Lexer.Token {
465
+ if (!Utils.equals(value, index, prefix + "(")) return;
466
+ let start = index;
467
+ index += prefix.length + 1;
468
+
469
+ let items = [];
470
+ let geo = itemLiteral(value, index);
471
+ if (!geo) return;
472
+ index = geo.next;
473
+
474
+ while (geo) {
475
+ items.push(geo);
476
+
477
+ let close = Lexer.CLOSE(value, index);
478
+ if (close) {
479
+ index = close;
480
+ break;
481
+ }
482
+
483
+ let comma = Lexer.COMMA(value, index);
484
+ if (!comma) return;
485
+ index = comma;
486
+
487
+ geo = itemLiteral(value, index);
488
+ if (!geo) return;
489
+ index = geo.next;
490
+ }
491
+
492
+ return Lexer.tokenize(value, start, index, { items }, Lexer.TokenType.Literal);
493
+ }
494
+ export function multiGeoLiteralOptionalFactory(value: Utils.SourceArray, index: number, prefix: string, itemLiteral: Function): Lexer.Token {
495
+ if (!Utils.equals(value, index, prefix + "(")) return;
496
+ let start = index;
497
+ index += prefix.length + 1;
498
+
499
+ let items = [];
500
+ let close = Lexer.CLOSE(value, index);
501
+ if (!close) {
502
+ let geo = itemLiteral(value, index);
503
+ if (!geo) return;
504
+ index = geo.next;
505
+
506
+ while (geo) {
507
+ items.push(geo);
508
+
509
+ close = Lexer.CLOSE(value, index);
510
+ if (close) {
511
+ index = close;
512
+ break;
513
+ }
514
+
515
+ let comma = Lexer.COMMA(value, index);
516
+ if (!comma) return;
517
+ index = comma;
518
+
519
+ geo = itemLiteral(value, index);
520
+ if (!geo) return;
521
+ index = geo.next;
522
+ }
523
+ }else index++;
524
+
525
+ return Lexer.tokenize(value, start, index, { items }, Lexer.TokenType.Literal);
526
+ }
527
+ export function geoLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
528
+ return PrimitiveLiteral.collectionLiteral(value, index) ||
529
+ PrimitiveLiteral.lineStringLiteral(value, index) ||
530
+ PrimitiveLiteral.multiPointLiteral(value, index) ||
531
+ PrimitiveLiteral.multiLineStringLiteral(value, index) ||
532
+ PrimitiveLiteral.multiPolygonLiteral(value, index) ||
533
+ PrimitiveLiteral.pointLiteral(value, index) ||
534
+ PrimitiveLiteral.polygonLiteral(value, index);
535
+ }
536
+ export function fullPointLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
537
+ return PrimitiveLiteral.fullGeoLiteralFactory(value, index, PrimitiveLiteral.pointLiteral);
538
+ }
539
+ export function fullCollectionLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
540
+ return PrimitiveLiteral.fullGeoLiteralFactory(value, index, PrimitiveLiteral.collectionLiteral);
541
+ }
542
+ export function fullLineStringLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
543
+ return PrimitiveLiteral.fullGeoLiteralFactory(value, index, PrimitiveLiteral.lineStringLiteral);
544
+ }
545
+ export function fullMultiLineStringLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
546
+ return PrimitiveLiteral.fullGeoLiteralFactory(value, index, PrimitiveLiteral.multiLineStringLiteral);
547
+ }
548
+ export function fullMultiPointLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
549
+ return PrimitiveLiteral.fullGeoLiteralFactory(value, index, PrimitiveLiteral.multiPointLiteral);
550
+ }
551
+ export function fullMultiPolygonLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
552
+ return PrimitiveLiteral.fullGeoLiteralFactory(value, index, PrimitiveLiteral.multiPolygonLiteral);
553
+ }
554
+ export function fullPolygonLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
555
+ return PrimitiveLiteral.fullGeoLiteralFactory(value, index, PrimitiveLiteral.polygonLiteral);
556
+ }
557
+ export function fullGeoLiteralFactory(value: Utils.SourceArray, index: number, literal: Function): Lexer.Token {
558
+ let srid = PrimitiveLiteral.sridLiteral(value, index);
559
+ if (!srid) return;
560
+
561
+ let token = literal(value, srid.next);
562
+ if (!token) return;
563
+
564
+ return Lexer.tokenize(value, index, token.next, { srid, value: token }, Lexer.TokenType.Literal);
565
+ }
566
+
567
+ export function geographyCollection(value: Utils.SourceArray, index: number): Lexer.Token {
568
+ let prefix = Lexer.geographyPrefix(value, index);
569
+ if (prefix === index) return;
570
+ let start = index;
571
+ index = prefix;
572
+
573
+ let squote = Lexer.SQUOTE(value, index);
574
+ if (!squote) return;
575
+ index = squote;
576
+
577
+ let point = PrimitiveLiteral.fullCollectionLiteral(value, index);
578
+ if (!point) return;
579
+ index = point.next;
580
+
581
+ squote = Lexer.SQUOTE(value, index);
582
+ if (!squote) return;
583
+ index = squote;
584
+
585
+ return Lexer.tokenize(value, start, index, "Edm.GeographyCollection", Lexer.TokenType.Literal);
586
+ }
587
+ export function geographyLineString(value: Utils.SourceArray, index: number): Lexer.Token {
588
+ return PrimitiveLiteral.geoLiteralFactory(value, index, "Edm.GeographyLineString", Lexer.geographyPrefix, PrimitiveLiteral.fullLineStringLiteral);
589
+ }
590
+ export function geographyMultiLineString(value: Utils.SourceArray, index: number): Lexer.Token {
591
+ return PrimitiveLiteral.geoLiteralFactory(value, index, "Edm.GeographyMultiLineString", Lexer.geographyPrefix, PrimitiveLiteral.fullMultiLineStringLiteral);
592
+ }
593
+ export function geographyMultiPoint(value: Utils.SourceArray, index: number): Lexer.Token {
594
+ return PrimitiveLiteral.geoLiteralFactory(value, index, "Edm.GeographyMultiPoint", Lexer.geographyPrefix, PrimitiveLiteral.fullMultiPointLiteral);
595
+ }
596
+ export function geographyMultiPolygon(value: Utils.SourceArray, index: number): Lexer.Token {
597
+ return PrimitiveLiteral.geoLiteralFactory(value, index, "Edm.GeographyMultiPolygon", Lexer.geographyPrefix, PrimitiveLiteral.fullMultiPolygonLiteral);
598
+ }
599
+ export function geographyPoint(value: Utils.SourceArray, index: number): Lexer.Token {
600
+ return PrimitiveLiteral.geoLiteralFactory(value, index, "Edm.GeographyPoint", Lexer.geographyPrefix, PrimitiveLiteral.fullPointLiteral);
601
+ }
602
+ export function geographyPolygon(value: Utils.SourceArray, index: number): Lexer.Token {
603
+ return PrimitiveLiteral.geoLiteralFactory(value, index, "Edm.GeographyPolygon", Lexer.geographyPrefix, PrimitiveLiteral.fullPolygonLiteral);
604
+ }
605
+ export function geometryCollection(value: Utils.SourceArray, index: number): Lexer.Token {
606
+ return PrimitiveLiteral.geoLiteralFactory(value, index, "Edm.GeometryCollection", Lexer.geometryPrefix, PrimitiveLiteral.fullCollectionLiteral);
607
+ }
608
+ export function geometryLineString(value: Utils.SourceArray, index: number): Lexer.Token {
609
+ return PrimitiveLiteral.geoLiteralFactory(value, index, "Edm.GeometryLineString", Lexer.geometryPrefix, PrimitiveLiteral.fullLineStringLiteral);
610
+ }
611
+ export function geometryMultiLineString(value: Utils.SourceArray, index: number): Lexer.Token {
612
+ return PrimitiveLiteral.geoLiteralFactory(value, index, "Edm.GeometryMultiLineString", Lexer.geometryPrefix, PrimitiveLiteral.fullMultiLineStringLiteral);
613
+ }
614
+ export function geometryMultiPoint(value: Utils.SourceArray, index: number): Lexer.Token {
615
+ return PrimitiveLiteral.geoLiteralFactory(value, index, "Edm.GeometryMultiPoint", Lexer.geometryPrefix, PrimitiveLiteral.fullMultiPointLiteral);
616
+ }
617
+ export function geometryMultiPolygon(value: Utils.SourceArray, index: number): Lexer.Token {
618
+ return PrimitiveLiteral.geoLiteralFactory(value, index, "Edm.GeometryMultiPolygon", Lexer.geometryPrefix, PrimitiveLiteral.fullMultiPolygonLiteral);
619
+ }
620
+ export function geometryPoint(value: Utils.SourceArray, index: number): Lexer.Token {
621
+ return PrimitiveLiteral.geoLiteralFactory(value, index, "Edm.GeometryPoint", Lexer.geometryPrefix, PrimitiveLiteral.fullPointLiteral);
622
+ }
623
+ export function geometryPolygon(value: Utils.SourceArray, index: number): Lexer.Token {
624
+ return PrimitiveLiteral.geoLiteralFactory(value, index, "Edm.GeometryPolygon", Lexer.geometryPrefix, PrimitiveLiteral.fullPolygonLiteral);
625
+ }
626
+ export function geoLiteralFactory(value: Utils.SourceArray, index: number, type: string, prefix: Function, literal: Function): Lexer.Token {
627
+ let prefixNext = prefix(value, index);
628
+ if (prefixNext === index) return;
629
+ let start = index;
630
+ index = prefixNext;
631
+
632
+ let squote = Lexer.SQUOTE(value, index);
633
+ if (!squote) return;
634
+ index = squote;
635
+
636
+ let data = literal(value, index);
637
+ if (!data) return;
638
+ index = data.next;
639
+
640
+ squote = Lexer.SQUOTE(value, index);
641
+ if (!squote) return;
642
+ index = squote;
643
+
644
+ return Lexer.tokenize(value, start, index, type, Lexer.TokenType.Literal);
645
+ }
646
+
647
+ export function primitiveLiteral(value: Utils.SourceArray, index: number): Lexer.Token {
648
+ return PrimitiveLiteral.nullValue(value, index) ||
649
+ PrimitiveLiteral.booleanValue(value, index) ||
650
+ PrimitiveLiteral.guidValue(value, index) ||
651
+ PrimitiveLiteral.dateValue(value, index) ||
652
+ PrimitiveLiteral.dateTimeOffsetValue(value, index) ||
653
+ PrimitiveLiteral.timeOfDayValue(value, index) ||
654
+ PrimitiveLiteral.decimalValue(value, index) ||
655
+ PrimitiveLiteral.doubleValue(value, index) ||
656
+ PrimitiveLiteral.singleValue(value, index) ||
657
+ PrimitiveLiteral.sbyteValue(value, index) ||
658
+ PrimitiveLiteral.byteValue(value, index) ||
659
+ PrimitiveLiteral.int16Value(value, index) ||
660
+ PrimitiveLiteral.int32Value(value, index) ||
661
+ PrimitiveLiteral.int64Value(value, index) ||
662
+ PrimitiveLiteral.arrayValue(value, index) ||
663
+ PrimitiveLiteral.stringValue(value, index) ||
664
+ PrimitiveLiteral.durationValue(value, index) ||
665
+ PrimitiveLiteral.binaryValue(value, index) ||
666
+ NameOrIdentifier.enumeration(value, index) ||
667
+ PrimitiveLiteral.geographyCollection(value, index) ||
668
+ PrimitiveLiteral.geographyLineString(value, index) ||
669
+ PrimitiveLiteral.geographyMultiLineString(value, index) ||
670
+ PrimitiveLiteral.geographyMultiPoint(value, index) ||
671
+ PrimitiveLiteral.geographyMultiPolygon(value, index) ||
672
+ PrimitiveLiteral.geographyPoint(value, index) ||
673
+ PrimitiveLiteral.geographyPolygon(value, index) ||
674
+ PrimitiveLiteral.geometryCollection(value, index) ||
675
+ PrimitiveLiteral.geometryLineString(value, index) ||
676
+ PrimitiveLiteral.geometryMultiLineString(value, index) ||
677
+ PrimitiveLiteral.geometryMultiPoint(value, index) ||
678
+ PrimitiveLiteral.geometryMultiPolygon(value, index) ||
679
+ PrimitiveLiteral.geometryPoint(value, index) ||
680
+ PrimitiveLiteral.geometryPolygon(value, index);
681
+ }
682
+ }
683
+
684
+ export default PrimitiveLiteral;