xray16 1.6.2 → 1.6.4

package/README.md

@@ -62,6 +62,7 @@ Plugins can be included in [tstl tsconfig](https://typescripttolua.github.io/doc
       { "name": "xray16/plugins/inject_filename" },
       { "name": "xray16/plugins/from_cast_utils" },
       { "name": "xray16/plugins/optimize_return_ternary" },
+      { "name": "xray16/plugins/inline_constants/plugin" },
       { "name": "xray16/plugins/inject_tracy_zones" }
     ]
   }
@@ -112,6 +113,40 @@ All the calls are completely gets stripped and removed from runtime.
 Plugin rewrites returned ternary expressions into direct `if` / `else` branch returns when it is safe.\
 This avoids temporary result locals for patterns like `return condition ? first : second` while preserving general ternary semantics.
 
+### inline_constants
+
+Plugin that inlines compile-time constants from declarations tagged with `@inline` or `@virtual`.\
+Supported targets are enums, module-level `as const` object literals and module-level scalar constants.\
+Values may be literals or expressions that can be folded at build time: arithmetic, string concatenation,
+template literals and references to other constant declarations.\
+Tagged declarations act as an explicit whitelist and produce build errors when they cannot be inlined.
+
+- `@inline` replaces accesses with literal values but still emits the original declaration, so iteration,
+  reverse mapping and whole-object usages keep working. Import bindings that are no longer used at runtime
+  are stripped; if the target module is proven pure, its `require` is dropped too.
+- `@virtual` includes `@inline` behavior and also removes the declaration from emitted output. Every value
+  reference must be computable at build time. Object spreads of virtual objects are expanded to table literals.
+
+```typescript
+/**
+ * @inline
+ */
+export const medkits = {
+  medkit: "medkit",
+  medkit_army: "medkit_army",
+} as const;
+
+/**
+ * @virtual
+ */
+export const TIMEOUT: number = 60 * 1000;
+
+// Build time: `medkits.medkit_army` access is emitted as plain "medkit_army" string literal.
+// Build time: `TIMEOUT` reference is emitted as 60000 and the declaration is erased from output.
+```
+
+See [src/plugins/inline_constants/README.md](src/plugins/inline_constants/README.md) for full documentation.
+
 ### inject_tracy_zones
 
 Plugin designed to work specifically with [tracy profiler](https://github.com/wolfpld/tracy).\

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xray16",
-  "version": "1.6.2",
+  "version": "1.6.4",
   "author": "Neloreck",
   "repository": "https://github.com/xray-forge/xray-16-types",
   "homepage": "https://xray-forge.github.io/xray-16-types/index.html",
@@ -11,10 +11,11 @@
     "prepublish": "npm run build",
     "prepack": "npm run build",
     "build": "npm run build:plugins && npm run build:types",
-    "build:plugins": "tsc -p ./src/tsconfig.json",
+    "build:plugins": "tsc -p ./src/tsconfig.build.json",
     "build:types": "rollup -c rollup.dts.config.mjs",
     "build:docs": "typedoc",
-    "typecheck": "tsc --noEmit",
+    "test": "jest",
+    "typecheck": "tsc --noEmit && tsc --noEmit -p ./src/tsconfig.json",
     "typedoc": "typedoc",
     "format": "prettier --write \"**/*.(js|ts|tsx|md)\" && eslint . --fix",
     "lint": "eslint ."
@@ -24,6 +25,7 @@
   },
   "devDependencies": {
     "@eslint/js": "^9.39.4",
+    "@types/jest": "^29.5.14",
     "@types/node": "22.10.2",
     "@typescript-eslint/eslint-plugin": "^8.62.0",
     "@typescript-eslint/parser": "^8.62.0",
@@ -34,9 +36,11 @@
     "eslint-plugin-jest": "^29.15.2",
     "eslint-plugin-jsdoc": "^63.0.7",
     "globals": "^17.7.0",
+    "jest": "^29.7.0",
     "prettier": "^3.4.2",
     "rollup": "^4.62.2",
     "rollup-plugin-dts": "^6.4.1",
+    "ts-jest": "^29.4.11",
     "typedoc": "^0.27.5",
     "typescript": "5.7.2",
     "typescript-eslint": "^8.62.0",

package/plugins/inline_constants/plugin.d.ts

@@ -0,0 +1,21 @@
+import { type Plugin } from "typescript-to-lua";
+/**
+ * Plugin that inlines compile-time constants from declarations tagged with `@inline` or `@virtual`.
+ *
+ * Supported targets are enums, module-level `as const` object literals and module-level scalar constants.
+ * Values may be literals or expressions that can be folded at build time: arithmetic, string concatenation,
+ * template literals and references to other constant declarations (enum members, const scalars,
+ * `as const` object properties, whitelisted constants like 'math.pi').
+ *
+ * `@inline` replaces member accesses with literal values while still emitting the original declaration,
+ * so iteration, reverse mapping and whole-object usages keep working. Import bindings with no remaining
+ * runtime usages are stripped; requires of provably pure modules are dropped with them.
+ *
+ * `@virtual` includes `@inline` behavior and also erases the declaration from emitted output. Every
+ * value reference must be computable at build time. Object spreads are expanded to table literals.
+ * Modules containing `@virtual` declarations are validated to be side-effect free.
+ *
+ * Tagged declarations act as an explicit whitelist and produce build errors when they cannot be inlined.
+ */
+declare const plugin: Plugin;
+export default plugin;

package/plugins/inline_constants/plugin.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ts = require("typescript");
+const transformation_1 = require("./transformation");
+/**
+ * Plugin that inlines compile-time constants from declarations tagged with `@inline` or `@virtual`.
+ *
+ * Supported targets are enums, module-level `as const` object literals and module-level scalar constants.
+ * Values may be literals or expressions that can be folded at build time: arithmetic, string concatenation,
+ * template literals and references to other constant declarations (enum members, const scalars,
+ * `as const` object properties, whitelisted constants like 'math.pi').
+ *
+ * `@inline` replaces member accesses with literal values while still emitting the original declaration,
+ * so iteration, reverse mapping and whole-object usages keep working. Import bindings with no remaining
+ * runtime usages are stripped; requires of provably pure modules are dropped with them.
+ *
+ * `@virtual` includes `@inline` behavior and also erases the declaration from emitted output. Every
+ * value reference must be computable at build time. Object spreads are expanded to table literals.
+ * Modules containing `@virtual` declarations are validated to be side-effect free.
+ *
+ * Tagged declarations act as an explicit whitelist and produce build errors when they cannot be inlined.
+ */
+const plugin = {
+    beforeTransform(program) {
+        // Force binder to assign node parents before any 'getJSDocTags' call,
+        // otherwise empty results are computed for parent-less nodes and cached on them forever.
+        program.getTypeChecker();
+        const diagnostics = [...(0, transformation_1.validateTopLevelTags)(program), ...(0, transformation_1.collectVirtualDiagnostics)(program)];
+        if (diagnostics.length > 0) {
+            return diagnostics;
+        }
+    },
+    visitors: {
+        [ts.SyntaxKind.PropertyAccessExpression]: transformation_1.transformAccessExpression,
+        [ts.SyntaxKind.ElementAccessExpression]: transformation_1.transformAccessExpression,
+        [ts.SyntaxKind.Identifier]: transformation_1.transformIdentifierExpression,
+        [ts.SyntaxKind.ImportDeclaration]: transformation_1.transformImportDeclaration,
+        [ts.SyntaxKind.VariableStatement]: (statement, context) => {
+            if ((0, transformation_1.hasInlineTag)(statement)) {
+                (0, transformation_1.validateVariableStatement)(statement, context);
+                if ((0, transformation_1.hasVirtualTag)(statement)) {
+                    return [];
+                }
+            }
+            return context.superTransformStatements(statement);
+        },
+        [ts.SyntaxKind.EnumDeclaration]: (declaration, context) => {
+            if ((0, transformation_1.hasInlineTag)(declaration)) {
+                (0, transformation_1.validateEnumDeclaration)(declaration, context);
+                if ((0, transformation_1.hasVirtualTag)(declaration)) {
+                    return [];
+                }
+            }
+            return context.superTransformStatements(declaration);
+        },
+    },
+};
+exports.default = plugin;

package/plugins/inline_constants/transformation/ast.d.ts

@@ -0,0 +1,69 @@
+import * as ts from "typescript";
+/**
+ * Check whether a node is whitelisted for inlining.
+ * Both `@inline` and `@virtual` enable inlining; `@virtual` adds erasure rules elsewhere.
+ *
+ * @param node - Node to check tags for.
+ * @returns Whether the node is whitelisted for inlining.
+ */
+export declare function hasInlineTag(node: ts.Node): boolean;
+/**
+ * Check whether a node has the `@virtual` JSDoc tag.
+ *
+ * @param node - Node to check tags for.
+ * @returns Whether the node has `@virtual` JSDoc tag.
+ */
+export declare function hasVirtualTag(node: ts.Node): boolean;
+/**
+ * Find the variable statement that contains the provided declaration node.
+ *
+ * @param node - Declaration node to walk up from.
+ * @returns Containing variable statement or null.
+ */
+export declare function getContainingVariableStatement(node: ts.Node): ts.VariableStatement | null;
+/**
+ * Unwrap an initializer expression from `as`, `satisfies`, and parenthesized wrappers.
+ *
+ * @param expression - Initializer expression to unwrap.
+ * @returns Unwrapped expression or null.
+ */
+export declare function unwrapInitializer(expression?: ts.Expression): ts.Expression | null;
+/**
+ * Check whether variable statement is a module-level `const` declaration.
+ *
+ * @param statement - Variable statement to check.
+ * @returns Whether the statement is a module-level const.
+ */
+export declare function isModuleLevelConst(statement: ts.VariableStatement): boolean;
+/**
+ * Check whether an expression is wrapped in an `as const` assertion, possibly through parens/satisfies wrappers.
+ *
+ * @param expression - Expression to check.
+ * @returns Whether the expression has an `as const` assertion.
+ */
+export declare function hasAsConstAssertion(expression?: ts.Expression): boolean;
+/**
+ * Check whether a property is declared inside an `as const` object literal assigned to a module-level const.
+ * Such properties are readonly and cannot be legally reassigned, so their values are stable at runtime.
+ *
+ * @param declaration - Property declaration to check.
+ * @returns Whether property value is safe to fold.
+ */
+export declare function isReadonlyModuleConstProperty(declaration: ts.PropertyAssignment | ts.ShorthandPropertyAssignment): boolean;
+/**
+ * Check whether an identifier is used in a value position where it can be replaced with a literal.
+ *
+ * @param node - Identifier node to check.
+ * @returns Whether the identifier is a replaceable value usage.
+ */
+export declare function isValueUsagePosition(node: ts.Identifier): boolean;
+/**
+ * Get global access path for a runtime-constant engine member declaration.
+ * Qualifying declarations are `static readonly` class members declared inside ambient `declare module "xray16"` -
+ * such values are registered once by the engine and never change at runtime.
+ * The path uses the declared class name, so import aliases do not affect emitted references.
+ *
+ * @param declaration - Declaration to check.
+ * @returns Global access path like ['stalker_ids', 'action_dying'], or null when not a constant engine member.
+ */
+export declare function getEngineConstantPath(declaration: ts.Declaration): Array<string> | null;

package/plugins/inline_constants/transformation/ast.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasInlineTag = hasInlineTag;
+exports.hasVirtualTag = hasVirtualTag;
+exports.getContainingVariableStatement = getContainingVariableStatement;
+exports.unwrapInitializer = unwrapInitializer;
+exports.isModuleLevelConst = isModuleLevelConst;
+exports.hasAsConstAssertion = hasAsConstAssertion;
+exports.isReadonlyModuleConstProperty = isReadonlyModuleConstProperty;
+exports.isValueUsagePosition = isValueUsagePosition;
+exports.getEngineConstantPath = getEngineConstantPath;
+const ts = require("typescript");
+const constants_1 = require("./constants");
+/**
+ * Check whether a node has the provided JSDoc tag.
+ *
+ * @param node - Node to check tags for.
+ * @param tag - Tag name to look for.
+ * @returns Whether the node has the JSDoc tag.
+ */
+function hasJsDocTag(node, tag) {
+    return ts.getJSDocTags(node).some((it) => it.tagName.text === tag);
+}
+/**
+ * Check whether a node is whitelisted for inlining.
+ * Both `@inline` and `@virtual` enable inlining; `@virtual` adds erasure rules elsewhere.
+ *
+ * @param node - Node to check tags for.
+ * @returns Whether the node is whitelisted for inlining.
+ */
+function hasInlineTag(node) {
+    return hasJsDocTag(node, constants_1.INLINE_TAG) || hasJsDocTag(node, constants_1.VIRTUAL_TAG);
+}
+/**
+ * Check whether a node has the `@virtual` JSDoc tag.
+ *
+ * @param node - Node to check tags for.
+ * @returns Whether the node has `@virtual` JSDoc tag.
+ */
+function hasVirtualTag(node) {
+    return hasJsDocTag(node, constants_1.VIRTUAL_TAG);
+}
+/**
+ * Find the variable statement that contains the provided declaration node.
+ *
+ * @param node - Declaration node to walk up from.
+ * @returns Containing variable statement or null.
+ */
+function getContainingVariableStatement(node) {
+    let current = node;
+    while (current !== undefined && !ts.isSourceFile(current)) {
+        if (ts.isVariableStatement(current)) {
+            return current;
+        }
+        current = current.parent;
+    }
+    return null;
+}
+/**
+ * Unwrap an initializer expression from `as`, `satisfies`, and parenthesized wrappers.
+ *
+ * @param expression - Initializer expression to unwrap.
+ * @returns Unwrapped expression or null.
+ */
+function unwrapInitializer(expression) {
+    let current = expression ?? null;
+    while (current !== null &&
+        (ts.isAsExpression(current) ||
+            ts.isSatisfiesExpression(current) ||
+            ts.isParenthesizedExpression(current) ||
+            ts.isTypeAssertionExpression(current))) {
+        current = current.expression;
+    }
+    return current;
+}
+/**
+ * Check whether variable statement is a module-level `const` declaration.
+ *
+ * @param statement - Variable statement to check.
+ * @returns Whether the statement is a module-level const.
+ */
+function isModuleLevelConst(statement) {
+    return ts.isSourceFile(statement.parent) && (statement.declarationList.flags & ts.NodeFlags.Const) !== 0;
+}
+/**
+ * Check whether an expression is wrapped in an `as const` assertion, possibly through parens/satisfies wrappers.
+ *
+ * @param expression - Expression to check.
+ * @returns Whether the expression has an `as const` assertion.
+ */
+function hasAsConstAssertion(expression) {
+    let current = expression;
+    while (current !== undefined) {
+        if (ts.isAsExpression(current) &&
+            ts.isTypeReferenceNode(current.type) &&
+            current.type.typeName.getText() === "const") {
+            return true;
+        }
+        if (ts.isAsExpression(current) || ts.isParenthesizedExpression(current) || ts.isSatisfiesExpression(current)) {
+            current = current.expression;
+        }
+        else {
+            return false;
+        }
+    }
+    return false;
+}
+/**
+ * Check whether a property is declared inside an `as const` object literal assigned to a module-level const.
+ * Such properties are readonly and cannot be legally reassigned, so their values are stable at runtime.
+ *
+ * @param declaration - Property declaration to check.
+ * @returns Whether property value is safe to fold.
+ */
+function isReadonlyModuleConstProperty(declaration) {
+    let sawAsConst = false;
+    let current = declaration.parent;
+    while (current !== undefined && !ts.isVariableDeclaration(current)) {
+        if (ts.isAsExpression(current) &&
+            ts.isTypeReferenceNode(current.type) &&
+            current.type.typeName.getText() === "const") {
+            sawAsConst = true;
+        }
+        if (!ts.isObjectLiteralExpression(current) &&
+            !ts.isPropertyAssignment(current) &&
+            !ts.isAsExpression(current) &&
+            !ts.isParenthesizedExpression(current) &&
+            !ts.isSatisfiesExpression(current)) {
+            return false;
+        }
+        current = current.parent;
+    }
+    if (current === undefined || !sawAsConst) {
+        return false;
+    }
+    const statement = getContainingVariableStatement(current);
+    return statement !== null && isModuleLevelConst(statement);
+}
+/**
+ * Check whether an identifier is used in a value position where it can be replaced with a literal.
+ *
+ * @param node - Identifier node to check.
+ * @returns Whether the identifier is a replaceable value usage.
+ */
+function isValueUsagePosition(node) {
+    const parent = node.parent;
+    if (parent === undefined || ts.isPartOfTypeNode(node)) {
+        return false;
+    }
+    if (ts.isPropertyAccessExpression(parent)) {
+        return parent.expression === node;
+    }
+    if (ts.isPropertyAssignment(parent) ||
+        ts.isBindingElement(parent) ||
+        ts.isParameter(parent) ||
+        ts.isEnumMember(parent) ||
+        ts.isPropertyDeclaration(parent) ||
+        ts.isVariableDeclaration(parent)) {
+        return parent.initializer === node;
+    }
+    if (ts.isShorthandPropertyAssignment(parent) ||
+        ts.isImportSpecifier(parent) ||
+        ts.isImportClause(parent) ||
+        ts.isNamespaceImport(parent) ||
+        ts.isExportSpecifier(parent) ||
+        ts.isNamespaceExport(parent) ||
+        ts.isImportEqualsDeclaration(parent) ||
+        ts.isQualifiedName(parent) ||
+        ts.isLabeledStatement(parent) ||
+        ts.isBreakOrContinueStatement(parent)) {
+        return false;
+    }
+    if (ts.isFunctionDeclaration(parent) ||
+        ts.isFunctionExpression(parent) ||
+        ts.isClassDeclaration(parent) ||
+        ts.isClassExpression(parent) ||
+        ts.isMethodDeclaration(parent) ||
+        ts.isGetAccessorDeclaration(parent) ||
+        ts.isSetAccessorDeclaration(parent) ||
+        ts.isModuleDeclaration(parent) ||
+        ts.isEnumDeclaration(parent) ||
+        ts.isInterfaceDeclaration(parent) ||
+        ts.isTypeAliasDeclaration(parent)) {
+        return parent.name !== node;
+    }
+    return true;
+}
+/**
+ * Get global access path for a runtime-constant engine member declaration.
+ * Qualifying declarations are `static readonly` class members declared inside ambient `declare module "xray16"` -
+ * such values are registered once by the engine and never change at runtime.
+ * The path uses the declared class name, so import aliases do not affect emitted references.
+ *
+ * @param declaration - Declaration to check.
+ * @returns Global access path like ['stalker_ids', 'action_dying'], or null when not a constant engine member.
+ */
+function getEngineConstantPath(declaration) {
+    if (!ts.isPropertyDeclaration(declaration) || !ts.isIdentifier(declaration.name)) {
+        return null;
+    }
+    const modifiers = ts.getModifiers(declaration) ?? [];
+    const isStaticReadonly = modifiers.some((it) => it.kind === ts.SyntaxKind.StaticKeyword) &&
+        modifiers.some((it) => it.kind === ts.SyntaxKind.ReadonlyKeyword);
+    if (!isStaticReadonly) {
+        return null;
+    }
+    const classDeclaration = declaration.parent;
+    if (!ts.isClassDeclaration(classDeclaration) || classDeclaration.name === undefined) {
+        return null;
+    }
+    let current = classDeclaration.parent;
+    while (current !== undefined && !ts.isSourceFile(current)) {
+        if (ts.isModuleDeclaration(current) && ts.isStringLiteral(current.name) && current.name.text === "xray16") {
+            return [classDeclaration.name.text, declaration.name.text];
+        }
+        current = current.parent;
+    }
+    return null;
+}

package/plugins/inline_constants/transformation/constants.d.ts

@@ -0,0 +1,72 @@
+/**
+ * JSDoc tag marking declarations as whitelisted for compile-time inlining.
+ */
+export declare const INLINE_TAG: string;
+/**
+ * JSDoc tag marking declarations for compile-time inlining and erasure from emitted output.
+ * Includes `@inline` behavior and requires every value reference to be erasable.
+ */
+export declare const VIRTUAL_TAG: string;
+/**
+ * Value types that can be inlined as Lua literals.
+ */
+export type TInlineValue = string | number | boolean;
+/**
+ * Reference to a runtime-constant engine value like 'stalker_ids.action_dying'.
+ * Emitted as a global access expression instead of a baked literal, so values stay correct
+ * even when engine builds diverge from the literal types declared in typings.
+ */
+export interface IEngineReference {
+    kind: "engine-ref";
+    path: Array<string>;
+    isNumeric: boolean;
+}
+/**
+ * Binary numeric expression mixing engine references with other folded values.
+ */
+export interface IFoldedBinary {
+    kind: "binary";
+    operator: TFoldedBinaryOperator;
+    left: TFoldedValue;
+    right: TFoldedValue;
+}
+/**
+ * Numeric negation of a folded expression.
+ */
+export interface IFoldedNegation {
+    kind: "negate";
+    operand: TFoldedValue;
+}
+/**
+ * Operators allowed in folded expression trees - restricted to those where emitted Lua matches
+ * tstl lowering exactly. '%', bitwise operators and string concatenation are rejected for trees.
+ */
+export type TFoldedBinaryOperator = "+" | "-" | "*" | "/" | "**";
+/**
+ * Expression parts of folded values that cannot be computed to plain literals at build time.
+ */
+export type TFoldedExpression = IEngineReference | IFoldedBinary | IFoldedNegation;
+/**
+ * Result of build-time folding - either a plain literal or an expression tree with engine references.
+ */
+export type TFoldedValue = TInlineValue | TFoldedExpression;
+/**
+ * Check whether folded value is an expression tree rather than a plain literal.
+ *
+ * @param value - Folded value to check.
+ * @returns Whether value is an expression tree.
+ */
+export declare function isFoldedExpression(value: TFoldedValue): value is TFoldedExpression;
+/**
+ * Check whether folded value is numeric - a number literal or a numeric expression tree.
+ *
+ * @param value - Folded value to check.
+ * @returns Whether value is numeric.
+ */
+export declare function isNumericFoldedValue(value: TFoldedValue): boolean;
+/**
+ * Numeric namespace constants with identical IEEE 754 double values in the build environment and LuaJIT runtime.
+ * Covers both TS 'Math' and Lua 'math' namespaces. Function calls are intentionally not supported because
+ * libm implementations may differ between build machine and game runtime.
+ */
+export declare const FOLDABLE_NAMESPACE_CONSTANTS: Record<string, Record<string, number>>;

package/plugins/inline_constants/transformation/constants.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FOLDABLE_NAMESPACE_CONSTANTS = exports.VIRTUAL_TAG = exports.INLINE_TAG = void 0;
+exports.isFoldedExpression = isFoldedExpression;
+exports.isNumericFoldedValue = isNumericFoldedValue;
+/**
+ * JSDoc tag marking declarations as whitelisted for compile-time inlining.
+ */
+exports.INLINE_TAG = "inline";
+/**
+ * JSDoc tag marking declarations for compile-time inlining and erasure from emitted output.
+ * Includes `@inline` behavior and requires every value reference to be erasable.
+ */
+exports.VIRTUAL_TAG = "virtual";
+/**
+ * Check whether folded value is an expression tree rather than a plain literal.
+ *
+ * @param value - Folded value to check.
+ * @returns Whether value is an expression tree.
+ */
+function isFoldedExpression(value) {
+    return typeof value === "object";
+}
+/**
+ * Check whether folded value is numeric - a number literal or a numeric expression tree.
+ *
+ * @param value - Folded value to check.
+ * @returns Whether value is numeric.
+ */
+function isNumericFoldedValue(value) {
+    if (typeof value === "number") {
+        return true;
+    }
+    if (typeof value === "object") {
+        return value.kind === "engine-ref" ? value.isNumeric : true;
+    }
+    return false;
+}
+/**
+ * Numeric namespace constants with identical IEEE 754 double values in the build environment and LuaJIT runtime.
+ * Covers both TS 'Math' and Lua 'math' namespaces. Function calls are intentionally not supported because
+ * libm implementations may differ between build machine and game runtime.
+ */
+exports.FOLDABLE_NAMESPACE_CONSTANTS = {
+    Math: {
+        E: Math.E,
+        LN10: Math.LN10,
+        LN2: Math.LN2,
+        LOG10E: Math.LOG10E,
+        LOG2E: Math.LOG2E,
+        PI: Math.PI,
+        SQRT1_2: Math.SQRT1_2,
+        SQRT2: Math.SQRT2,
+    },
+    math: {
+        pi: Math.PI,
+    },
+};

package/plugins/inline_constants/transformation/errors.d.ts

@@ -0,0 +1,30 @@
+export declare const createUnsupportedDeclarationError: ((node: import("typescript").Node, ...args: any[]) => import("typescript").Diagnostic) & {
+    code: number;
+};
+export declare const createVirtualValueReferenceError: ((node: import("typescript").Node, name: string) => import("typescript").Diagnostic) & {
+    code: number;
+};
+export declare const createImpureVirtualModuleError: ((node: import("typescript").Node, ...args: any[]) => import("typescript").Diagnostic) & {
+    code: number;
+};
+export declare const createNotModuleLevelError: ((node: import("typescript").Node, ...args: any[]) => import("typescript").Diagnostic) & {
+    code: number;
+};
+export declare const createNotConstError: ((node: import("typescript").Node, ...args: any[]) => import("typescript").Diagnostic) & {
+    code: number;
+};
+export declare const createNotAsConstObjectError: ((node: import("typescript").Node, name: string) => import("typescript").Diagnostic) & {
+    code: number;
+};
+export declare const createNotLiteralConstantError: ((node: import("typescript").Node, name: string) => import("typescript").Diagnostic) & {
+    code: number;
+};
+export declare const createNotLiteralPropertyError: ((node: import("typescript").Node, object: string, property: string) => import("typescript").Diagnostic) & {
+    code: number;
+};
+export declare const createForeignPropertyError: ((node: import("typescript").Node, object: string, property: string) => import("typescript").Diagnostic) & {
+    code: number;
+};
+export declare const createNotConstantEnumMemberError: ((node: import("typescript").Node, name: string) => import("typescript").Diagnostic) & {
+    code: number;
+};

package/plugins/inline_constants/transformation/errors.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNotConstantEnumMemberError = exports.createForeignPropertyError = exports.createNotLiteralPropertyError = exports.createNotLiteralConstantError = exports.createNotAsConstObjectError = exports.createNotConstError = exports.createNotModuleLevelError = exports.createImpureVirtualModuleError = exports.createVirtualValueReferenceError = exports.createUnsupportedDeclarationError = void 0;
+const diagnostics_1 = require("../../utils/diagnostics");
+const constants_1 = require("./constants");
+exports.createUnsupportedDeclarationError = (0, diagnostics_1.createErrorDiagnosticFactory)(`'@${constants_1.INLINE_TAG}' and '@${constants_1.VIRTUAL_TAG}' are supported only for enums and module-level 'const' declarations.`);
+exports.createVirtualValueReferenceError = (0, diagnostics_1.createErrorDiagnosticFactory)((name) => `'@${constants_1.VIRTUAL_TAG}' declaration '${name}' is referenced as a value and cannot be erased, ` +
+    `demote it to '@${constants_1.INLINE_TAG}' or make the reference computable on build time.`);
+exports.createImpureVirtualModuleError = (0, diagnostics_1.createErrorDiagnosticFactory)(`Modules with '@${constants_1.VIRTUAL_TAG}' declarations may contain only type-only imports, ` +
+    `'@${constants_1.INLINE_TAG}'/'@${constants_1.VIRTUAL_TAG}' constants, constant enums, type aliases and interfaces.`);
+exports.createNotModuleLevelError = (0, diagnostics_1.createErrorDiagnosticFactory)(`'@${constants_1.INLINE_TAG}' declarations must be module-level statements.`);
+exports.createNotConstError = (0, diagnostics_1.createErrorDiagnosticFactory)(`'@${constants_1.INLINE_TAG}' declarations must use 'const' keyword.`);
+exports.createNotAsConstObjectError = (0, diagnostics_1.createErrorDiagnosticFactory)((name) => `'@${constants_1.INLINE_TAG}' object '${name}' must use 'as const' assertion.`);
+exports.createNotLiteralConstantError = (0, diagnostics_1.createErrorDiagnosticFactory)((name) => `'@${constants_1.INLINE_TAG}' constant '${name}' must have a compile-time constant value, ` +
+    "use a literal or an expression computable on build time.");
+exports.createNotLiteralPropertyError = (0, diagnostics_1.createErrorDiagnosticFactory)((object, property) => `'@${constants_1.INLINE_TAG}' object '${object}' property '${property}' must have a compile-time constant value, ` +
+    "use a literal or an expression computable on build time.");
+exports.createForeignPropertyError = (0, diagnostics_1.createErrorDiagnosticFactory)((object, property) => `'@${constants_1.INLINE_TAG}' object '${object}' property '${property}' is declared outside of '@${constants_1.INLINE_TAG}' statements, ` +
+    `mark the source declaration with '@${constants_1.INLINE_TAG}' too.`);
+exports.createNotConstantEnumMemberError = (0, diagnostics_1.createErrorDiagnosticFactory)((name) => `'@${constants_1.INLINE_TAG}' enum member '${name}' must have a compile-time constant value.`);