@ja-platform/parser-expressions 0.0.0-dev-20261019214152
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/README.md +112 -0
- package/dist/@types/CombinedParser.d.ts +11 -0
- package/dist/@types/ExpressionParser.d.ts +12 -0
- package/dist/@types/code-parsers/CodeParser.d.ts +25 -0
- package/dist/@types/code-parsers/JavaScriptParser.d.ts +18 -0
- package/dist/@types/definitions/ValidationContext.d.ts +8 -0
- package/dist/@types/expressions/AbstractExpression.d.ts +42 -0
- package/dist/@types/expressions/EvaluatedExpression.d.ts +34 -0
- package/dist/@types/expressions/constant/ConstantExpression.d.ts +28 -0
- package/dist/@types/expressions/function/FunctionExpression.d.ts +37 -0
- package/dist/@types/expressions/index.d.ts +8 -0
- package/dist/@types/expressions/shorthand/FormatShorthandExpression.d.ts +31 -0
- package/dist/@types/expressions/shorthand/ShorthandExpression.d.ts +42 -0
- package/dist/@types/expressions/text/AbstractFormatExpression.d.ts +43 -0
- package/dist/@types/expressions/text/FormatStringExpression.d.ts +18 -0
- package/dist/@types/index.d.ts +9 -0
- package/dist/@types/tokens/AbstractToken.d.ts +12 -0
- package/dist/@types/tokens/code/CodeToken.d.ts +142 -0
- package/dist/@types/tokens/code/IdentifierToken.d.ts +12 -0
- package/dist/@types/tokens/code/JSToken.d.ts +31 -0
- package/dist/@types/tokens/code/PrefixToken.d.ts +9 -0
- package/dist/@types/tokens/index.d.ts +8 -0
- package/dist/@types/tokens/text/PlaceholderToken.d.ts +12 -0
- package/dist/@types/tokens/text/TextToken.d.ts +12 -0
- package/dist/@types/utils/parserUtils.d.ts +7 -0
- package/dist/@types/utils/tokenUtils.d.ts +11 -0
- package/dist/@types/utils/valueFormatting.d.ts +9 -0
- package/dist/CombinedParser.js +24 -0
- package/dist/CombinedParser.js.map +1 -0
- package/dist/ExpressionParser.js +20 -0
- package/dist/ExpressionParser.js.map +1 -0
- package/dist/code-parsers/CodeParser.js +45 -0
- package/dist/code-parsers/CodeParser.js.map +1 -0
- package/dist/code-parsers/JavaScriptParser.js +56 -0
- package/dist/code-parsers/JavaScriptParser.js.map +1 -0
- package/dist/definitions/ValidationContext.js +3 -0
- package/dist/definitions/ValidationContext.js.map +1 -0
- package/dist/expressions/AbstractExpression.js +47 -0
- package/dist/expressions/AbstractExpression.js.map +1 -0
- package/dist/expressions/EvaluatedExpression.js +102 -0
- package/dist/expressions/EvaluatedExpression.js.map +1 -0
- package/dist/expressions/constant/ConstantExpression.js +53 -0
- package/dist/expressions/constant/ConstantExpression.js.map +1 -0
- package/dist/expressions/function/FunctionExpression.js +79 -0
- package/dist/expressions/function/FunctionExpression.js.map +1 -0
- package/dist/expressions/index.js +25 -0
- package/dist/expressions/index.js.map +1 -0
- package/dist/expressions/shorthand/FormatShorthandExpression.js +60 -0
- package/dist/expressions/shorthand/FormatShorthandExpression.js.map +1 -0
- package/dist/expressions/shorthand/ShorthandExpression.js +90 -0
- package/dist/expressions/shorthand/ShorthandExpression.js.map +1 -0
- package/dist/expressions/text/AbstractFormatExpression.js +178 -0
- package/dist/expressions/text/AbstractFormatExpression.js.map +1 -0
- package/dist/expressions/text/FormatStringExpression.js +44 -0
- package/dist/expressions/text/FormatStringExpression.js.map +1 -0
- package/dist/index.js +29 -0
- package/dist/index.js.map +1 -0
- package/dist/tokens/AbstractToken.js +22 -0
- package/dist/tokens/AbstractToken.js.map +1 -0
- package/dist/tokens/code/CodeToken.js +33 -0
- package/dist/tokens/code/CodeToken.js.map +1 -0
- package/dist/tokens/code/IdentifierToken.js +28 -0
- package/dist/tokens/code/IdentifierToken.js.map +1 -0
- package/dist/tokens/code/JSToken.js +251 -0
- package/dist/tokens/code/JSToken.js.map +1 -0
- package/dist/tokens/code/PrefixToken.js +24 -0
- package/dist/tokens/code/PrefixToken.js.map +1 -0
- package/dist/tokens/index.js +31 -0
- package/dist/tokens/index.js.map +1 -0
- package/dist/tokens/text/PlaceholderToken.js +25 -0
- package/dist/tokens/text/PlaceholderToken.js.map +1 -0
- package/dist/tokens/text/TextToken.js +28 -0
- package/dist/tokens/text/TextToken.js.map +1 -0
- package/dist/tsconfig.tsbuildinfo +1 -0
- package/dist/utils/parserUtils.js +19 -0
- package/dist/utils/parserUtils.js.map +1 -0
- package/dist/utils/tokenUtils.js +43 -0
- package/dist/utils/tokenUtils.js.map +1 -0
- package/dist/utils/valueFormatting.js +34 -0
- package/dist/utils/valueFormatting.js.map +1 -0
- package/package.json +40 -0
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"FunctionExpression.js","sourceRoot":"","sources":["../../../src/expressions/function/FunctionExpression.ts"],"names":[],"mappings":";;;AAAA,6DAA0D;AAE1D,gEAAwF;AACxF,yCAA2D;AAE3D;;;;;;;;;;;GAWG;AACH,wBAAgC,SAAQ,yCAAmB;IAGzD,MAAM,CAAC,KAAK,CAAC,MAAwB,EAAE,KAAK,GAAG,CAAC;QAC9C,OAAO,IAAI,wBAAwB,EAAE,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC7D,CAAC;IAED,YAAY,OAAkC;QAC5C,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC,IAAI,CAAC;IACtC,CAAC;IAED,OAAO;QACL,OAAO,KAAK,CAAC,OAAO,EAAE,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,YAAY,kBAAS,IAAI,KAAK,CAAC,gBAAgB,EAAE,CAAC,CAAC;IAChH,CAAC;IAED,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC;IAClC,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,CAAC;IACvC,CAAC;IAED,QAAQ,CAAC,IAAY;QACnB,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;IACtD,CAAC;IAED;;;OAGG;IACH,aAAa,CAAC,IAAmC;QAC/C,MAAM,eAAe,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE;YAC5C,IAAI,MAAc,CAAC;YACnB,IAAI,QAAQ,YAAY,yCAAmB,EAAE,CAAC;gBAC5C,MAAM,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;YAC3B,CAAC;iBAAM,CAAC;gBACN,MAAM,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC;YAC1B,CAAC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,CAAC,mBAAmB,CAAC,eAAe,CAAC,CAAC;IACnD,CAAC;IAED,mBAAmB,CAAC,IAAuB;QACzC,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC;IAC3D,CAAC;CACF;;AA/CQ,uBAAI,GAAG,qBAAqB,CAAC;AAiDtC;;GAEG;AACH,8BAAsC,SAAQ,mCAAoC;IAChF,QAAQ,CAAC,MAAwB,EAAE,KAAK,GAAG,CAAC;QAC1C,MAAM,SAAS,GAAG,IAAI,+CAAyB,EAAE,CAAC,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QAC1E,IAAI,UAAU,GAA8B,IAAI,CAAC;QACjD,IAAI,SAAS,EAAE,CAAC;YACd,MAAM,SAAS,GAAG,IAAI,kBAAkB,iCAAM,SAAS,CAAC,OAAO,KAAE,MAAM,EAAE,SAAS,CAAC,MAAM,IAAG,CAAC;YAC7F,IAAI,SAAS,CAAC,OAAO,EAAE,EAAE,CAAC;gBACxB,UAAU,GAAG,SAAS,CAAC;YACzB,CAAC;QACH,CAAC;QACD,OAAO,UAAU,CAAC;IACpB,CAAC;CACF","sourcesContent":["import { ExpressionParser } from '../../ExpressionParser';\nimport { AbstractExpression, AbstractExpressionOptions } from '../AbstractExpression';\nimport { EvaluatedExpression, EvaluatedExpressionParser } from '../EvaluatedExpression';\nimport { CodeToken, ExpressionSource } from '../../tokens';\n\n/**\n * An explicitly evaluated function call, such as `$:save(true)` or `$:worker.save(user.name)`.\n * The root code expression must be a call; this type exposes its target and arguments for editing.\n *\n * @example\n * ```ts\n * const expression = FunctionExpression.parse('$:save(true)');\n * expression.functionName(); // 'save'\n * expression.withName('persist').raw(); // '$:persist(true)'\n * expression.withArgumentSources(['false']).raw(); // '$:save(false)'\n * ```\n */\nexport class FunctionExpression extends EvaluatedExpression {\n static TYPE = 'function-expression';\n\n static parse(source: ExpressionSource, start = 0): FunctionExpression {\n return new FunctionExpressionParser().parse(source, start);\n }\n\n constructor(options: AbstractExpressionOptions) {\n super(options);\n this.type = FunctionExpression.TYPE;\n }\n\n isValid(): boolean {\n return super.isValid() && this.tokens.some((token) => token instanceof CodeToken && token.isCallExpression());\n }\n\n get arguments(): CodeToken['arguments'] {\n return this.codeToken.arguments;\n }\n\n functionName(): string {\n return this.codeToken.functionName();\n }\n\n withName(name: string): this {\n return this.withCode(this.codeToken.withName(name));\n }\n\n /**\n * Replace arguments using expression source in the code token's language.\n * Constant text is inserted verbatim; callers supply any required quoting or escaping.\n */\n withArguments(args: readonly AbstractExpression[]): this {\n const argumentsSource = args.map((argument) => {\n let source: string;\n if (argument instanceof EvaluatedExpression) {\n source = argument.code();\n } else {\n source = argument.raw();\n }\n return source;\n });\n return this.withArgumentSources(argumentsSource);\n }\n\n withArgumentSources(args: readonly string[]): this {\n return this.withCode(this.codeToken.withArguments(args));\n }\n}\n\n/**\n * Recognize the syntax owned by FunctionExpression.\n */\nexport class FunctionExpressionParser extends ExpressionParser<FunctionExpression> {\n tryParse(source: ExpressionSource, start = 0): FunctionExpression | null {\n const evaluated = new EvaluatedExpressionParser().tryParse(source, start);\n let expression: FunctionExpression | null = null;\n if (evaluated) {\n const candidate = new FunctionExpression({ ...evaluated.options, tokens: evaluated.tokens });\n if (candidate.isValid()) {\n expression = candidate;\n }\n }\n return expression;\n }\n}\n"]}
|
|
@@ -0,0 +1,25 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
|
3
|
+
if (k2 === undefined) k2 = k;
|
|
4
|
+
var desc = Object.getOwnPropertyDescriptor(m, k);
|
|
5
|
+
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
|
6
|
+
desc = { enumerable: true, get: function() { return m[k]; } };
|
|
7
|
+
}
|
|
8
|
+
Object.defineProperty(o, k2, desc);
|
|
9
|
+
}) : (function(o, m, k, k2) {
|
|
10
|
+
if (k2 === undefined) k2 = k;
|
|
11
|
+
o[k2] = m[k];
|
|
12
|
+
}));
|
|
13
|
+
var __exportStar = (this && this.__exportStar) || function(m, exports) {
|
|
14
|
+
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
|
|
15
|
+
};
|
|
16
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
17
|
+
__exportStar(require("./AbstractExpression"), exports);
|
|
18
|
+
__exportStar(require("./EvaluatedExpression"), exports);
|
|
19
|
+
__exportStar(require("./shorthand/ShorthandExpression"), exports);
|
|
20
|
+
__exportStar(require("./shorthand/FormatShorthandExpression"), exports);
|
|
21
|
+
__exportStar(require("./constant/ConstantExpression"), exports);
|
|
22
|
+
__exportStar(require("./function/FunctionExpression"), exports);
|
|
23
|
+
__exportStar(require("./text/FormatStringExpression"), exports);
|
|
24
|
+
__exportStar(require("./text/AbstractFormatExpression"), exports);
|
|
25
|
+
//# sourceMappingURL=index.js.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/expressions/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,uDAAqC;AAErC,wDAAsC;AAEtC,kEAAgD;AAChD,wEAAsD;AAEtD,gEAA8C;AAE9C,gEAA8C;AAE9C,gEAA8C;AAE9C,kEAAgD","sourcesContent":["export * from './AbstractExpression';\n\nexport * from './EvaluatedExpression';\n\nexport * from './shorthand/ShorthandExpression';\nexport * from './shorthand/FormatShorthandExpression';\n\nexport * from './constant/ConstantExpression';\n\nexport * from './function/FunctionExpression';\n\nexport * from './text/FormatStringExpression';\n\nexport * from './text/AbstractFormatExpression';\n"]}
|
|
@@ -0,0 +1,60 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
exports.FormatShorthandExpressionParser = exports.FormatShorthandExpression = void 0;
|
|
4
|
+
const ExpressionParser_1 = require("../../ExpressionParser");
|
|
5
|
+
const ShorthandExpression_1 = require("./ShorthandExpression");
|
|
6
|
+
const tokens_1 = require("../../tokens");
|
|
7
|
+
/**
|
|
8
|
+
* A shorthand reference with a format specifier, such as `price:.2f`.
|
|
9
|
+
* Commonly used inside a format-string placeholder, for example `{price:.2f}`.
|
|
10
|
+
* The scope resolves the reference before the format specifier is applied to its value.
|
|
11
|
+
*
|
|
12
|
+
* @example
|
|
13
|
+
* ```ts
|
|
14
|
+
* const expression = FormatShorthandExpression.parse('price:.2f');
|
|
15
|
+
* expression.path; // ['price']
|
|
16
|
+
* expression.format; // '.2f'
|
|
17
|
+
* expression.raw(); // 'price:.2f'
|
|
18
|
+
* ```
|
|
19
|
+
*/
|
|
20
|
+
class FormatShorthandExpression extends ShorthandExpression_1.ShorthandExpression {
|
|
21
|
+
static parse(source, start = 0) {
|
|
22
|
+
return new FormatShorthandExpressionParser().parse(source, start);
|
|
23
|
+
}
|
|
24
|
+
constructor(options) {
|
|
25
|
+
super(options);
|
|
26
|
+
this.type = FormatShorthandExpression.TYPE;
|
|
27
|
+
}
|
|
28
|
+
isValid() {
|
|
29
|
+
return super.isValid() && typeof this.format === 'string' && /^[\w.]+$/.test(this.format);
|
|
30
|
+
}
|
|
31
|
+
}
|
|
32
|
+
exports.FormatShorthandExpression = FormatShorthandExpression;
|
|
33
|
+
FormatShorthandExpression.TYPE = 'format-shorthand-expression';
|
|
34
|
+
/**
|
|
35
|
+
* Recognize the syntax owned by FormatShorthandExpression.
|
|
36
|
+
*/
|
|
37
|
+
class FormatShorthandExpressionParser extends ExpressionParser_1.ExpressionParser {
|
|
38
|
+
tryParse(source, start = 0) {
|
|
39
|
+
const text = (0, tokens_1.stringify)(source);
|
|
40
|
+
const match = text.match(/:\s*([\w.]+)\s*$/);
|
|
41
|
+
let expression = null;
|
|
42
|
+
if (match) {
|
|
43
|
+
const reference = text.slice(0, match.index);
|
|
44
|
+
const shorthand = new ShorthandExpression_1.ShorthandExpressionParser().tryParse(reference, start);
|
|
45
|
+
if (shorthand) {
|
|
46
|
+
let tokens;
|
|
47
|
+
if (typeof source === 'string') {
|
|
48
|
+
tokens = [...shorthand.tokens, new tokens_1.TextToken(text.slice(match.index), start + match.index)];
|
|
49
|
+
}
|
|
50
|
+
else {
|
|
51
|
+
tokens = source;
|
|
52
|
+
}
|
|
53
|
+
expression = new FormatShorthandExpression({ format: match[1], tokens });
|
|
54
|
+
}
|
|
55
|
+
}
|
|
56
|
+
return expression;
|
|
57
|
+
}
|
|
58
|
+
}
|
|
59
|
+
exports.FormatShorthandExpressionParser = FormatShorthandExpressionParser;
|
|
60
|
+
//# sourceMappingURL=FormatShorthandExpression.js.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"FormatShorthandExpression.js","sourceRoot":"","sources":["../../../src/expressions/shorthand/FormatShorthandExpression.ts"],"names":[],"mappings":";;;AAAA,6DAA0D;AAC1D,+DAAmH;AACnH,yCAAqF;AAMrF;;;;;;;;;;;;GAYG;AACH,+BAAuC,SAAQ,yCAAqD;IAGlG,MAAM,CAAC,KAAK,CAAC,MAAwB,EAAE,KAAK,GAAG,CAAC;QAC9C,OAAO,IAAI,+BAA+B,EAAE,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACpE,CAAC;IAED,YAAY,OAAyC;QACnD,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,yBAAyB,CAAC,IAAI,CAAC;IAC7C,CAAC;IAED,OAAO;QACL,OAAO,KAAK,CAAC,OAAO,EAAE,IAAI,OAAO,IAAI,CAAC,MAAM,KAAK,QAAQ,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC5F,CAAC;CACF;;AAdiB,8BAAI,GAAG,6BAA6B,CAAC;AAgBvD;;GAEG;AACH,qCAA6C,SAAQ,mCAA2C;IAC9F,QAAQ,CAAC,MAAwB,EAAE,KAAK,GAAG,CAAC;QAC1C,MAAM,IAAI,GAAG,IAAA,kBAAS,EAAC,MAAM,CAAC,CAAC;QAC/B,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC;QAC7C,IAAI,UAAU,GAAqC,IAAI,CAAC;QACxD,IAAI,KAAK,EAAE,CAAC;YACV,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;YAC7C,MAAM,SAAS,GAAG,IAAI,+CAAyB,EAAE,CAAC,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;YAC7E,IAAI,SAAS,EAAE,CAAC;gBACd,IAAI,MAAgC,CAAC;gBACrC,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;oBAC/B,MAAM,GAAG,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,IAAI,kBAAS,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;gBAC9F,CAAC;qBAAM,CAAC;oBACN,MAAM,GAAG,MAAM,CAAC;gBAClB,CAAC;gBACD,UAAU,GAAG,IAAI,yBAAyB,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;YAC3E,CAAC;QACH,CAAC;QACD,OAAO,UAAU,CAAC;IACpB,CAAC;CACF","sourcesContent":["import { ExpressionParser } from '../../ExpressionParser';\nimport { ShorthandExpression, ShorthandExpressionOptions, ShorthandExpressionParser } from './ShorthandExpression';\nimport { AbstractToken, ExpressionSource, TextToken, stringify } from '../../tokens';\n\nexport interface FormatShorthandExpressionOptions extends ShorthandExpressionOptions {\n format: string;\n}\n\n/**\n * A shorthand reference with a format specifier, such as `price:.2f`.\n * Commonly used inside a format-string placeholder, for example `{price:.2f}`.\n * The scope resolves the reference before the format specifier is applied to its value.\n *\n * @example\n * ```ts\n * const expression = FormatShorthandExpression.parse('price:.2f');\n * expression.path; // ['price']\n * expression.format; // '.2f'\n * expression.raw(); // 'price:.2f'\n * ```\n */\nexport class FormatShorthandExpression extends ShorthandExpression<FormatShorthandExpressionOptions> {\n static readonly TYPE = 'format-shorthand-expression';\n\n static parse(source: ExpressionSource, start = 0): FormatShorthandExpression {\n return new FormatShorthandExpressionParser().parse(source, start);\n }\n\n constructor(options: FormatShorthandExpressionOptions) {\n super(options);\n this.type = FormatShorthandExpression.TYPE;\n }\n\n isValid(): boolean {\n return super.isValid() && typeof this.format === 'string' && /^[\\w.]+$/.test(this.format);\n }\n}\n\n/**\n * Recognize the syntax owned by FormatShorthandExpression.\n */\nexport class FormatShorthandExpressionParser extends ExpressionParser<FormatShorthandExpression> {\n tryParse(source: ExpressionSource, start = 0): FormatShorthandExpression | null {\n const text = stringify(source);\n const match = text.match(/:\\s*([\\w.]+)\\s*$/);\n let expression: FormatShorthandExpression | null = null;\n if (match) {\n const reference = text.slice(0, match.index);\n const shorthand = new ShorthandExpressionParser().tryParse(reference, start);\n if (shorthand) {\n let tokens: readonly AbstractToken[];\n if (typeof source === 'string') {\n tokens = [...shorthand.tokens, new TextToken(text.slice(match.index), start + match.index)];\n } else {\n tokens = source;\n }\n expression = new FormatShorthandExpression({ format: match[1], tokens });\n }\n }\n return expression;\n }\n}\n"]}
|
|
@@ -0,0 +1,90 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
exports.ShorthandExpressionParser = exports.ShorthandExpression = void 0;
|
|
4
|
+
const ExpressionParser_1 = require("../../ExpressionParser");
|
|
5
|
+
const AbstractExpression_1 = require("../AbstractExpression");
|
|
6
|
+
const tokens_1 = require("../../tokens");
|
|
7
|
+
/**
|
|
8
|
+
* A reference resolved through the scope without an evaluation prefix.
|
|
9
|
+
* Examples include `user.name`, `items[0].name` and `user['name']`.
|
|
10
|
+
* Dynamic keys, call receivers, optional chains and arithmetic are not shorthand references.
|
|
11
|
+
*
|
|
12
|
+
* @example
|
|
13
|
+
* ```ts
|
|
14
|
+
* ShorthandExpression.parse('user.name').path; // ['user', 'name']
|
|
15
|
+
* ShorthandExpression.parse('items[0].name').raw(); // 'items[0].name'
|
|
16
|
+
* ```
|
|
17
|
+
*/
|
|
18
|
+
class ShorthandExpression extends AbstractExpression_1.AbstractExpression {
|
|
19
|
+
static parse(source, start = 0) {
|
|
20
|
+
return new ShorthandExpressionParser().parse(source, start);
|
|
21
|
+
}
|
|
22
|
+
constructor(options) {
|
|
23
|
+
super(ShorthandExpression.TYPE, options);
|
|
24
|
+
}
|
|
25
|
+
get format() {
|
|
26
|
+
var _a;
|
|
27
|
+
return (_a = this.options.format) !== null && _a !== void 0 ? _a : null;
|
|
28
|
+
}
|
|
29
|
+
get codeToken() {
|
|
30
|
+
return (0, tokens_1.codeToken)(this.tokens);
|
|
31
|
+
}
|
|
32
|
+
isValid() {
|
|
33
|
+
const code = this.tokens.filter((token) => token instanceof tokens_1.CodeToken);
|
|
34
|
+
return code.length === 1 && code[0].referencePath() != null;
|
|
35
|
+
}
|
|
36
|
+
get path() {
|
|
37
|
+
const path = this.codeToken.referencePath();
|
|
38
|
+
if (path == null)
|
|
39
|
+
throw new TypeError('Shorthand expressions require a static reference path.');
|
|
40
|
+
return path;
|
|
41
|
+
}
|
|
42
|
+
/**
|
|
43
|
+
* Resolve the referenced type without evaluating its value or retaining the result.
|
|
44
|
+
*/
|
|
45
|
+
resolveType(context) {
|
|
46
|
+
return context.getReference(this.path);
|
|
47
|
+
}
|
|
48
|
+
/**
|
|
49
|
+
* Report an unresolved reference using its original source token.
|
|
50
|
+
*/
|
|
51
|
+
validate(context) {
|
|
52
|
+
if (this.resolveType(context) != null) {
|
|
53
|
+
return [];
|
|
54
|
+
}
|
|
55
|
+
return [{ token: this.codeToken, message: `'${this.codeToken.code}' is not defined` }];
|
|
56
|
+
}
|
|
57
|
+
}
|
|
58
|
+
exports.ShorthandExpression = ShorthandExpression;
|
|
59
|
+
ShorthandExpression.TYPE = 'shorthand-expression';
|
|
60
|
+
/**
|
|
61
|
+
* Recognize the syntax owned by ShorthandExpression.
|
|
62
|
+
*/
|
|
63
|
+
class ShorthandExpressionParser extends ExpressionParser_1.ExpressionParser {
|
|
64
|
+
tryParse(source, start = 0) {
|
|
65
|
+
let expression = null;
|
|
66
|
+
try {
|
|
67
|
+
let tokens;
|
|
68
|
+
if (typeof source === 'string') {
|
|
69
|
+
tokens = [new tokens_1.JSToken(source, start)];
|
|
70
|
+
}
|
|
71
|
+
else {
|
|
72
|
+
tokens = source;
|
|
73
|
+
}
|
|
74
|
+
const candidate = new ShorthandExpression({
|
|
75
|
+
tokens
|
|
76
|
+
});
|
|
77
|
+
if (candidate.isValid()) {
|
|
78
|
+
expression = candidate;
|
|
79
|
+
}
|
|
80
|
+
}
|
|
81
|
+
catch (error) {
|
|
82
|
+
if (!(error instanceof SyntaxError)) {
|
|
83
|
+
throw error;
|
|
84
|
+
}
|
|
85
|
+
}
|
|
86
|
+
return expression;
|
|
87
|
+
}
|
|
88
|
+
}
|
|
89
|
+
exports.ShorthandExpressionParser = ShorthandExpressionParser;
|
|
90
|
+
//# sourceMappingURL=ShorthandExpression.js.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"ShorthandExpression.js","sourceRoot":"","sources":["../../../src/expressions/shorthand/ShorthandExpression.ts"],"names":[],"mappings":";;;AAAA,6DAA0D;AAC1D,8DAA4G;AAC5G,yCAA6G;AAQ7G;;;;;;;;;;GAUG;AACH,yBAEE,SAAQ,uCAAqB;IAG7B,MAAM,CAAC,KAAK,CAAC,MAAwB,EAAE,KAAK,GAAG,CAAC;QAC9C,OAAO,IAAI,yBAAyB,EAAE,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC9D,CAAC;IAED,YAAY,OAAU;QACpB,KAAK,CAAC,mBAAmB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAC3C,CAAC;IAED,IAAI,MAAM;;QACR,aAAO,IAAI,CAAC,OAAO,CAAC,MAAM,mCAAI,IAAI,CAAC;IACrC,CAAC;IAED,IAAI,SAAS;QACX,OAAO,IAAA,kBAAS,EAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAChC,CAAC;IAED,OAAO;QACL,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,EAAsB,EAAE,CAAC,KAAK,YAAY,kBAAS,CAAC,CAAC;QAC3F,OAAO,IAAI,CAAC,MAAM,KAAK,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,aAAa,EAAE,IAAI,IAAI,CAAC;IAC9D,CAAC;IAED,IAAI,IAAI;QACN,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,CAAC;QAC5C,IAAI,IAAI,IAAI,IAAI;YAAE,MAAM,IAAI,SAAS,CAAC,wDAAwD,CAAC,CAAC;QAChG,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,WAAW,CAAC,OAA0B;QACpC,OAAO,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACzC,CAAC;IAED;;OAEG;IACH,QAAQ,CAAC,OAA0B;QACjC,IAAI,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,IAAI,EAAE,CAAC;YACtC,OAAO,EAAE,CAAC;QACZ,CAAC;QACD,OAAO,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,OAAO,EAAE,IAAI,IAAI,CAAC,SAAS,CAAC,IAAI,kBAAkB,EAAE,CAAC,CAAC;IACzF,CAAC;CACF;;AA7CQ,wBAAI,GAAG,sBAAsB,CAAC;AA+CvC;;GAEG;AACH,+BAAuC,SAAQ,mCAAqC;IAClF,QAAQ,CAAC,MAAwB,EAAE,KAAK,GAAG,CAAC;QAC1C,IAAI,UAAU,GAA+B,IAAI,CAAC;QAClD,IAAI,CAAC;YACH,IAAI,MAAgC,CAAC;YACrC,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;gBAC/B,MAAM,GAAG,CAAC,IAAI,gBAAO,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;YACxC,CAAC;iBAAM,CAAC;gBACN,MAAM,GAAG,MAAM,CAAC;YAClB,CAAC;YACD,MAAM,SAAS,GAAG,IAAI,mBAAmB,CAAC;gBACxC,MAAM;aACP,CAAC,CAAC;YACH,IAAI,SAAS,CAAC,OAAO,EAAE,EAAE,CAAC;gBACxB,UAAU,GAAG,SAAS,CAAC;YACzB,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,CAAC,KAAK,YAAY,WAAW,CAAC,EAAE,CAAC;gBACpC,MAAM,KAAK,CAAC;YACd,CAAC;QACH,CAAC;QACD,OAAO,UAAU,CAAC;IACpB,CAAC;CACF","sourcesContent":["import { ExpressionParser } from '../../ExpressionParser';\nimport { AbstractExpression, AbstractExpressionOptions, ExpressionDiagnostic } from '../AbstractExpression';\nimport { AbstractToken, CodeToken, codeToken, ExpressionSource, JSToken, ReferencePath } from '../../tokens';\nimport type { ValidationContext } from '../../definitions/ValidationContext';\nimport type { Type } from '@ja-platform/parser-type-system';\n\nexport interface ShorthandExpressionOptions extends AbstractExpressionOptions {\n format?: string;\n}\n\n/**\n * A reference resolved through the scope without an evaluation prefix.\n * Examples include `user.name`, `items[0].name` and `user['name']`.\n * Dynamic keys, call receivers, optional chains and arithmetic are not shorthand references.\n *\n * @example\n * ```ts\n * ShorthandExpression.parse('user.name').path; // ['user', 'name']\n * ShorthandExpression.parse('items[0].name').raw(); // 'items[0].name'\n * ```\n */\nexport class ShorthandExpression<\n O extends ShorthandExpressionOptions = ShorthandExpressionOptions\n> extends AbstractExpression<O> {\n static TYPE = 'shorthand-expression';\n\n static parse(source: ExpressionSource, start = 0): ShorthandExpression {\n return new ShorthandExpressionParser().parse(source, start);\n }\n\n constructor(options: O) {\n super(ShorthandExpression.TYPE, options);\n }\n\n get format(): string | null {\n return this.options.format ?? null;\n }\n\n get codeToken(): CodeToken {\n return codeToken(this.tokens);\n }\n\n isValid(): boolean {\n const code = this.tokens.filter((token): token is CodeToken => token instanceof CodeToken);\n return code.length === 1 && code[0].referencePath() != null;\n }\n\n get path(): ReferencePath {\n const path = this.codeToken.referencePath();\n if (path == null) throw new TypeError('Shorthand expressions require a static reference path.');\n return path;\n }\n\n /**\n * Resolve the referenced type without evaluating its value or retaining the result.\n */\n resolveType(context: ValidationContext): Type | null {\n return context.getReference(this.path);\n }\n\n /**\n * Report an unresolved reference using its original source token.\n */\n validate(context: ValidationContext): ExpressionDiagnostic[] {\n if (this.resolveType(context) != null) {\n return [];\n }\n return [{ token: this.codeToken, message: `'${this.codeToken.code}' is not defined` }];\n }\n}\n\n/**\n * Recognize the syntax owned by ShorthandExpression.\n */\nexport class ShorthandExpressionParser extends ExpressionParser<ShorthandExpression> {\n tryParse(source: ExpressionSource, start = 0): ShorthandExpression | null {\n let expression: ShorthandExpression | null = null;\n try {\n let tokens: readonly AbstractToken[];\n if (typeof source === 'string') {\n tokens = [new JSToken(source, start)];\n } else {\n tokens = source;\n }\n const candidate = new ShorthandExpression({\n tokens\n });\n if (candidate.isValid()) {\n expression = candidate;\n }\n } catch (error) {\n if (!(error instanceof SyntaxError)) {\n throw error;\n }\n }\n return expression;\n }\n}\n"]}
|
|
@@ -0,0 +1,178 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
exports.AbstractFormatExpressionParser = exports.AbstractFormatExpression = void 0;
|
|
4
|
+
const ExpressionParser_1 = require("../../ExpressionParser");
|
|
5
|
+
const tokens_1 = require("../../tokens");
|
|
6
|
+
const AbstractExpression_1 = require("../AbstractExpression");
|
|
7
|
+
/**
|
|
8
|
+
* Shared format text, placeholder tokens, source positions, and rendering.
|
|
9
|
+
*/
|
|
10
|
+
class AbstractFormatExpression extends AbstractExpression_1.AbstractExpression {
|
|
11
|
+
get tokens() {
|
|
12
|
+
return this.options.tokens;
|
|
13
|
+
}
|
|
14
|
+
isValid() {
|
|
15
|
+
return this.tokens.every((token) => token instanceof tokens_1.TextToken || (token instanceof tokens_1.PlaceholderToken && token.expression.isValid()));
|
|
16
|
+
}
|
|
17
|
+
get parameters() {
|
|
18
|
+
return this.tokens
|
|
19
|
+
.filter((token) => token instanceof tokens_1.PlaceholderToken)
|
|
20
|
+
.map((token) => token.expression);
|
|
21
|
+
}
|
|
22
|
+
withParameters(parameters) {
|
|
23
|
+
if (parameters.length !== this.parameters.length) {
|
|
24
|
+
throw new Error('Expected one expression for each format-string placeholder.');
|
|
25
|
+
}
|
|
26
|
+
const parser = this.getParser();
|
|
27
|
+
let index = 0;
|
|
28
|
+
let start = this.start;
|
|
29
|
+
const tokens = [];
|
|
30
|
+
for (const token of this.tokens) {
|
|
31
|
+
const replacement = token instanceof tokens_1.PlaceholderToken
|
|
32
|
+
? parser.placeholder(parameters[index++], start)
|
|
33
|
+
: new tokens_1.TextToken(token.raw(), start);
|
|
34
|
+
tokens.push(replacement);
|
|
35
|
+
start = replacement.end;
|
|
36
|
+
}
|
|
37
|
+
return parser.parse(tokens, this.start);
|
|
38
|
+
}
|
|
39
|
+
/**
|
|
40
|
+
* Validate each placeholder against the supplied declarations.
|
|
41
|
+
*/
|
|
42
|
+
validate(context) {
|
|
43
|
+
return this.parameters.flatMap((expression) => expression.validate(context));
|
|
44
|
+
}
|
|
45
|
+
/**
|
|
46
|
+
* Assemble the text using resolved placeholder values in parameter order.
|
|
47
|
+
* This does not parse source or evaluate parameters.
|
|
48
|
+
*
|
|
49
|
+
* @example
|
|
50
|
+
* ```ts
|
|
51
|
+
* FormatStringExpression.parse('Hello {user.name}').render(['Sam']); // 'Hello Sam'
|
|
52
|
+
* ```
|
|
53
|
+
*/
|
|
54
|
+
render(values) {
|
|
55
|
+
let index = 0;
|
|
56
|
+
return this.tokens
|
|
57
|
+
.map((token) => {
|
|
58
|
+
var _a;
|
|
59
|
+
let text;
|
|
60
|
+
if (token instanceof tokens_1.TextToken) {
|
|
61
|
+
text = token.decodedText;
|
|
62
|
+
}
|
|
63
|
+
else {
|
|
64
|
+
text = String((_a = values[index++]) !== null && _a !== void 0 ? _a : '');
|
|
65
|
+
}
|
|
66
|
+
return text;
|
|
67
|
+
})
|
|
68
|
+
.join('');
|
|
69
|
+
}
|
|
70
|
+
toString() {
|
|
71
|
+
return this.raw();
|
|
72
|
+
}
|
|
73
|
+
}
|
|
74
|
+
exports.AbstractFormatExpression = AbstractFormatExpression;
|
|
75
|
+
class AbstractFormatExpressionParser extends ExpressionParser_1.ExpressionParser {
|
|
76
|
+
/**
|
|
77
|
+
* Reparse replacements through the concrete grammar, retaining their expression kind.
|
|
78
|
+
*/
|
|
79
|
+
placeholder(expression, start) {
|
|
80
|
+
const parsed = this.parsePlaceholder(expression.raw(), start + 1);
|
|
81
|
+
if (parsed.type !== expression.type) {
|
|
82
|
+
throw new SyntaxError('Unsupported expression in a format placeholder.');
|
|
83
|
+
}
|
|
84
|
+
parsed.start = start;
|
|
85
|
+
return new tokens_1.PlaceholderToken(parsed, start);
|
|
86
|
+
}
|
|
87
|
+
validateToken(token) {
|
|
88
|
+
if (token instanceof tokens_1.TextToken)
|
|
89
|
+
return;
|
|
90
|
+
if (token instanceof tokens_1.PlaceholderToken) {
|
|
91
|
+
this.placeholder(token.expression, token.start);
|
|
92
|
+
return;
|
|
93
|
+
}
|
|
94
|
+
throw new SyntaxError('Expected valid format text and placeholders.');
|
|
95
|
+
}
|
|
96
|
+
tryParse(source, start = 0) {
|
|
97
|
+
source = source !== null && source !== void 0 ? source : '';
|
|
98
|
+
let tokens;
|
|
99
|
+
if (typeof source === 'string') {
|
|
100
|
+
tokens = this.tokens(source, start);
|
|
101
|
+
}
|
|
102
|
+
else {
|
|
103
|
+
tokens = [];
|
|
104
|
+
for (const token of source) {
|
|
105
|
+
this.validateToken(token);
|
|
106
|
+
tokens.push(token);
|
|
107
|
+
}
|
|
108
|
+
}
|
|
109
|
+
const expression = this.createExpression({ start, tokens });
|
|
110
|
+
if (!expression.isValid()) {
|
|
111
|
+
throw new SyntaxError('Expected valid format text and placeholders.');
|
|
112
|
+
}
|
|
113
|
+
return expression;
|
|
114
|
+
}
|
|
115
|
+
tokens(source, offset = 0) {
|
|
116
|
+
const tokens = [];
|
|
117
|
+
let start = 0;
|
|
118
|
+
for (let i = 0; i < source.length; i++) {
|
|
119
|
+
if (source[i] !== '{')
|
|
120
|
+
continue;
|
|
121
|
+
// Doubled braces encode literal text, so they never start a placeholder.
|
|
122
|
+
if (source[i + 1] === '{') {
|
|
123
|
+
i++;
|
|
124
|
+
continue;
|
|
125
|
+
}
|
|
126
|
+
const end = placeholderEnd({ source, start: i });
|
|
127
|
+
// Preserve unmatched opening braces as text.
|
|
128
|
+
if (end < 0)
|
|
129
|
+
break;
|
|
130
|
+
const text = source.slice(i + 1, end);
|
|
131
|
+
if (text.trim() === '')
|
|
132
|
+
throw new SyntaxError('Expected an expression inside a placeholder.');
|
|
133
|
+
const expression = this.parsePlaceholder(text, offset + i + 1);
|
|
134
|
+
if (!expression)
|
|
135
|
+
throw new SyntaxError('Expected an expression inside a placeholder.');
|
|
136
|
+
if (i > start)
|
|
137
|
+
tokens.push(new tokens_1.TextToken(source.slice(start, i), offset + start));
|
|
138
|
+
expression.start = offset + i;
|
|
139
|
+
tokens.push(new tokens_1.PlaceholderToken(expression, offset + i));
|
|
140
|
+
start = end + 1;
|
|
141
|
+
i = end;
|
|
142
|
+
}
|
|
143
|
+
if (start < source.length)
|
|
144
|
+
tokens.push(new tokens_1.TextToken(source.slice(start), offset + start));
|
|
145
|
+
return tokens;
|
|
146
|
+
}
|
|
147
|
+
}
|
|
148
|
+
exports.AbstractFormatExpressionParser = AbstractFormatExpressionParser;
|
|
149
|
+
/**
|
|
150
|
+
* Balance placeholder braces independently of the embedded language. Single, double and
|
|
151
|
+
* backtick quotes are opaque spans with backslash escapes; comments, regex literals and
|
|
152
|
+
* nested template interpolation have no special boundary rules.
|
|
153
|
+
* Return -1 for an unmatched opening brace or unfinished quoted span.
|
|
154
|
+
*/
|
|
155
|
+
function placeholderEnd({ source, start }) {
|
|
156
|
+
let depth = 1;
|
|
157
|
+
let quote = '';
|
|
158
|
+
for (let i = start + 1; i < source.length; i++) {
|
|
159
|
+
const char = source[i];
|
|
160
|
+
if (quote) {
|
|
161
|
+
if (char === '\\')
|
|
162
|
+
i++;
|
|
163
|
+
else if (char === quote)
|
|
164
|
+
quote = '';
|
|
165
|
+
}
|
|
166
|
+
else if (char === "'" || char === '"' || char === '`') {
|
|
167
|
+
quote = char;
|
|
168
|
+
}
|
|
169
|
+
else if (char === '{') {
|
|
170
|
+
depth++;
|
|
171
|
+
}
|
|
172
|
+
else if (char === '}' && --depth === 0) {
|
|
173
|
+
return i;
|
|
174
|
+
}
|
|
175
|
+
}
|
|
176
|
+
return -1;
|
|
177
|
+
}
|
|
178
|
+
//# sourceMappingURL=AbstractFormatExpression.js.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"AbstractFormatExpression.js","sourceRoot":"","sources":["../../../src/expressions/text/AbstractFormatExpression.ts"],"names":[],"mappings":"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","sourcesContent":["import { ExpressionParser } from '../../ExpressionParser';\nimport { AbstractToken, ExpressionSource, TextToken, PlaceholderToken } from '../../tokens';\nimport type { ValidationContext } from '../../definitions/ValidationContext';\nimport { AbstractExpression, AbstractExpressionOptions, ExpressionDiagnostic } from '../AbstractExpression';\n\nexport interface AbstractFormatExpressionOptions<P extends AbstractExpression> extends AbstractExpressionOptions {\n tokens: readonly (TextToken | PlaceholderToken<P>)[];\n}\n\n/**\n * Shared format text, placeholder tokens, source positions, and rendering.\n */\nexport abstract class AbstractFormatExpression<\n T extends AbstractFormatExpression<T, P>,\n P extends AbstractExpression = AbstractExpression\n> extends AbstractExpression<AbstractFormatExpressionOptions<P>> {\n get tokens(): readonly (TextToken | PlaceholderToken<P>)[] {\n return this.options.tokens;\n }\n\n isValid(): boolean {\n return this.tokens.every(\n (token) => token instanceof TextToken || (token instanceof PlaceholderToken && token.expression.isValid())\n );\n }\n\n get parameters(): readonly P[] {\n return this.tokens\n .filter((token): token is PlaceholderToken<P> => token instanceof PlaceholderToken)\n .map((token) => token.expression);\n }\n\n protected abstract getParser(): AbstractFormatExpressionParser<T, P>;\n\n withParameters(parameters: readonly P[]): T {\n if (parameters.length !== this.parameters.length) {\n throw new Error('Expected one expression for each format-string placeholder.');\n }\n const parser = this.getParser();\n let index = 0;\n let start = this.start;\n const tokens: (TextToken | PlaceholderToken<P>)[] = [];\n for (const token of this.tokens) {\n const replacement =\n token instanceof PlaceholderToken\n ? parser.placeholder(parameters[index++], start)\n : new TextToken(token.raw(), start);\n tokens.push(replacement);\n start = replacement.end;\n }\n return parser.parse(tokens, this.start);\n }\n\n /**\n * Validate each placeholder against the supplied declarations.\n */\n validate(context: ValidationContext): ExpressionDiagnostic[] {\n return this.parameters.flatMap((expression) => expression.validate(context));\n }\n\n /**\n * Assemble the text using resolved placeholder values in parameter order.\n * This does not parse source or evaluate parameters.\n *\n * @example\n * ```ts\n * FormatStringExpression.parse('Hello {user.name}').render(['Sam']); // 'Hello Sam'\n * ```\n */\n render(values: readonly unknown[]): string {\n let index = 0;\n return this.tokens\n .map((token) => {\n let text: string;\n if (token instanceof TextToken) {\n text = token.decodedText;\n } else {\n text = String(values[index++] ?? '');\n }\n return text;\n })\n .join('');\n }\n\n toString(): string {\n return this.raw();\n }\n}\n\nexport abstract class AbstractFormatExpressionParser<\n T extends AbstractFormatExpression<T, P>,\n P extends AbstractExpression = AbstractExpression\n> extends ExpressionParser<T> {\n protected abstract parsePlaceholder(source: ExpressionSource, start: number): P;\n protected abstract createExpression(options: AbstractFormatExpressionOptions<P>): T;\n\n /**\n * Reparse replacements through the concrete grammar, retaining their expression kind.\n */\n placeholder(expression: AbstractExpression, start: number): PlaceholderToken<P> {\n const parsed = this.parsePlaceholder(expression.raw(), start + 1);\n if (parsed.type !== expression.type) {\n throw new SyntaxError('Unsupported expression in a format placeholder.');\n }\n parsed.start = start;\n return new PlaceholderToken(parsed, start);\n }\n\n protected validateToken(token: AbstractToken): asserts token is TextToken | PlaceholderToken<P> {\n if (token instanceof TextToken) return;\n if (token instanceof PlaceholderToken) {\n this.placeholder(token.expression, token.start);\n return;\n }\n throw new SyntaxError('Expected valid format text and placeholders.');\n }\n\n tryParse(source: ExpressionSource, start = 0): T {\n source = source ?? '';\n let tokens: (TextToken | PlaceholderToken<P>)[];\n if (typeof source === 'string') {\n tokens = this.tokens(source, start);\n } else {\n tokens = [];\n for (const token of source) {\n this.validateToken(token);\n tokens.push(token);\n }\n }\n const expression = this.createExpression({ start, tokens });\n if (!expression.isValid()) {\n throw new SyntaxError('Expected valid format text and placeholders.');\n }\n return expression;\n }\n\n tokens(source: string, offset = 0): (TextToken | PlaceholderToken<P>)[] {\n const tokens: (TextToken | PlaceholderToken<P>)[] = [];\n let start = 0;\n for (let i = 0; i < source.length; i++) {\n if (source[i] !== '{') continue;\n // Doubled braces encode literal text, so they never start a placeholder.\n if (source[i + 1] === '{') {\n i++;\n continue;\n }\n const end = placeholderEnd({ source, start: i });\n // Preserve unmatched opening braces as text.\n if (end < 0) break;\n const text = source.slice(i + 1, end);\n if (text.trim() === '') throw new SyntaxError('Expected an expression inside a placeholder.');\n const expression = this.parsePlaceholder(text, offset + i + 1);\n if (!expression) throw new SyntaxError('Expected an expression inside a placeholder.');\n if (i > start) tokens.push(new TextToken(source.slice(start, i), offset + start));\n expression.start = offset + i;\n tokens.push(new PlaceholderToken(expression, offset + i));\n start = end + 1;\n i = end;\n }\n if (start < source.length) tokens.push(new TextToken(source.slice(start), offset + start));\n return tokens;\n }\n}\n\n/**\n * Balance placeholder braces independently of the embedded language. Single, double and\n * backtick quotes are opaque spans with backslash escapes; comments, regex literals and\n * nested template interpolation have no special boundary rules.\n * Return -1 for an unmatched opening brace or unfinished quoted span.\n */\nfunction placeholderEnd({ source, start }: { source: string; start: number }): number {\n let depth = 1;\n let quote = '';\n for (let i = start + 1; i < source.length; i++) {\n const char = source[i];\n if (quote) {\n if (char === '\\\\') i++;\n else if (char === quote) quote = '';\n } else if (char === \"'\" || char === '\"' || char === '`') {\n quote = char;\n } else if (char === '{') {\n depth++;\n } else if (char === '}' && --depth === 0) {\n return i;\n }\n }\n return -1;\n}\n"]}
|
|
@@ -0,0 +1,44 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
exports.FormatStringExpressionParser = exports.FormatStringExpression = void 0;
|
|
4
|
+
const CombinedParser_1 = require("../../CombinedParser");
|
|
5
|
+
const EvaluatedExpression_1 = require("../EvaluatedExpression");
|
|
6
|
+
const FunctionExpression_1 = require("../function/FunctionExpression");
|
|
7
|
+
const FormatShorthandExpression_1 = require("../shorthand/FormatShorthandExpression");
|
|
8
|
+
const ShorthandExpression_1 = require("../shorthand/ShorthandExpression");
|
|
9
|
+
const AbstractFormatExpression_1 = require("./AbstractFormatExpression");
|
|
10
|
+
/**
|
|
11
|
+
* Format text supporting references, formatted references, and explicitly evaluated code.
|
|
12
|
+
*/
|
|
13
|
+
class FormatStringExpression extends AbstractFormatExpression_1.AbstractFormatExpression {
|
|
14
|
+
static parse(source, start = 0) {
|
|
15
|
+
return new FormatStringExpressionParser().parse(source, start);
|
|
16
|
+
}
|
|
17
|
+
constructor(options) {
|
|
18
|
+
super(FormatStringExpression.TYPE, options);
|
|
19
|
+
}
|
|
20
|
+
getParser() {
|
|
21
|
+
return new FormatStringExpressionParser();
|
|
22
|
+
}
|
|
23
|
+
}
|
|
24
|
+
exports.FormatStringExpression = FormatStringExpression;
|
|
25
|
+
FormatStringExpression.TYPE = 'format-string';
|
|
26
|
+
class FormatStringExpressionParser extends AbstractFormatExpression_1.AbstractFormatExpressionParser {
|
|
27
|
+
constructor() {
|
|
28
|
+
super(...arguments);
|
|
29
|
+
this.placeholders = new CombinedParser_1.CombinedParser([
|
|
30
|
+
new FunctionExpression_1.FunctionExpressionParser(),
|
|
31
|
+
new EvaluatedExpression_1.EvaluatedExpressionParser(),
|
|
32
|
+
new FormatShorthandExpression_1.FormatShorthandExpressionParser(),
|
|
33
|
+
new ShorthandExpression_1.ShorthandExpressionParser()
|
|
34
|
+
]);
|
|
35
|
+
}
|
|
36
|
+
parsePlaceholder(source, start) {
|
|
37
|
+
return this.placeholders.parse(source, start);
|
|
38
|
+
}
|
|
39
|
+
createExpression(options) {
|
|
40
|
+
return new FormatStringExpression(options);
|
|
41
|
+
}
|
|
42
|
+
}
|
|
43
|
+
exports.FormatStringExpressionParser = FormatStringExpressionParser;
|
|
44
|
+
//# sourceMappingURL=FormatStringExpression.js.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"FormatStringExpression.js","sourceRoot":"","sources":["../../../src/expressions/text/FormatStringExpression.ts"],"names":[],"mappings":";;;AAAA,yDAAsD;AAEtD,gEAAwF;AACxF,uEAA0E;AAC1E,sFAAyF;AACzF,0EAAkG;AAClG,yEAIoC;AAEpC;;GAEG;AACH,4BAAoC,SAAQ,mDAG3C;IAGC,MAAM,CAAC,KAAK,CAAC,MAAwB,EAAE,KAAK,GAAG,CAAC;QAC9C,OAAO,IAAI,4BAA4B,EAAE,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACjE,CAAC;IAED,YAAY,OAAmF;QAC7F,KAAK,CAAC,sBAAsB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAC9C,CAAC;IAES,SAAS;QACjB,OAAO,IAAI,4BAA4B,EAAE,CAAC;IAC5C,CAAC;CACF;;AAbiB,2BAAI,GAAG,eAAe,CAAC;AAezC,kCAA0C,SAAQ,yDAGjD;IAHD;;QAImB,iBAAY,GAAG,IAAI,+BAAc,CAA4C;YAC5F,IAAI,6CAAwB,EAAE;YAC9B,IAAI,+CAAyB,EAAE;YAC/B,IAAI,2DAA+B,EAAE;YACrC,IAAI,+CAAyB,EAAE;SAChC,CAAC,CAAC;IASL,CAAC;IAPW,gBAAgB,CAAC,MAAwB,EAAE,KAAa;QAChE,OAAO,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAChD,CAAC;IAES,gBAAgB,CAAC,OAAmF;QAC5G,OAAO,IAAI,sBAAsB,CAAC,OAAO,CAAC,CAAC;IAC7C,CAAC;CACF","sourcesContent":["import { CombinedParser } from '../../CombinedParser';\nimport { ExpressionSource } from '../../tokens';\nimport { EvaluatedExpression, EvaluatedExpressionParser } from '../EvaluatedExpression';\nimport { FunctionExpressionParser } from '../function/FunctionExpression';\nimport { FormatShorthandExpressionParser } from '../shorthand/FormatShorthandExpression';\nimport { ShorthandExpression, ShorthandExpressionParser } from '../shorthand/ShorthandExpression';\nimport {\n AbstractFormatExpression,\n AbstractFormatExpressionOptions,\n AbstractFormatExpressionParser\n} from './AbstractFormatExpression';\n\n/**\n * Format text supporting references, formatted references, and explicitly evaluated code.\n */\nexport class FormatStringExpression extends AbstractFormatExpression<\n FormatStringExpression,\n ShorthandExpression | EvaluatedExpression\n> {\n static readonly TYPE = 'format-string';\n\n static parse(source: ExpressionSource, start = 0): FormatStringExpression {\n return new FormatStringExpressionParser().parse(source, start);\n }\n\n constructor(options: AbstractFormatExpressionOptions<ShorthandExpression | EvaluatedExpression>) {\n super(FormatStringExpression.TYPE, options);\n }\n\n protected getParser(): FormatStringExpressionParser {\n return new FormatStringExpressionParser();\n }\n}\n\nexport class FormatStringExpressionParser extends AbstractFormatExpressionParser<\n FormatStringExpression,\n ShorthandExpression | EvaluatedExpression\n> {\n private readonly placeholders = new CombinedParser<ShorthandExpression | EvaluatedExpression>([\n new FunctionExpressionParser(),\n new EvaluatedExpressionParser(),\n new FormatShorthandExpressionParser(),\n new ShorthandExpressionParser()\n ]);\n\n protected parsePlaceholder(source: ExpressionSource, start: number) {\n return this.placeholders.parse(source, start);\n }\n\n protected createExpression(options: AbstractFormatExpressionOptions<ShorthandExpression | EvaluatedExpression>) {\n return new FormatStringExpression(options);\n }\n}\n"]}
|
package/dist/index.js
ADDED
|
@@ -0,0 +1,29 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
|
3
|
+
if (k2 === undefined) k2 = k;
|
|
4
|
+
var desc = Object.getOwnPropertyDescriptor(m, k);
|
|
5
|
+
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
|
6
|
+
desc = { enumerable: true, get: function() { return m[k]; } };
|
|
7
|
+
}
|
|
8
|
+
Object.defineProperty(o, k2, desc);
|
|
9
|
+
}) : (function(o, m, k, k2) {
|
|
10
|
+
if (k2 === undefined) k2 = k;
|
|
11
|
+
o[k2] = m[k];
|
|
12
|
+
}));
|
|
13
|
+
var __exportStar = (this && this.__exportStar) || function(m, exports) {
|
|
14
|
+
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
|
|
15
|
+
};
|
|
16
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
17
|
+
exports.formatValueAsync = exports.formatValue = void 0;
|
|
18
|
+
__exportStar(require("./ExpressionParser"), exports);
|
|
19
|
+
__exportStar(require("./CombinedParser"), exports);
|
|
20
|
+
__exportStar(require("./utils/parserUtils"), exports);
|
|
21
|
+
__exportStar(require("./code-parsers/CodeParser"), exports);
|
|
22
|
+
__exportStar(require("./code-parsers/JavaScriptParser"), exports);
|
|
23
|
+
var valueFormatting_1 = require("./utils/valueFormatting");
|
|
24
|
+
Object.defineProperty(exports, "formatValue", { enumerable: true, get: function () { return valueFormatting_1.formatValue; } });
|
|
25
|
+
Object.defineProperty(exports, "formatValueAsync", { enumerable: true, get: function () { return valueFormatting_1.formatValueAsync; } });
|
|
26
|
+
__exportStar(require("./expressions"), exports);
|
|
27
|
+
__exportStar(require("./definitions/ValidationContext"), exports);
|
|
28
|
+
__exportStar(require("./tokens"), exports);
|
|
29
|
+
//# sourceMappingURL=index.js.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,qDAAmC;AAEnC,mDAAiC;AACjC,sDAAoC;AACpC,4DAA0C;AAC1C,kEAAgD;AAChD,2DAAwE;AAA/D,8GAAA,WAAW,OAAA;AAAE,mHAAA,gBAAgB,OAAA;AAEtC,gDAA8B;AAE9B,kEAAgD;AAEhD,2CAAyB","sourcesContent":["export * from './ExpressionParser';\n\nexport * from './CombinedParser';\nexport * from './utils/parserUtils';\nexport * from './code-parsers/CodeParser';\nexport * from './code-parsers/JavaScriptParser';\nexport { formatValue, formatValueAsync } from './utils/valueFormatting';\n\nexport * from './expressions';\n\nexport * from './definitions/ValidationContext';\n\nexport * from './tokens';\n"]}
|
|
@@ -0,0 +1,22 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
exports.AbstractToken = void 0;
|
|
4
|
+
/**
|
|
5
|
+
* A source node. Containers expose their children and assemble their source recursively.
|
|
6
|
+
*/
|
|
7
|
+
class AbstractToken {
|
|
8
|
+
constructor(start = 0) {
|
|
9
|
+
this.start = start;
|
|
10
|
+
}
|
|
11
|
+
get children() {
|
|
12
|
+
return [];
|
|
13
|
+
}
|
|
14
|
+
get end() {
|
|
15
|
+
return this.start + this.raw().length;
|
|
16
|
+
}
|
|
17
|
+
raw() {
|
|
18
|
+
return this.children.map((child) => child.raw()).join('');
|
|
19
|
+
}
|
|
20
|
+
}
|
|
21
|
+
exports.AbstractToken = AbstractToken;
|
|
22
|
+
//# sourceMappingURL=AbstractToken.js.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"AbstractToken.js","sourceRoot":"","sources":["../../src/tokens/AbstractToken.ts"],"names":[],"mappings":";;;AAAA;;GAEG;AACH;IACE,YAA+B,KAAK,GAAG,CAAC;qBAAT,KAAK;IAAO,CAAC;IAI5C,IAAI,QAAQ;QACV,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,IAAI,GAAG;QACL,OAAO,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC;IACxC,CAAC;IAED,GAAG;QACD,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC5D,CAAC;CACF","sourcesContent":["/**\n * A source node. Containers expose their children and assemble their source recursively.\n */\nexport abstract class AbstractToken {\n protected constructor(readonly start = 0) {}\n\n abstract clone(): AbstractToken;\n\n get children(): readonly AbstractToken[] {\n return [];\n }\n\n get end(): number {\n return this.start + this.raw().length;\n }\n\n raw(): string {\n return this.children.map((child) => child.raw()).join('');\n }\n}\n\nexport type ExpressionSource = string | readonly AbstractToken[];\n"]}
|
|
@@ -0,0 +1,33 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
exports.CodeToken = void 0;
|
|
4
|
+
const AbstractToken_1 = require("../AbstractToken");
|
|
5
|
+
/**
|
|
6
|
+
* Original source and executable code for a language-specific token.
|
|
7
|
+
* Subclasses own their parser and syntax tree.
|
|
8
|
+
* Argument describes that language's argument representation; consumers can use
|
|
9
|
+
* sourceOf() to read its source without inspecting the language's syntax tree.
|
|
10
|
+
*/
|
|
11
|
+
class CodeToken extends AbstractToken_1.AbstractToken {
|
|
12
|
+
/**
|
|
13
|
+
* Preserve the original source and its position in the surrounding expression.
|
|
14
|
+
*/
|
|
15
|
+
constructor(source, start = 0) {
|
|
16
|
+
super(start);
|
|
17
|
+
this.source = source;
|
|
18
|
+
}
|
|
19
|
+
/**
|
|
20
|
+
* Normalize a static reference. Dynamic keys and receivers are not paths.
|
|
21
|
+
*/
|
|
22
|
+
referencePath() {
|
|
23
|
+
return null;
|
|
24
|
+
}
|
|
25
|
+
/**
|
|
26
|
+
* Reproduce the original source, including surrounding whitespace and comments.
|
|
27
|
+
*/
|
|
28
|
+
raw() {
|
|
29
|
+
return this.source;
|
|
30
|
+
}
|
|
31
|
+
}
|
|
32
|
+
exports.CodeToken = CodeToken;
|
|
33
|
+
//# sourceMappingURL=CodeToken.js.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"CodeToken.js","sourceRoot":"","sources":["../../../src/tokens/code/CodeToken.ts"],"names":[],"mappings":";;;AAAA,oDAAiD;AA0BjD;;;;;GAKG;AACH,eAAoD,SAAQ,6BAAa;IACvE;;OAEG;IACH,YACW,MAAc,EACvB,KAAK,GAAG,CAAC;QAET,KAAK,CAAC,KAAK,CAAC,CAAC;sBAHJ,MAAM;IAIjB,CAAC;IAuCD;;OAEG;IACH,aAAa;QACX,OAAO,IAAI,CAAC;IACd,CAAC;IAyED;;OAEG;IACH,GAAG;QACD,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;CACF","sourcesContent":["import { AbstractToken } from '../AbstractToken';\n\n/**\n * An unbound reference or direct call, independent of a language's syntax tree.\n */\nexport interface CodeReference {\n /**\n * The name resolved outside the code's local bindings.\n */\n readonly name: string;\n /**\n * Whether the reference is a direct call rather than a value lookup.\n */\n readonly isCall: boolean;\n /**\n * Call argument source tokens, including any nested reference replacements.\n * Value references have no arguments.\n */\n readonly arguments: readonly AbstractToken[];\n}\n\n/**\n * Static reference segments, independent of the source language.\n */\nexport type ReferencePath = readonly [string, ...(string | number)[]];\n\n/**\n * Original source and executable code for a language-specific token.\n * Subclasses own their parser and syntax tree.\n * Argument describes that language's argument representation; consumers can use\n * sourceOf() to read its source without inspecting the language's syntax tree.\n */\nexport abstract class CodeToken<Argument = unknown> extends AbstractToken {\n /**\n * Preserve the original source and its position in the surrounding expression.\n */\n protected constructor(\n readonly source: string,\n start = 0\n ) {\n super(start);\n }\n\n /**\n * Executable source supplied to the evaluator, without surrounding source trivia.\n */\n abstract readonly code: string;\n\n /**\n * Free identifier names, including direct calls, in first-reference order.\n * Local bindings and non-computed property names are excluded.\n */\n abstract readonly freeIdentifiers: readonly string[];\n /**\n * Arguments of the root call. Requires isCallExpression() to be true.\n */\n abstract readonly arguments: readonly Argument[];\n\n /**\n * Whether the root expression is a function call.\n *\n * @example\n * ```ts\n * new JSToken('save(true)').isCallExpression(); // true\n * new JSToken('ready ? save() : null').isCallExpression(); // false\n * ```\n */\n abstract isCallExpression(): boolean;\n\n /**\n * Whether the root expression identifies a value that can be resolved as shorthand.\n *\n * @example\n * ```ts\n * new JSToken('user.name').isReferenceExpression(); // true\n * new JSToken('count + 1').isReferenceExpression(); // false\n * ```\n */\n abstract isReferenceExpression(): boolean;\n\n /**\n * Normalize a static reference. Dynamic keys and receivers are not paths.\n */\n referencePath(): ReferencePath | null {\n return null;\n }\n\n /**\n * Source of the root call's target. Requires isCallExpression() to be true.\n *\n * @example\n * ```ts\n * new JSToken('worker.save(true)').functionName(); // 'worker.save'\n * ```\n */\n abstract functionName(): string;\n\n /**\n * Original source for an argument belonging to this token, including its delimiters.\n *\n * @example\n * ```ts\n * const token = new JSToken('save((count + 1), true)');\n * token.arguments.map((argument) => token.sourceOf(argument));\n * // ['(count + 1)', 'true']\n * ```\n */\n abstract sourceOf(argument: Argument): string;\n\n /**\n * Return a new token with the root call's target replaced by the supplied source.\n * Requires isCallExpression() to be true; leaves this token unchanged.\n *\n * @example\n * ```ts\n * const token = new JSToken('save(true)');\n * token.withName('worker.persist').raw(); // 'worker.persist(true)'\n * token.raw(); // 'save(true)'\n * ```\n */\n abstract withName(name: string): CodeToken<Argument>;\n\n /**\n * Return a new token with the root call's arguments replaced by language-specific source.\n * Requires isCallExpression() to be true; leaves this token unchanged.\n *\n * @example\n * ```ts\n * new JSToken('save(true)').withArguments(['user.name', 'false']).raw();\n * // 'save(user.name, false)'\n * ```\n */\n abstract withArguments(args: readonly string[]): CodeToken<Argument>;\n\n /**\n * Return a new token after rewriting unbound references and direct calls.\n * Return null from the callback to keep a reference unchanged. Replacement code\n * must be valid in this token's language and is not visited again.\n *\n * @example\n * ```ts\n * const token = new JSToken('user.name + count');\n * const rewritten = token.rewriteReferences((reference) => {\n * if (reference.name === 'count' && !reference.isCall) {\n * return new JSToken('state.total');\n * }\n * return null;\n * });\n * rewritten.raw(); // 'user.name + state.total'\n * ```\n */\n abstract rewriteReferences(rewrite: (reference: CodeReference) => CodeToken | null): CodeToken<Argument>;\n\n /**\n * Copy this token with an independent syntax tree and the same source position.\n */\n abstract clone(): CodeToken<Argument>;\n\n /**\n * Reproduce the original source, including surrounding whitespace and comments.\n */\n raw(): string {\n return this.source;\n }\n}\n"]}
|
|
@@ -0,0 +1,28 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
exports.IdentifierToken = void 0;
|
|
4
|
+
const AbstractToken_1 = require("../AbstractToken");
|
|
5
|
+
/**
|
|
6
|
+
* A single identifier with its original source position.
|
|
7
|
+
*/
|
|
8
|
+
class IdentifierToken extends AbstractToken_1.AbstractToken {
|
|
9
|
+
static isValid(source) {
|
|
10
|
+
return /^[$A-Z_a-z][$\w]*$/.test(source);
|
|
11
|
+
}
|
|
12
|
+
constructor(source, start = 0) {
|
|
13
|
+
super(start);
|
|
14
|
+
this.source = source;
|
|
15
|
+
Object.freeze(this);
|
|
16
|
+
}
|
|
17
|
+
isValid() {
|
|
18
|
+
return IdentifierToken.isValid(this.source);
|
|
19
|
+
}
|
|
20
|
+
raw() {
|
|
21
|
+
return this.source;
|
|
22
|
+
}
|
|
23
|
+
clone() {
|
|
24
|
+
return this;
|
|
25
|
+
}
|
|
26
|
+
}
|
|
27
|
+
exports.IdentifierToken = IdentifierToken;
|
|
28
|
+
//# sourceMappingURL=IdentifierToken.js.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"IdentifierToken.js","sourceRoot":"","sources":["../../../src/tokens/code/IdentifierToken.ts"],"names":[],"mappings":";;;AAAA,oDAAiD;AAEjD;;GAEG;AACH,qBAA6B,SAAQ,6BAAa;IAChD,MAAM,CAAC,OAAO,CAAC,MAAc;QAC3B,OAAO,oBAAoB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC3C,CAAC;IAED,YACW,MAAc,EACvB,KAAK,GAAG,CAAC;QAET,KAAK,CAAC,KAAK,CAAC,CAAC;sBAHJ,MAAM;QAIf,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACtB,CAAC;IAED,OAAO;QACL,OAAO,eAAe,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC9C,CAAC;IAED,GAAG;QACD,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED,KAAK;QACH,OAAO,IAAI,CAAC;IACd,CAAC;CACF","sourcesContent":["import { AbstractToken } from '../AbstractToken';\n\n/**\n * A single identifier with its original source position.\n */\nexport class IdentifierToken extends AbstractToken {\n static isValid(source: string): boolean {\n return /^[$A-Z_a-z][$\\w]*$/.test(source);\n }\n\n constructor(\n readonly source: string,\n start = 0\n ) {\n super(start);\n Object.freeze(this);\n }\n\n isValid(): boolean {\n return IdentifierToken.isValid(this.source);\n }\n\n raw(): string {\n return this.source;\n }\n\n clone(): this {\n return this;\n }\n}\n"]}
|