@comet/admin-generator 8.0.0-beta.1 → 8.0.0-beta.3

package/lib/commands/generate/utils/convertConfigImport.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertConfigImport = convertConfigImport;
+// generated code is one level below config, this function converts relative imports to go one level up
+function convertConfigImport(imprt) {
+    let importPath = imprt.import;
+    if (importPath.startsWith("../")) {
+        importPath = `../${importPath}`;
+    }
+    else if (importPath.startsWith("./")) {
+        importPath = `.${importPath}`;
+    }
+    return { name: imprt.name, importPath };
+}

package/lib/commands/generate/utils/findMutationType.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findMutationTypeOrThrow = exports.findMutationType = void 0;
+exports.findMutationType = findMutationType;
+exports.findMutationTypeOrThrow = findMutationTypeOrThrow;
 function findMutationType(mutationName, schema) {
     if (!schema.__schema.mutationType)
         throw new Error("Schema has no Mutation type");
@@ -9,11 +10,9 @@ function findMutationType(mutationName, schema) {
         throw new Error("Can't find Mutation type in gql schema");
     return queryType.fields.find((field) => field.name === mutationName);
 }
-exports.findMutationType = findMutationType;
 function findMutationTypeOrThrow(mutationName, schema) {
     const ret = findMutationType(mutationName, schema);
     if (!ret)
         throw new Error(`Can't find Mutation ${mutationName} in gql schema`);
     return ret;
 }
-exports.findMutationTypeOrThrow = findMutationTypeOrThrow;

package/lib/commands/generate/utils/findQueryType.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findQueryTypeOrThrow = void 0;
+exports.findQueryTypeOrThrow = findQueryTypeOrThrow;
 function findQueryType(queryName, schema) {
     const queryType = schema.__schema.types.find((type) => type.name === schema.__schema.queryType.name);
     if (!queryType)
@@ -16,4 +16,3 @@ function findQueryTypeOrThrow(queryName, schema) {
         throw new Error(`Can't find query ${queryName} in gql schema`);
     return ret;
 }
-exports.findQueryTypeOrThrow = findQueryTypeOrThrow;

package/lib/commands/generate/utils/findRootBlocks.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findRootBlocks = void 0;
+exports.findRootBlocks = findRootBlocks;
 const fs_1 = require("fs");
 const fallbackLibraryBlocks = {
     AnchorBlock: "@comet/cms-admin",
@@ -64,4 +64,3 @@ function findRootBlocks({ gqlType, targetDirectory }, schema) {
     });
     return ret;
 }
-exports.findRootBlocks = findRootBlocks;

package/lib/commands/generate/utils/generateImportsCode.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateImportsCode = void 0;
+exports.generateImportsCode = generateImportsCode;
 // generate imports code and filter duplicates
 function generateImportsCode(imports) {
     const importsNameToPath = new Map(); // name -> importPath
@@ -24,4 +24,3 @@ function generateImportsCode(imports) {
         .join("\n");
     return importsString;
 }
-exports.generateImportsCode = generateImportsCode;

package/lib/commands/generate/utils/runtimeTypeGuards.d.ts

@@ -0,0 +1,20 @@
+type GeneratorConfigImport = {
+    name: string;
+    import: string;
+};
+/**
+ * Type Guard used by generator runtime for places where runtime vs. configtime types mismatch
+ */
+export declare function isGeneratorConfigImport(value: unknown): value is GeneratorConfigImport;
+type GeneratorConfigCode = {
+    code: string;
+    imports: {
+        name: string;
+        import: string;
+    }[];
+};
+/**
+ * Type Guard used by generator runtime for places where runtime vs. configtime types mismatch
+ */
+export declare function isGeneratorConfigCode(value: unknown): value is GeneratorConfigCode;
+export {};

package/lib/commands/generate/utils/runtimeTypeGuards.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGeneratorConfigImport = isGeneratorConfigImport;
+exports.isGeneratorConfigCode = isGeneratorConfigCode;
+/**
+ * Type Guard used by generator runtime for places where runtime vs. configtime types mismatch
+ */
+function isGeneratorConfigImport(value) {
+    if (value && typeof value === "object" && "import" in value && "name" in value) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Type Guard used by generator runtime for places where runtime vs. configtime types mismatch
+ */
+function isGeneratorConfigCode(value) {
+    if (value && typeof value === "object" && "code" in value && "imports" in value) {
+        return true;
+    }
+    return false;
+}

package/lib/commands/generate/utils/tsMorphHelper.d.ts

@@ -0,0 +1,4 @@
+import { type SourceFile } from "ts-morph";
+import { type GeneratorConfig } from "../generate-command";
+export declare function morphTsSource(path: string): SourceFile;
+export declare function configsFromSourceFile(sourceFile: SourceFile): Record<string, GeneratorConfig>;

package/lib/commands/generate/utils/tsMorphHelper.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.morphTsSource = morphTsSource;
+exports.configsFromSourceFile = configsFromSourceFile;
+const ts_morph_1 = require("ts-morph");
+const project = new ts_morph_1.Project({
+    tsConfigFilePath: "tsconfig.json",
+    skipAddingFilesFromTsConfig: true,
+});
+function morphTsSource(path) {
+    let tsSource = project.getSourceFile(path);
+    if (!tsSource)
+        tsSource = project.addSourceFileAtPath(path);
+    return tsSource;
+}
+const supportedImportPaths = [
+    "[type=grid].columns.filterOperators",
+    "[type=grid].columns.block",
+    "[type=grid].columns.component",
+    // TODO implement in generator "[type=grid].columns.renderCell",
+    //support in up to 5 levels of nested fields (eg. fieldSet)
+    ...Array.from(Array(5).keys()).map((i) => `[type=form]${".fields".repeat(i + 1)}.validate`),
+    ...Array.from(Array(5).keys()).map((i) => `[type=form]${".fields".repeat(i + 1)}.block`),
+    ...Array.from(Array(5).keys()).map((i) => `[type=form]${".fields".repeat(i + 1)}.component`),
+];
+const supportedInlineCodePaths = [
+    // TODO implement in generator "[type=grid].columns.filterOperators",
+    "[type=grid].columns.renderCell",
+    //support in up to 5 levels of nested fields (eg. fieldSet)
+    ...Array.from(Array(5).keys()).map((i) => `[type=form]${".fields".repeat(i + 1)}.validate`),
+];
+function configsFromSourceFile(sourceFile) {
+    const configs = {}; //GeneratorConfig is not fully correct (runtime vs config mismatch), we work around that using type guards
+    for (const [name, declarations] of Array.from(sourceFile.getExportedDeclarations().entries())) {
+        //console.log(name);
+        if (declarations.length != 1) {
+            throw new Error(`Expected exactly one declaration for ${name}`);
+        }
+        const config = exportedDeclarationToJson(declarations[0]);
+        //console.dir(config, { depth: 10 });
+        configs[name] = config;
+    }
+    return configs;
+}
+function findUsedImports(node) {
+    const imports = [];
+    node.getDescendantsOfKind(ts_morph_1.SyntaxKind.Identifier).forEach((identifier) => {
+        var _a;
+        for (const referencedSymbol of identifier.findReferences()) {
+            for (const reference of referencedSymbol.getReferences()) {
+                const referenceNode = reference.getNode();
+                const importDeclaration = referenceNode.getFirstAncestorByKind(ts_morph_1.SyntaxKind.ImportDeclaration);
+                if (importDeclaration) {
+                    for (const namedImport of importDeclaration.getNamedImports()) {
+                        if (((_a = (namedImport.getAliasNode() || namedImport.getNameNode())) === null || _a === void 0 ? void 0 : _a.getText()) == referenceNode.getText()) {
+                            imports.push({
+                                name: namedImport.getNameNode().getText(),
+                                import: importDeclaration.getModuleSpecifierValue(),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    });
+    return imports;
+}
+function getTypePropertyFromObjectLiteral(node) {
+    for (const property of node.getProperties()) {
+        if (property.getKind() == ts_morph_1.SyntaxKind.PropertyAssignment) {
+            const propertyAssignment = property;
+            if (propertyAssignment.getName() == "type") {
+                const propertyAssignmentInitializer = propertyAssignment.getInitializer();
+                if ((propertyAssignmentInitializer === null || propertyAssignmentInitializer === void 0 ? void 0 : propertyAssignmentInitializer.getKind()) == ts_morph_1.SyntaxKind.StringLiteral) {
+                    return propertyAssignmentInitializer.getLiteralValue();
+                }
+            }
+        }
+    }
+    return null;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function astExpressionToJson(node, path) {
+    var _a;
+    if (node.getKind() == ts_morph_1.SyntaxKind.ObjectLiteralExpression) {
+        if (path == "") {
+            // first entry of path is the type, then property names (. separated) are added
+            const typeProperty = getTypePropertyFromObjectLiteral(node);
+            path = typeProperty ? `[type=${typeProperty}]` : "";
+        }
+        const ret = {};
+        for (const property of node.getProperties()) {
+            if (property.getKind() == ts_morph_1.SyntaxKind.PropertyAssignment) {
+                const propertyAssignment = property;
+                const propertyAssignmentInitializer = propertyAssignment.getInitializer();
+                if (propertyAssignmentInitializer) {
+                    ret[propertyAssignment.getName()] = astExpressionToJson(propertyAssignmentInitializer, `${path}.${propertyAssignment.getName()}`);
+                }
+                else {
+                    throw new Error(`Initializer is required for propertyAssignment '${propertyAssignment.getName()}'`);
+                }
+            }
+            else {
+                throw new Error(`Unsupported ObjectLiteralExpression property Kind ${property.getKindName()}`);
+            }
+        }
+        return ret;
+    }
+    else if (node.getKind() == ts_morph_1.SyntaxKind.StringLiteral) {
+        return node.getLiteralValue();
+    }
+    else if (node.getKind() == ts_morph_1.SyntaxKind.NumericLiteral) {
+        return node.getLiteralValue();
+    }
+    else if (node.getKind() == ts_morph_1.SyntaxKind.FalseKeyword) {
+        return false;
+    }
+    else if (node.getKind() == ts_morph_1.SyntaxKind.TrueKeyword) {
+        return true;
+    }
+    else if (node.getKind() == ts_morph_1.SyntaxKind.BinaryExpression) {
+        //what is this?
+        return node.getText();
+    }
+    else if (node.getKind() == ts_morph_1.SyntaxKind.ArrowFunction) {
+        if (supportedInlineCodePaths.includes(path)) {
+            const body = node.getBody();
+            return {
+                code: node.getText(),
+                imports: findUsedImports(body),
+            };
+        }
+        else {
+            throw new Error(`Inline Function is not allowed here and calling the function is not supported: ${path}`);
+        }
+    }
+    else if (node.getKind() == ts_morph_1.SyntaxKind.ArrayLiteralExpression) {
+        const ret = [];
+        for (const element of node.getElements()) {
+            ret.push(astExpressionToJson(element, path));
+        }
+        return ret;
+    }
+    else if (node.getKind() == ts_morph_1.SyntaxKind.Identifier) {
+        for (const referencedSymbol of node.findReferences()) {
+            for (const reference of referencedSymbol.getReferences()) {
+                const referenceNode = reference.getNode();
+                const importDeclaration = referenceNode.getFirstAncestorByKind(ts_morph_1.SyntaxKind.ImportDeclaration);
+                const variableDeclaration = referenceNode.getFirstAncestorByKind(ts_morph_1.SyntaxKind.VariableDeclaration);
+                if (importDeclaration) {
+                    for (const namedImport of importDeclaration.getNamedImports()) {
+                        if (((_a = (namedImport.getAliasNode() || namedImport.getNameNode())) === null || _a === void 0 ? void 0 : _a.getText()) == referenceNode.getText()) {
+                            if (supportedImportPaths.includes(path)) {
+                                return {
+                                    name: namedImport.getNameNode().getText(),
+                                    import: importDeclaration.getModuleSpecifierValue(),
+                                };
+                            }
+                            else {
+                                throw new Error(`Following the import is not supported: ${path} ${namedImport.getText()}`);
+                            }
+                        }
+                    }
+                }
+                else if (variableDeclaration) {
+                    if (variableDeclaration.getName() == node.getText()) {
+                        const variableInitializer = variableDeclaration.getInitializer();
+                        if (variableInitializer) {
+                            return astExpressionToJson(variableInitializer, path);
+                        }
+                        else {
+                            throw new Error(`Initializer is required for variableDeclaration '${variableDeclaration.getName()}'`);
+                        }
+                    }
+                }
+            }
+        }
+        throw new Error(`Unsupported identifier '${node.getText()}', only imports and are variable declarations with initializer are supported`);
+    }
+    else {
+        throw new Error(`Unsupported expression Kind ${node.getKindName()}`);
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function exportedDeclarationToJson(node) {
+    if (node.getKind() == ts_morph_1.SyntaxKind.VariableDeclaration) {
+        const variableDeclaration = node;
+        const initializer = variableDeclaration.getInitializer();
+        if (initializer) {
+            return astExpressionToJson(initializer, "");
+        }
+        else {
+            throw new Error(`Initializer is required for variableDeclaration '${variableDeclaration.getName()}'`);
+        }
+    }
+    else {
+        throw new Error(`Unsupported declaration kind '${node.getKindName()}'`);
+    }
+}

package/lib/commands/generate/utils/writeGenerated.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -31,8 +41,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeGenerated = void 0;
+exports.writeGenerated = writeGenerated;
+const chalk_1 = __importDefault(require("chalk"));
 const eslint_1 = require("eslint");
 const fs_1 = require("fs");
 const path = __importStar(require("path"));
@@ -46,12 +60,25 @@ function writeGenerated(filePath, contents) {
             cwd: process.cwd(),
             fix: true,
         });
+        // Write not linted generated code into file. This is necessary to avoid linting errors like: Parsing error: file/path/file.tsx was not found by the project service.
+        yield fs_1.promises.writeFile(filePath, header + contents);
         const lintResult = yield eslint.lintText(header + contents, {
             filePath,
         });
-        const output = lintResult[0] && lintResult[0].output ? lintResult[0].output : lintResult[0].source;
-        yield fs_1.promises.writeFile(filePath, output !== null && output !== void 0 ? output : contents);
+        if (lintResult[0].errorCount > 0 || lintResult[0].fatalErrorCount > 0) {
+            const errorMessage = lintResult[0].messages
+                .map((message) => {
+                return message.message;
+            })
+                .join(".");
+            console.error(chalk_1.default.red(`Linting error in ${filePath}: \n${errorMessage}`));
+        }
+        else if (lintResult[0].output != null) {
+            yield fs_1.promises.writeFile(filePath, lintResult[0].output);
+        }
+        else {
+            console.error(chalk_1.default.red("No output from linting"));
+        }
         console.log(`generated ${filePath}`);
     });
 }
-exports.writeGenerated = writeGenerated;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comet/admin-generator",
-  "version": "8.0.0-beta.1",
+  "version": "8.0.0-beta.3",
   "repository": {
     "directory": "packages/admin/admin-generator",
     "type": "git",
@@ -19,35 +19,41 @@
   "dependencies": {
     "@graphql-tools/graphql-file-loader": "^7.5.17",
     "@graphql-tools/load": "^7.8.14",
+    "chalk": "^5.4.1",
     "change-case": "^4.1.2",
     "commander": "^9.5.0",
     "glob": "^10.4.5",
     "graphql": "^16.10.0",
     "object-path": "^0.11.8",
     "pluralize": "^8.0.0",
+    "ts-morph": "^25.0.1",
     "ts-node": "^10.9.2"
   },
   "devDependencies": {
-    "@mui/material": "^6.4.6",
-    "@mui/x-data-grid": "^7.27.2",
+    "@mui/material": "^6.4.8",
+    "@mui/x-data-grid": "^7.28.0",
     "@types/jest": "^29.5.14",
-    "@types/node": "^22.13.8",
+    "@types/node": "^22.13.10",
     "@types/object-path": "^0.11.4",
     "@types/pluralize": "^0.0.33",
-    "@types/react": "^18.3.18",
-    "eslint": "^9.20.1",
+    "@types/react": "^18.3.19",
+    "eslint": "^9.22.0",
+    "final-form": "^4.20.10",
     "jest": "^29.7.0",
     "npm-run-all2": "^5.0.2",
     "prettier": "^3.5.3",
     "react": "^18.3.1",
-    "react-intl": "^6.8.9",
+    "react-intl": "^7.1.6",
     "rimraf": "^6.0.1",
     "ts-jest": "^29.2.6",
-    "typescript": "^4.9.5",
-    "@comet/admin": "8.0.0-beta.1",
-    "@comet/admin-icons": "8.0.0-beta.1",
-    "@comet/cms-admin": "8.0.0-beta.1",
-    "@comet/eslint-config": "8.0.0-beta.1"
+    "typescript": "^5.7.3",
+    "@comet/admin": "8.0.0-beta.3",
+    "@comet/admin-icons": "8.0.0-beta.3",
+    "@comet/cms-admin": "8.0.0-beta.3",
+    "@comet/eslint-config": "8.0.0-beta.3"
+  },
+  "engines": {
+    "node": ">=22.0.0"
   },
   "publishConfig": {
     "access": "public",

package/lib/commands/generate/generateGrid/combinationColumn.d.ts

@@ -1,43 +0,0 @@
-import { type GridColDef } from "@comet/admin";
-import { type ComponentProps } from "react";
-import { type FormattedNumber } from "react-intl";
-import { type BaseColumnConfig, type ImportReference } from "../generate-command";
-type AbstractField<FieldName extends string> = {
-    field: FieldName;
-    emptyValue?: string;
-};
-type TextField<FieldName extends string> = AbstractField<FieldName> & {
-    type: "text";
-};
-type StaticText = {
-    type: "static";
-    text: string;
-};
-type FormattedNumberPropsForNumberField = Omit<ComponentProps<typeof FormattedNumber>, "value" | "children">;
-type NumberField<FieldName extends string> = AbstractField<FieldName> & FormattedNumberPropsForNumberField & {
-    type: "number";
-    decimals?: number;
-};
-type StaticSelectField<FieldName extends string> = AbstractField<FieldName> & {
-    type: "staticSelect";
-    values: Array<string | {
-        value: string | number | boolean;
-        label: string;
-    }>;
-};
-type FormattedMessage<FieldName extends string> = {
-    type: "formattedMessage";
-    message: string;
-    valueFields: Record<string, Field<FieldName>>;
-};
-type Field<FieldName extends string> = StaticText | FieldName | TextField<FieldName> | NumberField<FieldName> | StaticSelectField<FieldName> | FormattedMessage<FieldName>;
-export type GridCombinationColumnConfig<FieldName extends string> = {
-    type: "combination";
-    name: string;
-    primaryText?: Field<FieldName>;
-    secondaryText?: Field<FieldName>;
-    filterOperators?: ImportReference;
-} & BaseColumnConfig & Pick<GridColDef, "sortBy">;
-export declare const getCombinationColumnRenderCell: (column: GridCombinationColumnConfig<string>, messageIdPrefix: string) => string;
-export declare const getAllColumnFieldNames: (column: GridCombinationColumnConfig<string>) => string[];
-export {};

package/lib/commands/generate/generateGrid/combinationColumn.js

@@ -1,151 +0,0 @@
-"use strict";
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAllColumnFieldNames = exports.getCombinationColumnRenderCell = void 0;
-const intl_1 = require("../utils/intl");
-const getTextForCellContent = (textConfig, messageIdPrefix) => {
-    if (typeof textConfig !== "string" && textConfig.type === "static") {
-        return {
-            textContent: (0, intl_1.getFormattedMessageNode)(messageIdPrefix, textConfig.text),
-        };
-    }
-    if (typeof textConfig !== "string" && textConfig.type === "formattedMessage") {
-        const variableDefinitions = [];
-        const values = Object.entries(textConfig.valueFields)
-            .map(([key, value]) => {
-            const { textContent, variableDefinitions: cellVariableDefinitions } = getTextForCellContent(value, `${messageIdPrefix}.${key}`);
-            if (cellVariableDefinitions === null || cellVariableDefinitions === void 0 ? void 0 : cellVariableDefinitions.length) {
-                variableDefinitions.push(...cellVariableDefinitions);
-            }
-            return `${key}: ${textContent}`;
-        })
-            .join(", ");
-        return {
-            textContent: (0, intl_1.getFormattedMessageNode)(messageIdPrefix, textConfig.message, `{${values}}`),
-            variableDefinitions,
-        };
-    }
-    const emptyText = typeof textConfig !== "string" && "emptyValue" in textConfig
-        ? (0, intl_1.getFormattedMessageNode)(`${messageIdPrefix}.empty`, textConfig.emptyValue)
-        : "'-'";
-    const fieldName = typeof textConfig === "string" ? textConfig : textConfig.field;
-    const rowValue = `row.${fieldName.replace(/\./g, "?.")}`;
-    const stringTextContent = `${rowValue} ?? ${emptyText}`;
-    if (typeof textConfig === "string") {
-        return {
-            textContent: stringTextContent,
-        };
-    }
-    if (textConfig.type === "number") {
-        const { type, decimals: decimalsConfigValue, field, emptyValue } = textConfig, configForFormattedNumberProps = __rest(textConfig, ["type", "decimals", "field", "emptyValue"]);
-        const hasCurrency = Boolean(textConfig.currency);
-        const hasUnit = Boolean(textConfig.unit);
-        const defaultDecimalsProp = hasCurrency && decimalsConfigValue === undefined ? 2 : decimalsConfigValue;
-        let defaultStyleProp = undefined;
-        if (hasCurrency) {
-            defaultStyleProp = '"currency"';
-        }
-        else if (hasUnit) {
-            defaultStyleProp = '"unit"';
-        }
-        const formattedNumberProps = {
-            value: `{${rowValue}}`,
-            minimumFractionDigits: typeof defaultDecimalsProp !== "undefined" ? `{${defaultDecimalsProp}}` : undefined,
-            maximumFractionDigits: typeof defaultDecimalsProp !== "undefined" ? `{${defaultDecimalsProp}}` : undefined,
-            style: typeof defaultStyleProp !== "undefined" ? defaultStyleProp : undefined,
-        };
-        Object.entries(configForFormattedNumberProps).forEach(([key, value]) => {
-            if (typeof value === "string") {
-                formattedNumberProps[key] = `"${value}"`;
-            }
-            else {
-                formattedNumberProps[key] = `{${value}}`;
-            }
-        });
-        const formattedNumberPropsString = Object.entries(formattedNumberProps)
-            .map(([key, value]) => {
-            if (typeof value === "undefined") {
-                return null;
-            }
-            return `${key}=${value}`;
-        })
-            .join(" ");
-        return {
-            textContent: `typeof ${rowValue} === "undefined" || ${rowValue} === null ? ${emptyText} : <FormattedNumber ${formattedNumberPropsString} />`,
-        };
-    }
-    if (textConfig.type === "staticSelect") {
-        const labelsVariableName = `${textConfig.field}Labels`;
-        const labelMapping = textConfig.values
-            .map((valueOption) => {
-            const value = typeof valueOption === "string" ? valueOption : valueOption.value;
-            const label = typeof valueOption === "string" ? valueOption : valueOption.label;
-            return `${value}: ${(0, intl_1.getFormattedMessageNode)(`${messageIdPrefix}.${value}`, label)}`;
-        })
-            .join(", ");
-        const labelMappingVar = `const ${labelsVariableName}: Record<string, ReactNode> = { ${labelMapping} };`;
-        const textContent = `(${rowValue} == null ? ${emptyText} : ${labelsVariableName}[` + `\`\${${rowValue}}\`` + `] ?? ${rowValue})`;
-        return {
-            textContent,
-            variableDefinitions: [labelMappingVar],
-        };
-    }
-    return {
-        textContent: stringTextContent,
-    };
-};
-const getCombinationColumnRenderCell = (column, messageIdPrefix) => {
-    const gridCellContentProps = {};
-    const allVariableDefinitions = [];
-    if (column.primaryText) {
-        const { textContent, variableDefinitions = [] } = getTextForCellContent(column.primaryText, `${messageIdPrefix}.primaryText`);
-        gridCellContentProps.primaryText = textContent;
-        allVariableDefinitions.push(...variableDefinitions);
-    }
-    if (column.secondaryText) {
-        const { textContent, variableDefinitions = [] } = getTextForCellContent(column.secondaryText, `${messageIdPrefix}.secondaryText`);
-        gridCellContentProps.secondaryText = textContent;
-        allVariableDefinitions.push(...variableDefinitions);
-    }
-    const allUniqueVariableDefinitions = Array.from(new Set(allVariableDefinitions));
-    return `({ row }) => {
-        ${allUniqueVariableDefinitions.join("\n")}
-        return <GridCellContent ${Object.entries(gridCellContentProps)
-        .map(([key, value]) => `${key}={${value}}`)
-        .join(" ")} />;
-    }`;
-};
-exports.getCombinationColumnRenderCell = getCombinationColumnRenderCell;
-const getFieldNamesFromText = (textConfig) => {
-    if (typeof textConfig === "string") {
-        return [textConfig];
-    }
-    if (textConfig.type === "static") {
-        return [];
-    }
-    if (textConfig.type === "formattedMessage") {
-        return Object.values(textConfig.valueFields).flatMap((value) => getFieldNamesFromText(value));
-    }
-    return [textConfig.field];
-};
-const getAllColumnFieldNames = (column) => {
-    const fieldNames = [];
-    if (column.primaryText) {
-        fieldNames.push(...getFieldNamesFromText(column.primaryText));
-    }
-    if (column.secondaryText) {
-        fieldNames.push(...getFieldNamesFromText(column.secondaryText));
-    }
-    return fieldNames.filter((fieldName) => fieldName !== "id");
-};
-exports.getAllColumnFieldNames = getAllColumnFieldNames;