runtypex 0.1.13 → 0.2.1

package/dist/cjs/runtime/mapper.d.ts

@@ -0,0 +1,72 @@
+type Primitive = string | number | boolean | bigint | symbol | null | undefined | Date;
+export type PathOf<T> = T extends Primitive ? never : T extends readonly (infer U)[] ? `${number}` | `${number}.${PathOf<U>}` : {
+    [K in Extract<keyof T, string>]: T[K] extends Primitive ? K : T[K] extends readonly (infer U)[] ? K | `${K}.${number}` | `${K}.${number}.${PathOf<U>}` : K | `${K}.${PathOf<T[K]>}`;
+}[Extract<keyof T, string>];
+export type Mapper<TDto, TDomain> = (dto: TDto) => TDomain;
+export type MapperMetadata<TValue = never> = {
+    db?: string;
+    /** @deprecated Prefer domain property JSDoc for domain field descriptions. */
+    description?: string;
+    dtoDescription?: string;
+    default?: TValue;
+};
+export type MapRule<TDto, TValue> = MapperMetadata<TValue> & {
+    from: PathOf<TDto>;
+    transform?: (value: unknown, dto: TDto) => TValue;
+};
+export type MapSpec<TDto, TDomain> = {
+    [K in keyof TDomain]-?: MapRule<TDto, TDomain[K]>;
+};
+export type MappingPolicy<TDto> = Record<string, MapRule<TDto, unknown>>;
+export type MappingPolicyMode = "warn" | "error";
+export type MapperOptions<TDto> = {
+    policy?: MappingPolicy<TDto>;
+    policyMode?: MappingPolicyMode;
+};
+declare const DTO_TYPE: unique symbol;
+declare const DOMAIN_TYPE: unique symbol;
+export type DefinedMap<TDto, TDomain> = MapSpec<TDto, TDomain> & {
+    readonly [DTO_TYPE]?: TDto;
+    readonly [DOMAIN_TYPE]?: TDomain;
+};
+export declare function defineMap<TDto, TDomain>(): <const TSpec extends MapSpec<TDto, TDomain>>(spec: TSpec) => TSpec & DefinedMap<TDto, TDomain>;
+/** Declares canonical DTO path -> Domain field names for consistency checks. */
+export declare function defineMappingPolicy<TDto>(): <const TSpec extends MappingPolicy<TDto>>(spec: TSpec) => TSpec;
+/** Shorthand rule for direct DTO path reads. */
+export declare function source<const TPath extends string, TValue = never>(from: TPath, metadata?: MapperMetadata<TValue>): {
+    db?: string;
+    description?: string;
+    dtoDescription?: string;
+    default?: TValue | undefined;
+    from: TPath;
+};
+/** Shorthand rule for DTO path reads that require a value conversion. */
+export declare function transform<const TPath extends string, TValue>(from: TPath, transform: (value: unknown, dto: unknown) => TValue, metadata?: MapperMetadata<TValue>): {
+    db?: string;
+    description?: string;
+    dtoDescription?: string;
+    default?: TValue | undefined;
+    from: TPath;
+    transform: (value: unknown, dto: unknown) => TValue;
+};
+/** Typed helpers for callbacks that need access to the source DTO shape. */
+export declare function mapperHelpers<TDto>(): {
+    source: <const TPath extends PathOf<TDto>, TValue = never>(from: TPath, metadata?: MapperMetadata<TValue>) => {
+        db?: string;
+        description?: string;
+        dtoDescription?: string;
+        default?: TValue | undefined;
+        from: TPath;
+    };
+    transform: <const TPath extends PathOf<TDto>, TValue>(from: TPath, transform: (value: unknown, dto: TDto) => TValue, metadata?: MapperMetadata<TValue>) => {
+        db?: string;
+        description?: string;
+        dtoDescription?: string;
+        default?: TValue | undefined;
+        from: TPath;
+        transform: (value: unknown, dto: TDto) => TValue;
+    };
+};
+/** Runtime interpreter used as fallback when the transformer is not configured. */
+export declare function makeMapper<TDto, TDomain>(spec: DefinedMap<TDto, TDomain> | MapSpec<TDto, TDomain>, options?: MapperOptions<TDto>): Mapper<TDto, TDomain>;
+export {};

package/dist/cjs/runtime/mapper.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineMap = defineMap;
+exports.defineMappingPolicy = defineMappingPolicy;
+exports.source = source;
+exports.transform = transform;
+exports.mapperHelpers = mapperHelpers;
+exports.makeMapper = makeMapper;
+const path_js_1 = require("../core/path.js");
+function defineMap() {
+    return (spec) => spec;
+}
+/** Declares canonical DTO path -> Domain field names for consistency checks. */
+function defineMappingPolicy() {
+    return (spec) => spec;
+}
+/** Shorthand rule for direct DTO path reads. */
+function source(from, metadata) {
+    return { from, ...metadata };
+}
+/** Shorthand rule for DTO path reads that require a value conversion. */
+function transform(from, transform, metadata) {
+    return { from, transform, ...metadata };
+}
+/** Typed helpers for callbacks that need access to the source DTO shape. */
+function mapperHelpers() {
+    return {
+        source: (from, metadata) => source(from, metadata),
+        transform: (from, transform, metadata) => ({ from, transform, ...metadata }),
+    };
+}
+/** Runtime interpreter used as fallback when the transformer is not configured. */
+function makeMapper(spec, options) {
+    _handlePolicyViolations(_findPolicyViolations(spec, options?.policy), options?.policyMode ?? "warn");
+    return ((dto) => {
+        const output = {};
+        for (const key of Object.keys(spec)) {
+            const rule = spec[key];
+            const raw = (0, path_js_1.getByPath)(dto, String(rule.from));
+            const value = raw === undefined && _hasOwn(rule, "default") ? rule.default : raw;
+            output[key] = rule.transform ? rule.transform(value, dto) : value;
+        }
+        return output;
+    });
+}
+function _hasOwn(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key);
+}
+function _findPolicyViolations(spec, policy) {
+    if (!policy)
+        return [];
+    const canonicalByPath = new Map();
+    const violations = [];
+    for (const key of Object.keys(policy)) {
+        const from = String(policy[key].from);
+        const existing = canonicalByPath.get(from);
+        if (existing && existing !== key) {
+            violations.push(`DTO path "${from}" is canonically mapped as "${existing}", but this map uses "${key}".`);
+            continue;
+        }
+        canonicalByPath.set(from, key);
+    }
+    violations.push(...Object.keys(spec).flatMap((key) => {
+        const from = String(spec[key].from);
+        const expected = canonicalByPath.get(from);
+        return expected && expected !== key
+            ? [`DTO path "${from}" is canonically mapped as "${expected}", but this map uses "${key}".`]
+            : [];
+    }));
+    return violations;
+}
+function _handlePolicyViolations(violations, mode) {
+    if (!violations.length)
+        return;
+    const message = `[runtypex/mapper] Mapping policy violation:\n${violations.join("\n")}`;
+    if (mode === "error")
+        throw new Error(message);
+    console.warn(message);
+}

package/dist/cjs/runtime/validate.d.ts

@@ -0,0 +1,11 @@
+/**
+ * runtypex — runtime APIs
+ * 1) makeValidate<T>()  : (v) => v is T
+ * 2) makeAssert<T>()    : throws on invalid
+ *
+ * NOTE: These factories are replaced at build-time by the transformer.
+ */
+export type ValidateFn<T> = (value: unknown) => value is T;
+export type AssertFn<T> = (value: unknown) => asserts value is T;
+export declare function makeValidate<T>(): ValidateFn<T>;
+export declare function makeAssert<T>(): AssertFn<T>;

package/dist/cjs/runtime/validate.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeValidate = makeValidate;
+exports.makeAssert = makeAssert;
+// Replaced by transformer to generated guard
+function __validate(_value) {
+    return true;
+}
+function makeValidate() {
+    return (value) => __validate(value);
+}
+function makeAssert() {
+    const validate = makeValidate();
+    return (value) => {
+        if (!validate(value))
+            throw new TypeError("[runtypex] Validation failed.");
+    };
+}

package/dist/cjs/transformer/helper.d.ts

@@ -0,0 +1,2 @@
+import ts from "typescript";
+export declare function resolveTypeByName(program: ts.Program, sf: ts.SourceFile, checker: ts.TypeChecker, name: string): ts.Type | null;

package/dist/cjs/transformer/helper.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTypeByName = resolveTypeByName;
+const typescript_1 = __importDefault(require("typescript"));
+function resolveTypeByName(program, sf, checker, name) {
+    // -1️⃣ Primitive type fallback
+    const primitiveNames = ["string", "number", "boolean", "bigint", "symbol", "null", "undefined"];
+    if (primitiveNames.includes(name)) {
+        const map = {
+            string: checker.getStringType(),
+            number: checker.getNumberType(),
+            boolean: checker.getBooleanType(),
+            bigint: checker.getBigIntType(),
+            symbol: checker.getESSymbolType(),
+            null: checker.getNullType(),
+            undefined: checker.getUndefinedType(),
+        };
+        return map[name];
+    }
+    // 2️⃣ Scan source files
+    for (const file of program.getSourceFiles()) {
+        const decl = _findLocalDeclaration(file, name);
+        if (!decl)
+            continue;
+        // ✅ type, interface, enum, class
+        if (typescript_1.default.isInterfaceDeclaration(decl) ||
+            typescript_1.default.isClassDeclaration(decl) ||
+            typescript_1.default.isEnumDeclaration(decl)) {
+            if (decl.name) {
+                const symbol = checker.getSymbolAtLocation(decl.name);
+                if (symbol)
+                    return checker.getDeclaredTypeOfSymbol(symbol);
+            }
+        }
+        if (typescript_1.default.isTypeAliasDeclaration(decl)) {
+            return checker.getTypeFromTypeNode(decl.type);
+        }
+    }
+    // 3️⃣ Scope-based fallback
+    const symbol = checker
+        .getSymbolsInScope(sf, typescript_1.default.SymbolFlags.Type | typescript_1.default.SymbolFlags.Alias | typescript_1.default.SymbolFlags.Interface)
+        .find((s) => s.name === name);
+    return symbol ? checker.getDeclaredTypeOfSymbol(symbol) : null;
+}
+function _findLocalDeclaration(sf, name) {
+    let found;
+    (function walk(node) {
+        if ((typescript_1.default.isInterfaceDeclaration(node) ||
+            typescript_1.default.isTypeAliasDeclaration(node) ||
+            typescript_1.default.isEnumDeclaration(node) ||
+            typescript_1.default.isClassDeclaration(node)) &&
+            node.name?.text === name) {
+            found = node;
+            return;
+        }
+        if (!found)
+            node.forEachChild(walk);
+    })(sf);
+    return found;
+}

package/dist/cjs/transformer/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from "./ts-transformer.js";
+export { default as tsTransformer } from "./ts-transformer.js";
+export { default as vitePlugin } from "./vite-plugin.js";

package/dist/cjs/transformer/index.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vitePlugin = exports.tsTransformer = exports.default = void 0;
+var ts_transformer_js_1 = require("./ts-transformer.js");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(ts_transformer_js_1).default; } });
+var ts_transformer_js_2 = require("./ts-transformer.js");
+Object.defineProperty(exports, "tsTransformer", { enumerable: true, get: function () { return __importDefault(ts_transformer_js_2).default; } });
+var vite_plugin_js_1 = require("./vite-plugin.js");
+Object.defineProperty(exports, "vitePlugin", { enumerable: true, get: function () { return __importDefault(vite_plugin_js_1).default; } });

package/dist/cjs/transformer/ts-transformer.d.ts

@@ -0,0 +1,29 @@
+import ts from "typescript";
+type TransformerOptions = {
+    program: ts.Program;
+    removeInProd?: boolean;
+    validateDto?: boolean;
+    validateDomain?: boolean;
+};
+/**
+ * 🧩 tsTransformer
+ * TypeScript custom transformer (BEFORE) factory.
+ *
+ * 📘 Usage (ts-loader / ttypescript):
+ * ```ts
+ * getCustomTransformers: (program) => ({
+ *   before: [ tsTransformer({ program, removeInProd: true }) ]
+ * })
+ * ```
+ *
+ * 🧠 Purpose:
+ *  - Replace makeValidate<T>(), makeAssert<T>() calls
+ *    with *pre-generated runtime validation code* derived from T.
+ *
+ * 💡 Effect:
+ *   ✅ No reflection or runtime type parsing
+ *   ✅ Validation logic embedded at build-time
+ *   ✅ Optionally removed in production builds
+ */
+export default function tsTransformer(options: TransformerOptions): ts.TransformerFactory<ts.SourceFile>;
+export {};

package/dist/cjs/transformer/ts-transformer.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = tsTransformer;
+const typescript_1 = __importDefault(require("typescript"));
+const index_js_1 = require("../core/index.js");
+const emitMapperFromSpec_js_1 = require("../core/emitMapperFromSpec.js");
+/**
+ * 🧩 tsTransformer
+ * TypeScript custom transformer (BEFORE) factory.
+ *
+ * 📘 Usage (ts-loader / ttypescript):
+ * ```ts
+ * getCustomTransformers: (program) => ({
+ *   before: [ tsTransformer({ program, removeInProd: true }) ]
+ * })
+ * ```
+ *
+ * 🧠 Purpose:
+ *  - Replace makeValidate<T>(), makeAssert<T>() calls
+ *    with *pre-generated runtime validation code* derived from T.
+ *
+ * 💡 Effect:
+ *   ✅ No reflection or runtime type parsing
+ *   ✅ Validation logic embedded at build-time
+ *   ✅ Optionally removed in production builds
+ */
+function tsTransformer(options) {
+    const checker = options.program.getTypeChecker();
+    const removeInProd = !!options.removeInProd;
+    const prod = process.env.NODE_ENV === "production";
+    return (context) => {
+        const visit = (node) => {
+            if (typescript_1.default.isCallExpression(node) && typescript_1.default.isIdentifier(node.expression)) {
+                const name = node.expression.text;
+                if ((name === "makeValidate" || name === "makeAssert") && node.typeArguments?.length) {
+                    const type = checker.getTypeFromTypeNode(node.typeArguments[0]);
+                    const isRemovedInProd = removeInProd && prod;
+                    switch (name) {
+                        case "makeValidate":
+                            return _emitMakeValidate(checker, type, isRemovedInProd);
+                        case "makeAssert":
+                            return _emitMakeAssert(checker, type, isRemovedInProd);
+                    }
+                }
+                // makeMapper<TDto, TDomain>(spec) becomes an inline validating mapper.
+                if (name === "makeMapper" && node.typeArguments?.length === 2 && node.arguments[0]) {
+                    const mapperCallOptions = _readMapperCallOptions(node.arguments[1]);
+                    const mapper = (0, emitMapperFromSpec_js_1.emitMapperFromSpec)({
+                        checker,
+                        dtoType: checker.getTypeFromTypeNode(node.typeArguments[0]),
+                        domainType: checker.getTypeFromTypeNode(node.typeArguments[1]),
+                        specNode: node.arguments[0],
+                        sourceFile: node.getSourceFile(),
+                        options: {
+                            validateDto: !(removeInProd && prod) && options.validateDto !== false,
+                            validateDomain: !(removeInProd && prod) && options.validateDomain !== false,
+                            mappingPolicy: mapperCallOptions.policy,
+                            policyMode: mapperCallOptions.policyMode,
+                        },
+                    });
+                    if (mapper)
+                        return typescript_1.default.factory.createIdentifier(mapper);
+                }
+            }
+            return typescript_1.default.visitEachChild(node, visit, context);
+        };
+        return (sf) => typescript_1.default.visitNode(sf, visit);
+    };
+}
+function _readMapperCallOptions(node) {
+    if (!node)
+        return {};
+    const expr = typescript_1.default.isAsExpression(node) || typescript_1.default.isParenthesizedExpression(node) ? node.expression : node;
+    if (!typescript_1.default.isObjectLiteralExpression(expr))
+        return {};
+    return {
+        policy: _readExpressionProperty(expr, "policy"),
+        policyMode: _readPolicyMode(expr),
+    };
+}
+function _readExpressionProperty(object, name) {
+    for (const item of object.properties) {
+        if (typescript_1.default.isPropertyAssignment(item) && typescript_1.default.isIdentifier(item.name) && item.name.text === name) {
+            return item.initializer;
+        }
+        if (typescript_1.default.isShorthandPropertyAssignment(item) && item.name.text === name) {
+            return item.name;
+        }
+    }
+    return undefined;
+}
+function _readPolicyMode(object) {
+    const mode = _readExpressionProperty(object, "policyMode");
+    return mode && typescript_1.default.isStringLiteral(mode) && (mode.text === "warn" || mode.text === "error") ? mode.text : undefined;
+}
+function _emitMakeValidate(checker, type, isRemovedInProd) {
+    const guard = isRemovedInProd ? "((_)=>true)" : (0, index_js_1.emitGuardFromType)(checker, type);
+    return typescript_1.default.factory.createIdentifier(guard);
+}
+function _emitMakeAssert(checker, type, isRemovedInProd) {
+    if (isRemovedInProd)
+        return typescript_1.default.factory.createIdentifier("((_)=>{})");
+    const guard = (0, index_js_1.emitGuardFromType)(checker, type);
+    const txt = `(function(){const G=${guard};return(i)=>{if(!G(i))throw new TypeError("[runtypex] Validation failed.");};})()`;
+    return typescript_1.default.factory.createIdentifier(txt);
+}

package/dist/cjs/transformer/vite-plugin.d.ts

@@ -0,0 +1,18 @@
+import type { Plugin } from "vite";
+/**
+ * 🧩 vitePluginRuntypex
+ * A Vite plugin that performs build-time type → runtime validation transformation.
+ *
+ * 📘 Purpose
+ *  - Replace calls like:
+ *      makeValidate<T>(), makeAssert<T>()
+ *    with *inline JavaScript guard functions* derived from TypeScript types.
+ *
+ * 💡 Features
+ *  - Works in both dev & build mode
+ *  - Optional: remove validation code in production (`removeInProd`)
+ *  - Compatible with Rollup / Webpack (via Vite plugin API)
+ */
+export default function vitePluginRuntypex(options?: {
+    removeInProd?: boolean;
+}): Plugin;

package/dist/cjs/transformer/vite-plugin.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = vitePluginRuntypex;
+const typescript_1 = __importDefault(require("typescript"));
+const node_path_1 = __importDefault(require("node:path"));
+const ts_transformer_js_1 = __importDefault(require("./ts-transformer.js"));
+/**
+ * 🧩 vitePluginRuntypex
+ * A Vite plugin that performs build-time type → runtime validation transformation.
+ *
+ * 📘 Purpose
+ *  - Replace calls like:
+ *      makeValidate<T>(), makeAssert<T>()
+ *    with *inline JavaScript guard functions* derived from TypeScript types.
+ *
+ * 💡 Features
+ *  - Works in both dev & build mode
+ *  - Optional: remove validation code in production (`removeInProd`)
+ *  - Compatible with Rollup / Webpack (via Vite plugin API)
+ */
+function vitePluginRuntypex(options) {
+    const removeInProd = !!options?.removeInProd;
+    return {
+        name: "vite-plugin-runtypex",
+        enforce: "pre",
+        transform(code, id) {
+            const isTS = id.endsWith(".ts") || id.endsWith(".tsx");
+            const isTargetFunction = /make(?:Validate|Assert|Mapper)</.test(code);
+            if (!isTS || !isTargetFunction)
+                return;
+            const { program } = _createProgramFor(id);
+            const sf = program.getSourceFile(id);
+            if (!sf)
+                return;
+            const result = typescript_1.default.transform(sf, [(0, ts_transformer_js_1.default)({ program, removeInProd })]);
+            const mutated = typescript_1.default.createPrinter().printFile(result.transformed[0]);
+            result.dispose();
+            return mutated === code ? null : { code: mutated, map: null };
+        },
+    };
+}
+// ──────────────────────────────────────────────
+// ① createProgram & TypeChecker
+// ──────────────────────────────────────────────
+function _createProgramFor(file) {
+    const tsconfig = _findNearestTsconfig(node_path_1.default.dirname(file));
+    const cfg = typescript_1.default.readConfigFile(tsconfig, typescript_1.default.sys.readFile);
+    if (cfg.error)
+        throw new Error(typescript_1.default.flattenDiagnosticMessageText(cfg.error.messageText, "\n"));
+    const parsed = typescript_1.default.parseJsonConfigFileContent(cfg.config, typescript_1.default.sys, node_path_1.default.dirname(tsconfig));
+    const program = typescript_1.default.createProgram({ rootNames: parsed.fileNames, options: parsed.options });
+    return { program };
+}
+function _findNearestTsconfig(start) {
+    let dir = start;
+    while (true) {
+        const candidate = node_path_1.default.join(dir, "tsconfig.json");
+        if (typescript_1.default.sys.fileExists(candidate))
+            return candidate;
+        const parent = node_path_1.default.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    const fallback = node_path_1.default.join(process.cwd(), "tsconfig.json");
+    if (typescript_1.default.sys.fileExists(fallback))
+        return fallback;
+    throw new Error("tsconfig.json not found");
+}

package/dist/esm/core/emitArrayOrTuple.d.ts

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import type { GenContext } from "./index";
+import type { GenContext } from "./index.js";
 /**
  * Handles array (T[]) and tuple ([A, B]) types.
  */

package/dist/esm/core/emitLiteralOrEnum.d.ts

@@ -1,4 +1,4 @@
 import ts from "typescript";
-import type { GenContext } from "./index";
+import type { GenContext } from "./index.js";
 /** Handles literal types and enum-like types. */
 export declare function emitLiteralOrEnum(_: GenContext, expr: string, t: ts.Type): string | null;

package/dist/esm/core/emitMapperFromSpec.d.ts

@@ -0,0 +1,33 @@
+import ts from "typescript";
+export type MapperEmitOptions = {
+    validateDto?: boolean;
+    validateDomain?: boolean;
+    mappingPolicy?: ts.Expression;
+    policyMode?: "warn" | "error";
+};
+export type MapRuleInfo = {
+    key: string;
+    from: string;
+    db?: string;
+    /** @deprecated Prefer domain property JSDoc for domain field descriptions. */
+    description?: string;
+    dtoDescription?: string;
+};
+export declare function emitMapperFromSpec(params: {
+    checker: ts.TypeChecker;
+    dtoType: ts.Type;
+    domainType: ts.Type;
+    specNode: ts.Expression;
+    sourceFile: ts.SourceFile;
+    options?: MapperEmitOptions;
+}): string | null;
+export declare function readMapRules(checker: ts.TypeChecker, specNode: ts.Expression): Map<string, MapRuleInfo>;
+export type MapPolicyViolation = {
+    from: string;
+    expectedKey: string;
+    actualKey: string;
+};
+export declare function findMapPolicyViolations(checker: ts.TypeChecker, specNode: ts.Expression, policyNode: ts.Expression | undefined): MapPolicyViolation[];
+export declare function handleMapPolicyViolations(violations: MapPolicyViolation[], mode: "warn" | "error"): void;
+/** Finds the mapping object behind inline, defineMap-wrapped, or identifier specs. */
+export declare function resolveMapSpecObject(checker: ts.TypeChecker, node: ts.Expression): ts.ObjectLiteralExpression | null;