☰

Microsoft Power Platform/Dynamics 365 CE - Generate TypeScript Definitions

Automatically creates TypeScript type definitions compatible with @types/xrm by extracting form attributes and controls from Dynamics 365/Power Platform model-driven applications.

  1. // ==UserScript==
  2. // @name         Microsoft Power Platform/Dynamics 365 CE - Generate TypeScript Definitions
  3. // @namespace    https://github.com/gncnpk/xrm-generate-ts-overloads
  4. // @author       Gavin Canon-Phratsachack (https://github.com/gncnpk)
  5. // @version      1.998
  6. // @license      MIT
  7. // @description  Automatically creates TypeScript type definitions compatible with @types/xrm by extracting form attributes and controls from Dynamics 365/Power Platform model-driven applications.
  8. // @match        https://*.dynamics.com/main.aspx?appid=*&pagetype=entityrecord&etn=*&id=*
  9. // @grant        none
  10. // ==/UserScript==
  11.  
  12. (function () {
  13.   "use strict";
  14.  
  15.   const groupItemsByType = (items) => {
  16.     return Object.entries(items).reduce((acc, [itemName, itemType]) => {
  17.       if (!acc[itemType]) {
  18.         acc[itemType] = [];
  19.       }
  20.       acc[itemType].push(itemName);
  21.       return acc;
  22.     }, {});
  23.   };
  24.   const stripNonAlphaNumeric = (str) => {
  25.     return str.replace(/\W/g, "");
  26.   };
  27.   // Create a button element and style it to be fixed in the bottom-right corner.
  28.   const btn = document.createElement("button");
  29.   btn.textContent = "Generate TypeScript Definitions";
  30.   btn.style.position = "fixed";
  31.   btn.style.bottom = "20px";
  32.   btn.style.right = "20px";
  33.   btn.style.padding = "10px";
  34.   btn.style.backgroundColor = "#007ACC";
  35.   btn.style.color = "#fff";
  36.   btn.style.border = "none";
  37.   btn.style.borderRadius = "5px";
  38.   btn.style.cursor = "pointer";
  39.   btn.style.zIndex = 10000;
  40.   document.body.appendChild(btn);
  41.  
  42.   btn.addEventListener("click", () => {
  43.     // Mapping objects for Xrm attribute and control types.
  44.     var attributeTypeMapping = {
  45.       boolean: "Xrm.Attributes.BooleanAttribute",
  46.       datetime: "Xrm.Attributes.DateAttribute",
  47.       decimal: "Xrm.Attributes.NumberAttribute",
  48.       double: "Xrm.Attributes.NumberAttribute",
  49.       integer: "Xrm.Attributes.NumberAttribute",
  50.       lookup: "Xrm.Attributes.LookupAttribute",
  51.       memo: "Xrm.Attributes.StringAttribute",
  52.       money: "Xrm.Attributes.NumberAttribute",
  53.       multiselectoptionset: "Xrm.Attributes.MultiselectOptionSetAttribute",
  54.       optionset: "Xrm.Attributes.OptionSetAttribute",
  55.       string: "Xrm.Attributes.StringAttribute",
  56.     };
  57.  
  58.     var controlTypeMapping = {
  59.       standard: "Xrm.Controls.StandardControl",
  60.       iframe: "Xrm.Controls.IframeControl",
  61.       lookup: "Xrm.Controls.LookupControl",
  62.       optionset: "Xrm.Controls.OptionSetControl",
  63.       "customsubgrid:MscrmControls.Grid.GridControl":
  64.         "Xrm.Controls.GridControl",
  65.       subgrid: "Xrm.Controls.GridControl",
  66.       timelinewall: "Xrm.Controls.TimelineWall",
  67.       quickform: "Xrm.Controls.QuickFormControl",
  68.       formcomponent: "Xrm.FormContext",
  69.     };
  70.  
  71.     var specificControlTypeMapping = {
  72.       boolean: "Xrm.Controls.BooleanControl",
  73.       datetime: "Xrm.Controls.DateControl",
  74.       decimal: "Xrm.Controls.NumberControl",
  75.       double: "Xrm.Controls.NumberControl",
  76.       integer: "Xrm.Controls.NumberControl",
  77.       lookup: "Xrm.Controls.LookupControl",
  78.       memo: "Xrm.Controls.StringControl",
  79.       money: "Xrm.Controls.NumberControl",
  80.       multiselectoptionset: "Xrm.Controls.MultiselectOptionSetControl",
  81.       optionset: "Xrm.Controls.OptionSetControl",
  82.       string: "Xrm.Controls.StringControl",
  83.     };
  84.  
  85.     // Object to hold the type information.
  86.     const typeInfo = {
  87.       subGrids: {},
  88.       quickViews: {},
  89.       formAttributes: {},
  90.       formControls: {},
  91.       subForms: {},
  92.       possibleEnums: [],
  93.       formTabs: {},
  94.       formEnums: {},
  95.     };
  96.  
  97.     class Form {
  98.       constructor() {
  99.         this.attributes = {};
  100.         this.controls = {};
  101.         this.enums = {};
  102.         this.subGrids = {};
  103.         this.quickViews = {};
  104.       }
  105.     }
  106.     class Subgrid {
  107.       constructor() {
  108.         this.attributes = {};
  109.         this.enums = {};
  110.       }
  111.     }
  112.     class QuickForm {
  113.       constructor() {
  114.         this.attributes = {};
  115.         this.controls = {};
  116.         this.enums = {};
  117.       }
  118.     }
  119.  
  120.     class Tab {
  121.       constructor() {
  122.         this.sections = {};
  123.       }
  124.     }
  125.  
  126.     const currentFormName = stripNonAlphaNumeric(
  127.       Xrm.Page.ui.formSelector.getCurrentItem().getLabel()
  128.     );
  129.  
  130.     // Loop through all controls on the form.
  131.     function getControls(formContext, controlObject) {
  132.       if (
  133.         typeof formContext !== "undefined" &&
  134.         formContext &&
  135.         typeof formContext.getControl === "function"
  136.       ) {
  137.         formContext.getControl().forEach((ctrl) => {
  138.           const ctrlType = ctrl.getControlType();
  139.           const mappedType = controlTypeMapping[ctrlType];
  140.           if (mappedType) {
  141.             controlObject[ctrl.getName()] = mappedType;
  142.           }
  143.         });
  144.       } else {
  145.         alert("Xrm.Page is not available on this page.");
  146.         return;
  147.       }
  148.     }
  149.  
  150.     getControls(Xrm.Page, typeInfo.formControls);
  151.  
  152.     // Loop through all tabs and sections on the form.
  153.     if (typeof Xrm.Page.ui.tabs.get === "function") {
  154.       Xrm.Page.ui.tabs.get().forEach((tab) => {
  155.         let formTab = (typeInfo.formTabs[stripNonAlphaNumeric(tab.getName())] =
  156.           new Tab());
  157.         tab.sections.forEach((section) => {
  158.           formTab.sections[
  159.             stripNonAlphaNumeric(section.getName())
  160.           ] = `${stripNonAlphaNumeric(section.getName())}_section`;
  161.         });
  162.       });
  163.     }
  164.  
  165.     // Loop through all attributes on the form.
  166.     function getAttributes(
  167.       formContext,
  168.       attributesObject,
  169.       controlsObject,
  170.       enumsObject
  171.     ) {
  172.       if (typeof formContext.getAttribute === "function") {
  173.         formContext.getAttribute().forEach((attr) => {
  174.           const attrType = attr.getAttributeType();
  175.           const attrName = attr.getName();
  176.           const mappedType = attributeTypeMapping[attrType];
  177.           const mappedControlType = specificControlTypeMapping[attrType];
  178.           if (mappedType) {
  179.             attributesObject[attrName] = mappedType;
  180.             attr.controls.forEach((ctrl) => {
  181.               controlsObject[ctrl.getName()] = mappedControlType;
  182.             });
  183.           }
  184.           if (
  185.             attr.getAttributeType() === "optionset" &&
  186.             attr.controls.get().length > 0
  187.           ) {
  188.             const enumValues = attr.getOptions();
  189.             if (enumValues) {
  190.               enumsObject[attrName] = { attribute: "", values: [] };
  191.               enumsObject[attrName].values = enumValues;
  192.               enumsObject[attrName].attribute = attrName;
  193.               attributesObject[attrName] = `${attrName}_attribute`;
  194.             }
  195.           }
  196.         });
  197.       }
  198.     }
  199.     getAttributes(
  200.       Xrm.Page,
  201.       typeInfo.formAttributes,
  202.       typeInfo.formControls,
  203.       typeInfo.formEnums
  204.     );
  205.  
  206.     // Loop through all subgrids on the form.
  207.     function getSubGrids(formContext, subGridsObject, controlsObject) {
  208.       if (typeof formContext.getControl === "function") {
  209.         formContext.getControl().forEach((ctrl) => {
  210.           if (
  211.             ctrl.getControlType() === "subgrid" ||
  212.             ctrl.getControlType() ===
  213.               "customsubgrid:MscrmControls.Grid.GridControl"
  214.           ) {
  215.             const gridRow = ctrl.getGrid().getRows().get(0);
  216.             const gridName = ctrl.getName();
  217.             let subgrid = (subGridsObject[gridName] = new Subgrid());
  218.             controlsObject[gridName] = `${gridName}_gridcontrol`;
  219.             if (gridRow !== null) {
  220.               gridRow.data.entity.attributes.forEach((attr) => {
  221.                 const attrType = attr.getAttributeType();
  222.                 const attrName = attr.getName();
  223.                 const mappedType = attributeTypeMapping[attrType];
  224.                 if (mappedType) {
  225.                   subgrid.attributes[attrName] = mappedType;
  226.                 }
  227.                 if (
  228.                   attr.getAttributeType() === "optionset" &&
  229.                   attr.controls.get().length > 0
  230.                 ) {
  231.                   const enumValues = attr.getOptions();
  232.                   if (enumValues) {
  233.                     subgrid.enums[attrName] = { attribute: "", values: [] };
  234.                     subgrid.enums[attrName].values = enumValues;
  235.                     subgrid.enums[attrName].attribute = attrName;
  236.                     subgrid.attributes[attrName] = `${attrName}_attribute`;
  237.                   }
  238.                 }
  239.               });
  240.             }
  241.           }
  242.         });
  243.       }
  244.     }
  245.     getSubGrids(Xrm.Page, typeInfo.subGrids, typeInfo.formControls);
  246.  
  247.     if (typeof Xrm.Page.getControl === "function") {
  248.       Xrm.Page.getControl().forEach((ctrl) => {
  249.         if (ctrl.getControlType() === "formcomponent") {
  250.           let formObject = (typeInfo.subForms[`${ctrl.getName()}`] =
  251.             new Form());
  252.           try {
  253.             getControls(ctrl, formObject.controls);
  254.             getAttributes(
  255.               ctrl,
  256.               formObject.attributes,
  257.               formObject.controls,
  258.               formObject.enums
  259.             );
  260.             getSubGrids(ctrl, formObject.subGrids, formObject.controls);
  261.             getQuickViews(ctrl, formObject.quickViews, formObject.controls);
  262.           } catch {}
  263.         }
  264.       });
  265.     }
  266.     function generateEnums(possibleEnums, enumsObject) {
  267.       for (const [originalEnumName, enumValues] of Object.entries(
  268.         enumsObject
  269.       )) {
  270.         if (possibleEnums.includes(originalEnumName)) {
  271.           continue;
  272.         }
  273.         possibleEnums.push(originalEnumName);
  274.         let enumName = `${originalEnumName}_enum`;
  275.         let enumTemplate = [];
  276.         let textLiteralTypes = [];
  277.         let valueLiteralTypes = [];
  278.         for (const enumValue of enumValues.values) {
  279.           enumTemplate.push(
  280.             `   ${enumValue.text.replace(/\W/g, "").replace(/[0-9]/g, "")} = ${
  281.               enumValue.value
  282.             }`
  283.           );
  284.           textLiteralTypes.push(`"${enumValue.text}"`);
  285.           valueLiteralTypes.push(
  286.             `${enumName}.${enumValue.text
  287.               .replace(/\W/g, "")
  288.               .replace(/[0-9]/g, "")}`
  289.           );
  290.         }
  291.         outputTS += `
  292. const enum ${enumName} {
  293. ${enumTemplate.join(",\n")}
  294. }
  295. `;
  296.         outputTS += `
  297. interface ${enumValues.attribute}_value extends Xrm.OptionSetValue {
  298. text: ${textLiteralTypes.join(" | ")};
  299. value: ${valueLiteralTypes.join(" | ")};  
  300. }
  301. `;
  302.         outputTS += `
  303. interface ${enumValues.attribute}_attribute extends Xrm.Attributes.OptionSetAttribute<${enumName}> {
  304.    `;
  305.         valueLiteralTypes.forEach((value, index) => {
  306.           outputTS += `getOption(value: ${value}): {text: ${textLiteralTypes[index]}, value: ${value}};\n`;
  307.         });
  308.         outputTS += `getOption(value: ${enumValues.attribute}_value['value']): ${enumValues.attribute}_value | null;
  309.   getOptions(): ${enumValues.attribute}_value[];
  310.   getSelectedOption(): ${enumValues.attribute}_value | null;
  311.   getValue(): ${enumName} | null;
  312.   setValue(value: ${enumName} | null): void;
  313.   getText(): ${enumValues.attribute}_value['text'] | null;
  314. }
  315. `;
  316.       }
  317.     }
  318.  
  319.     function generateLiteralsTypesUnionsAndCollection(
  320.       unionAndCollectionName,
  321.       literalsAndTypesObject,
  322.       defaultType = "unknown",
  323.       generateCollection = true,
  324.       useLiteralAndAppendToType = ""
  325.     ) {
  326.       if (generateCollection) {
  327.         outputTS += `
  328.   interface ${unionAndCollectionName} extends Xrm.Collection.ItemCollection<${unionAndCollectionName}_types> {`;
  329.         if (useLiteralAndAppendToType) {
  330.           for (const [literal, type] of Object.entries(
  331.             literalsAndTypesObject
  332.           )) {
  333.             outputTS += `get(itemName: "${literal}"): ${literal}${useLiteralAndAppendToType};\n`;
  334.           }
  335.         } else {
  336.           for (const [type, literal] of Object.entries(
  337.             groupItemsByType(literalsAndTypesObject)
  338.           )) {
  339.             outputTS += `get(itemName: "${literal.join('" | "')}"): ${type};\n`;
  340.           }
  341.         }
  342.         outputTS += `
  343.       get(itemName: ${unionAndCollectionName}_literals): ${unionAndCollectionName}_types;
  344.       get(itemNameOrIndex: string | number): ${unionAndCollectionName} | null;
  345.       get(delegate?): ${unionAndCollectionName}_types[];
  346.       }
  347.   `;
  348.       }
  349.       if (useLiteralAndAppendToType) {
  350.         outputTS += `
  351.   type ${unionAndCollectionName}_types = ${new Set(
  352.           Object.keys(literalsAndTypesObject)
  353.         )
  354.           .map((literal) => `${literal}${useLiteralAndAppendToType}`)
  355.           .join(" | ")}${
  356.           Object.keys(literalsAndTypesObject).length === 0 ? defaultType : ""
  357.         };\n`;
  358.       } else {
  359.         outputTS += `
  360.   type ${unionAndCollectionName}_types = ${new Set(
  361.           Object.values(literalsAndTypesObject)
  362.         )
  363.           .map((type) => `${type}`)
  364.           .join(" | ")}${
  365.           Object.keys(literalsAndTypesObject).length === 0 ? defaultType : ""
  366.         };\n`;
  367.       }
  368.  
  369.       outputTS += `
  370.   type ${unionAndCollectionName}_literals = ${new Set(
  371.         Object.keys(literalsAndTypesObject)
  372.       )
  373.         .map((literal) => `"${literal}"`)
  374.         .join(" | ")}${
  375.         Object.keys(literalsAndTypesObject).length === 0 ? '""' : ""
  376.       };\n`;
  377.     }
  378.  
  379.     function generateSubgridTypes(subgridName) {
  380.       outputTS += `
  381.   interface ${subgridName}_entity extends Xrm.Entity {
  382.     attributes: ${subgridName}_attributes;
  383.   }
  384.   interface ${subgridName}_data extends Xrm.Data {
  385.     entity: ${subgridName}_entity;
  386.   }
  387.   
  388.   interface ${subgridName}_gridrow extends Xrm.Controls.Grid.GridRow {
  389.     data: ${subgridName}_data;
  390.   }
  391.   
  392.   interface ${subgridName}_grid extends Xrm.Controls.Grid {
  393.     getRows(): Xrm.Collection.ItemCollection<${subgridName}_gridrow>;
  394.   }
  395.   
  396.   interface ${subgridName}_gridcontrol extends Xrm.Controls.GridControl {
  397.     getGrid(): ${subgridName}_grid;
  398.   }`;
  399.     }
  400.     function generateContext(
  401.       formName,
  402.       contextType,
  403.       attributesObject,
  404.       controlsObject,
  405.       uiType = null
  406.     ) {
  407.       let contextSuffix;
  408.       if (contextType === "Xrm.FormContext") {
  409.         contextSuffix = `context`;
  410.       } else if (contextType === "Xrm.Controls.QuickFormControl") {
  411.         contextSuffix = `quickformcontrol`;
  412.       }
  413.       outputTS += `
  414.       interface ${formName}_${contextSuffix} extends ${contextType} {`;
  415.       if (uiType) {
  416.         outputTS += `ui: ${uiType};`;
  417.       }
  418.       if (attributesObject) {
  419.         for (const [attrType, attrNames] of Object.entries(
  420.           groupItemsByType(attributesObject)
  421.         )) {
  422.           outputTS += `getAttribute(attributeName: "${attrNames.join(
  423.             '" | "'
  424.           )}"): ${attrType};\n`;
  425.         }
  426.         outputTS += `getAttribute(attributeName: ${formName}_attributes_literals): ${formName}_attributes_types;`;
  427.         outputTS += `getAttribute(attributeNameOrIndex: string | number): Xrm.Attributes.Attribute | null;`;
  428.         outputTS += `getAttribute(delegateFunction?): ${formName}_attributes[];`;
  429.       }
  430.       if (controlsObject) {
  431.         for (const [controlType, controlNames] of Object.entries(
  432.           groupItemsByType(controlsObject)
  433.         )) {
  434.           outputTS += `getControl(controlName: "${controlNames.join(
  435.             '" | "'
  436.           )}"): ${controlType};\n`;
  437.         }
  438.         outputTS += `getControl(controlName: ${formName}_controls_literals): ${formName}_controls_types;`;
  439.         outputTS += `getControl(controlNameOrIndex: string | number): Xrm.Controls.Control | null;`;
  440.         outputTS += `getControl(delegateFunction?): ${formName}_controls_types[];`;
  441.       }
  442.       outputTS += `}`;
  443.       outputTS += `
  444.   interface ${formName}_eventcontext extends Xrm.Events.EventContext {
  445.     getFormContext(): ${formName}_${contextSuffix};
  446. }`;
  447.     }
  448.     // Loop through all Quick View controls and attributes on the form.
  449.     function getQuickViews(formContext, quickViewsObject, controlsObject) {
  450.       if (typeof formContext.ui.quickForms.get === "function") {
  451.         formContext.ui.quickForms.get().forEach((ctrl) => {
  452.           const quickViewName = ctrl.getName();
  453.           let quickView = (quickViewsObject[quickViewName] = new QuickForm());
  454.           controlsObject[quickViewName] = `${quickViewName}_quickformcontrol`;
  455.           ctrl.getControl().forEach((subCtrl) => {
  456.             if (typeof subCtrl.getAttribute !== "function") {
  457.               return;
  458.             }
  459.             const subCtrlAttrType = subCtrl.getAttribute().getAttributeType();
  460.             const mappedControlType =
  461.               specificControlTypeMapping[subCtrlAttrType] ??
  462.               controlTypeMapping[subCtrl.getControlType()];
  463.             if (mappedControlType) {
  464.               quickView.controls[subCtrl.getName()] = mappedControlType;
  465.             }
  466.           });
  467.           ctrl.getAttribute().forEach((attr) => {
  468.             const attrType = attr.getAttributeType();
  469.             const attrName = attr.getName();
  470.             const mappedType = attributeTypeMapping[attrType];
  471.             if (mappedType) {
  472.               quickView.attributes[attrName] = mappedType;
  473.             }
  474.             if (attrType === "optionset" && attr.controls.get().length > 0) {
  475.               const enumValues = attr.getOptions();
  476.               if (enumValues) {
  477.                 quickView.enums[attrName] = { attribute: "", values: [] };
  478.                 quickView.enums[attrName].values = enumValues;
  479.                 quickView.enums[attrName].attribute = attrName;
  480.                 quickView.attributes[attrName] = `${attrName}_attribute`;
  481.               }
  482.             }
  483.           });
  484.         });
  485.       }
  486.     }
  487.     getQuickViews(Xrm.Page, typeInfo.quickViews, typeInfo.formControls);
  488.  
  489.     // Build the TypeScript overload string.
  490.     let outputTS = `// These TypeScript definitions were generated automatically on: ${new Date().toDateString()}\n`;
  491.     generateEnums(typeInfo.possibleEnums, typeInfo.formEnums);
  492.     for (let [subgridName, subgrid] of Object.entries(typeInfo.subGrids)) {
  493.       subgridName = subgridName.replace(/\W/g, "");
  494.       generateEnums(typeInfo.possibleEnums, subgrid.enums);
  495.       generateLiteralsTypesUnionsAndCollection(
  496.         `${subgridName}_attributes`,
  497.         subgrid.attributes,
  498.         "Xrm.Attributes.Attribute",
  499.         true
  500.       );
  501.       generateSubgridTypes(subgridName);
  502.       generateContext(`${subgridName}`, `Xrm.FormContext`, subgrid.attributes);
  503.     }
  504.     for (const [quickViewName, quickView] of Object.entries(
  505.       typeInfo.quickViews
  506.     )) {
  507.       generateEnums(typeInfo.possibleEnums, quickView.enums);
  508.       generateLiteralsTypesUnionsAndCollection(
  509.         `${quickViewName}_attributes`,
  510.         quickView.attributes,
  511.         "Xrm.Attributes.Attribute",
  512.         false
  513.       );
  514.       generateLiteralsTypesUnionsAndCollection(
  515.         `${quickViewName}_controls`,
  516.         quickView.controls,
  517.         "Xrm.Controls.Control",
  518.         false
  519.       );
  520.       generateContext(
  521.         `${quickViewName}`,
  522.         `Xrm.Controls.QuickFormControl`,
  523.         quickView.attributes,
  524.         quickView.controls
  525.       );
  526.     }
  527.  
  528.     for (const [tabName, tab] of Object.entries(typeInfo.formTabs)) {
  529.       outputTS += `
  530.       type ${tabName}_sections_literals = ${new Set(Object.keys(tab.sections))
  531.         .map((sectionName) => `"${sectionName}"`)
  532.         .join(" | ")}${Object.keys(tab.sections).length === 0 ? '""' : ""};\n`;
  533.       outputTS += `
  534. interface ${tabName}_sections extends Xrm.Collection.ItemCollection<Xrm.Controls.Section> {`;
  535.       outputTS += `get(itemName: ${tabName}_sections_literals): Xrm.Controls.Section;\n`;
  536.       outputTS += `get(itemNameOrIndex: string | number): Xrm.Controls.Section | null;\n`;
  537.       outputTS += `get(delegate?): Xrm.Controls.Section[];\n`;
  538.       outputTS += `}`;
  539.  
  540.       outputTS += `
  541. interface ${tabName}_tab extends Xrm.Controls.Tab {
  542.   sections: ${tabName}_sections;
  543.     }`;
  544.     }
  545.     generateLiteralsTypesUnionsAndCollection(
  546.       `${currentFormName}_tabs`,
  547.       typeInfo.formTabs,
  548.       "Xrm.Controls.Tab",
  549.       true,
  550.       "_tab"
  551.     );
  552.     generateLiteralsTypesUnionsAndCollection(
  553.       `${currentFormName}_quickforms`,
  554.       typeInfo.quickViews,
  555.       "Xrm.Controls.QuickFormControl",
  556.       true,
  557.       "_quickformcontrol"
  558.     );
  559.     generateLiteralsTypesUnionsAndCollection(
  560.       `${currentFormName}_controls`,
  561.       typeInfo.formControls,
  562.       "Xrm.Controls.Control",
  563.       false
  564.     );
  565.     generateLiteralsTypesUnionsAndCollection(
  566.       `${currentFormName}_attributes`,
  567.       typeInfo.formAttributes,
  568.       "Xrm.Attributes.Attribute",
  569.       false
  570.     );
  571.     outputTS += `
  572.     interface ${currentFormName}_ui extends Xrm.Ui {
  573.       quickForms: ${currentFormName}_quickforms | null;
  574.       tabs: ${currentFormName}_tabs;
  575.     }
  576.     `;
  577.     generateContext(
  578.       currentFormName,
  579.       `Xrm.FormContext`,
  580.       typeInfo.formAttributes,
  581.       typeInfo.formControls,
  582.       `${currentFormName}_ui`
  583.     );
  584.  
  585.     for (const [formName, formObject] of Object.entries(typeInfo.subForms)) {
  586.       generateEnums(typeInfo.possibleEnums, formObject.enums);
  587.       for (let [subgridName, subgrid] of Object.entries(formObject.subGrids)) {
  588.         subgridName = subgridName.replace(/\W/g, "");
  589.         generateEnums(typeInfo.possibleEnums, subgrid.enums);
  590.         generateLiteralsTypesUnionsAndCollection(
  591.           `${subgridName}_attributes`,
  592.           subgrid.attributes,
  593.           "Xrm.Attributes.Attribute",
  594.           true
  595.         );
  596.         generateSubgridTypes(subgridName);
  597.         generateContext(
  598.           `${subgridName}`,
  599.           `Xrm.FormContext`,
  600.           subgrid.attributes
  601.         );
  602.       }
  603.       for (const [quickViewName, quickView] of Object.entries(
  604.         formObject.quickViews
  605.       )) {
  606.         generateEnums(typeInfo.possibleEnums, quickView.enums);
  607.         generateLiteralsTypesUnionsAndCollection(
  608.           `${quickViewName}_attributes`,
  609.           quickView.attributes,
  610.           "Xrm.Attributes.Attribute",
  611.           false
  612.         );
  613.         generateLiteralsTypesUnionsAndCollection(
  614.           `${quickViewName}_controls`,
  615.           quickView.controls,
  616.           "Xrm.Controls.Control",
  617.           false
  618.         );
  619.         generateContext(
  620.           `${quickViewName}`,
  621.           `Xrm.Controls.QuickFormControl`,
  622.           quickView.attributes,
  623.           quickView.controls
  624.         );
  625.       }
  626.       generateLiteralsTypesUnionsAndCollection(
  627.         `${formName}_attributes`,
  628.         formObject.attributes,
  629.         "Xrm.Attributes.Attribute",
  630.         false
  631.       );
  632.       generateLiteralsTypesUnionsAndCollection(
  633.         `${formName}_controls`,
  634.         formObject.controls,
  635.         "Xrm.Controls.Control",
  636.         false
  637.       );
  638.       generateContext(
  639.         formName,
  640.         `Xrm.FormContext`,
  641.         formObject.attributes,
  642.         formObject.controls
  643.       );
  644.     }
  645.  
  646.     // Create a new window with a textarea showing the output.
  647.     // The textarea is set to readonly to prevent editing.
  648.     const w = window.open(
  649.       "",
  650.       "_blank",
  651.       "width=600,height=400,menubar=no,toolbar=no,location=no,resizable=yes"
  652.     );
  653.     if (w) {
  654.       w.document.write(
  655.         "<html><head><title>TypeScript Definitions</title></head><body>"
  656.       );
  657.       w.document.write(
  658.         '<textarea readonly style="width:100%; height:90%;">' +
  659.           outputTS +
  660.           "</textarea>"
  661.       );
  662.       w.document.write("</body></html>");
  663.       w.document.close();
  664.     } else {
  665.       // Fallback to prompt if popups are blocked.
  666.       prompt("Copy the TypeScript definition:", outputTS);
  667.     }
  668.   });
  669. })();