☰

Greasy Fork 还支持 简体中文。

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.

目前為 2025-04-15 提交的版本，檢視 最新版本。

  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.988
  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.     };
  69.  
  70.     var specificControlTypeMapping = {
  71.       boolean: "Xrm.Controls.BooleanControl",
  72.       datetime: "Xrm.Controls.DateControl",
  73.       decimal: "Xrm.Controls.NumberControl",
  74.       double: "Xrm.Controls.NumberControl",
  75.       integer: "Xrm.Controls.NumberControl",
  76.       lookup: "Xrm.Controls.LookupControl",
  77.       memo: "Xrm.Controls.StringControl",
  78.       money: "Xrm.Controls.NumberControl",
  79.       multiselectoptionset: "Xrm.Controls.MultiselectOptionSetControl",
  80.       optionset: "Xrm.Controls.OptionSetControl",
  81.       string: "Xrm.Controls.StringControl",
  82.     };
  83.  
  84.     // Object to hold the type information.
  85.     const typeInfo = {
  86.       subGrids: {},
  87.       quickViews: {},
  88.       formAttributes: {},
  89.       formControls: {},
  90.       possibleEnums: [],
  91.       formTabs: {},
  92.       formEnums: {},
  93.       quickViewControls: {},
  94.       quickViewAttributes: {},
  95.     };
  96.     class Subgrid {
  97.       constructor() {
  98.         this.attributes = {};
  99.         this.enums = {};
  100.       }
  101.     }
  102.     class QuickForm {
  103.       constructor() {
  104.         this.attributes = {};
  105.         this.controls = {};
  106.         this.enums = {};
  107.       }
  108.     }
  109.  
  110.     class Tab {
  111.       constructor() {
  112.         this.sections = {};
  113.       }
  114.     }
  115.  
  116.     const currentFormName = stripNonAlphaNumeric(
  117.       Xrm.Page.ui.formSelector.getCurrentItem().getLabel()
  118.     );
  119.  
  120.     // Loop through all controls on the form.
  121.     if (
  122.       typeof Xrm !== "undefined" &&
  123.       Xrm.Page &&
  124.       typeof Xrm.Page.getControl === "function"
  125.     ) {
  126.       Xrm.Page.getControl().forEach((ctrl) => {
  127.         const ctrlType = ctrl.getControlType();
  128.         const mappedType = controlTypeMapping[ctrlType];
  129.         if (mappedType) {
  130.           typeInfo.formControls[ctrl.getName()] = mappedType;
  131.         }
  132.       });
  133.     } else {
  134.       alert("Xrm.Page is not available on this page.");
  135.       return;
  136.     }
  137.  
  138.     // Loop through all tabs and sections on the form.
  139.     if (typeof Xrm.Page.ui.tabs.get === "function") {
  140.       Xrm.Page.ui.tabs.get().forEach((tab) => {
  141.         let formTab = (typeInfo.formTabs[stripNonAlphaNumeric(tab.getName())] =
  142.           new Tab());
  143.         tab.sections.forEach((section) => {
  144.           formTab.sections[
  145.             stripNonAlphaNumeric(section.getName())
  146.           ] = `${stripNonAlphaNumeric(section.getName())}_section`;
  147.         });
  148.       });
  149.     }
  150.  
  151.     // Loop through all attributes on the form.
  152.     if (typeof Xrm.Page.getAttribute === "function") {
  153.       Xrm.Page.getAttribute().forEach((attr) => {
  154.         const attrType = attr.getAttributeType();
  155.         const attrName = attr.getName();
  156.         const mappedType = attributeTypeMapping[attrType];
  157.         const mappedControlType = specificControlTypeMapping[attrType];
  158.         if (mappedType) {
  159.           typeInfo.formAttributes[attrName] = mappedType;
  160.           attr.controls.forEach((ctrl) => {
  161.             typeInfo.formControls[ctrl.getName()] = mappedControlType;
  162.           });
  163.         }
  164.         if (
  165.           attr.getAttributeType() === "optionset" &&
  166.           attr.controls.get().length > 0
  167.         ) {
  168.           const enumValues = attr.getOptions();
  169.           if (enumValues) {
  170.             typeInfo.formEnums[attrName] = { attribute: "", values: [] };
  171.             typeInfo.formEnums[attrName].values = enumValues;
  172.             typeInfo.formEnums[attrName].attribute = attrName;
  173.             typeInfo.formAttributes[attrName] = `${attrName}_attribute`;
  174.           }
  175.         }
  176.       });
  177.     }
  178.  
  179.     // Loop through all subgrids on the form.
  180.     if (typeof Xrm.Page.getControl === "function") {
  181.       Xrm.Page.getControl().forEach((ctrl) => {
  182.         if (
  183.           ctrl.getControlType() === "subgrid" ||
  184.           ctrl.getControlType() ===
  185.             "customsubgrid:MscrmControls.Grid.GridControl"
  186.         ) {
  187.           const gridRow = ctrl.getGrid().getRows().get(0);
  188.           const gridName = ctrl.getName();
  189.           let subgrid = (typeInfo.subGrids[gridName] = new Subgrid());
  190.           typeInfo.formControls[gridName] = `${gridName}_gridcontrol`;
  191.           if (gridRow !== null) {
  192.             gridRow.data.entity.attributes.forEach((attr) => {
  193.               const attrType = attr.getAttributeType();
  194.               const attrName = attr.getName();
  195.               const mappedType = attributeTypeMapping[attrType];
  196.               if (mappedType) {
  197.                 subgrid.attributes[attrName] = mappedType;
  198.               }
  199.               if (
  200.                 attr.getAttributeType() === "optionset" &&
  201.                 attr.controls.get().length > 0
  202.               ) {
  203.                 const enumValues = attr.getOptions();
  204.                 if (enumValues) {
  205.                   subgrid.enums[attrName] = { attribute: "", values: [] };
  206.                   subgrid.enums[attrName].values = enumValues;
  207.                   subgrid.enums[attrName].attribute = attrName;
  208.                   subgrid.attributes[attrName] = `${attrName}_attribute`;
  209.                 }
  210.               }
  211.             });
  212.           }
  213.         }
  214.       });
  215.     }
  216.  
  217.     // Loop through all Quick View controls and attributes on the form.
  218.     if (typeof Xrm.Page.ui.quickForms.get === "function") {
  219.       Xrm.Page.ui.quickForms.get().forEach((ctrl) => {
  220.         const quickViewName = ctrl.getName();
  221.         let quickView = (typeInfo.quickViews[quickViewName] = new QuickForm());
  222.         const ctrlType = ctrl.getControlType();
  223.         typeInfo.formControls[
  224.           quickViewName
  225.         ] = `${quickViewName}_quickformcontrol`;
  226.         ctrl.getControl().forEach((subCtrl) => {
  227.           if (typeof subCtrl.getAttribute !== "function") {
  228.             return;
  229.           }
  230.           const subCtrlAttrType = subCtrl.getAttribute().getAttributeType();
  231.           const mappedControlType =
  232.             specificControlTypeMapping[subCtrlAttrType] ??
  233.             controlTypeMapping[subCtrl.getControlType()];
  234.           if (mappedControlType) {
  235.             quickView.controls[subCtrl.getName()] = mappedControlType;
  236.           }
  237.         });
  238.         ctrl.getAttribute().forEach((attr) => {
  239.           const attrType = attr.getAttributeType();
  240.           const attrName = attr.getName();
  241.           const mappedType = attributeTypeMapping[attrType];
  242.           if (mappedType) {
  243.             quickView.attributes[attrName] = mappedType;
  244.           }
  245.           if (attrType === "optionset" && attr.controls.get().length > 0) {
  246.             const enumValues = attr.getOptions();
  247.             if (enumValues) {
  248.               quickView.enums[attrName] = { attribute: "", values: [] };
  249.               quickView.enums[attrName].values = enumValues;
  250.               quickView.enums[attrName].attribute = attrName;
  251.               quickView.attributes[attrName] = `${attrName}_attribute`;
  252.             }
  253.           }
  254.         });
  255.       });
  256.     }
  257.  
  258.     // Build the TypeScript overload string.
  259.     let outputTS = `// These TypeScript definitions were generated automatically on: ${new Date().toDateString()}\n`;
  260.     for (const [originalEnumName, enumValues] of Object.entries(
  261.       typeInfo.formEnums
  262.     )) {
  263.       if (typeInfo.possibleEnums.includes(originalEnumName)) {
  264.         continue;
  265.       }
  266.       typeInfo.possibleEnums.push(originalEnumName);
  267.       let enumName = `${originalEnumName}_enum`;
  268.       let enumTemplate = [];
  269.       let textLiteralTypes = [];
  270.       let valueLiteralTypes = [];
  271.       for (const enumValue of enumValues.values) {
  272.         enumTemplate.push(
  273.           `   ${enumValue.text.replace(/\W/g, "").replace(/[0-9]/g, "")} = ${
  274.             enumValue.value
  275.           }`
  276.         );
  277.         textLiteralTypes.push(`"${enumValue.text}"`);
  278.         valueLiteralTypes.push(
  279.           `${enumName}.${enumValue.text
  280.             .replace(/\W/g, "")
  281.             .replace(/[0-9]/g, "")}`
  282.         );
  283.       }
  284.       outputTS += `
  285. const enum ${enumName} {
  286. ${enumTemplate.join(",\n")}
  287. }
  288. `;
  289.       outputTS += `
  290. interface ${enumValues.attribute}_value extends Xrm.OptionSetValue {
  291. text: ${textLiteralTypes.join(" | ")};
  292. value: ${valueLiteralTypes.join(" | ")};  
  293. }
  294. `;
  295.       outputTS += `
  296. interface ${enumValues.attribute}_attribute extends Xrm.Attributes.OptionSetAttribute<${enumName}> {
  297.    `;
  298.       valueLiteralTypes.forEach((value, index) => {
  299.         outputTS += `getOption(value: ${value}): {text: ${textLiteralTypes[index]}, value: ${value}};\n`;
  300.       });
  301.       outputTS += `getOption(value: ${enumValues.attribute}_value['value']): ${enumValues.attribute}_value | null;
  302.   getOptions(): ${enumValues.attribute}_value[];
  303.   getSelectedOption(): ${enumValues.attribute}_value | null;
  304.   getValue(): ${enumName} | null;
  305.   setValue(value: ${enumName} | null): void;
  306.   getText(): ${enumValues.attribute}_value['text'] | null;
  307. }
  308. `;
  309.     }
  310.     for (let [subgridName, subgrid] of Object.entries(typeInfo.subGrids)) {
  311.       subgridName = subgridName.replace(/\W/g, "");
  312.       for (const [enumName, enumValues] of Object.entries(subgrid.enums)) {
  313.         if (typeInfo.possibleEnums.includes(enumName)) {
  314.           continue;
  315.         }
  316.         typeInfo.possibleEnums.push(enumName);
  317.         let enumTemplate = [];
  318.         let textLiteralTypes = [];
  319.         let valueLiteralTypes = [];
  320.         for (const enumValue of enumValues.values) {
  321.           enumTemplate.push(
  322.             `   ${enumValue.text.replace(/\W/g, "").replace(/[0-9]/g, "")} = ${
  323.               enumValue.value
  324.             }`
  325.           );
  326.           textLiteralTypes.push(`"${enumValue.text}"`);
  327.           valueLiteralTypes.push(
  328.             `${enumName}_enum.${enumValue.text
  329.               .replace(/\W/g, "")
  330.               .replace(/[0-9]/g, "")}`
  331.           );
  332.         }
  333.         outputTS += `
  334. const enum ${enumName}_enum {
  335. ${enumTemplate.join(",\n")}
  336. }
  337. `;
  338.         outputTS += `
  339. interface ${enumValues.attribute}_value extends Xrm.OptionSetValue {
  340. text: ${textLiteralTypes.join(" | ")};
  341. value: ${valueLiteralTypes.join(" | ")};
  342.   }
  343. `;
  344.         outputTS += `
  345. interface ${enumValues.attribute}_attribute extends Xrm.Attributes.OptionSetAttribute<${enumName}_enum> {
  346. `;
  347.         valueLiteralTypes.forEach((value, index) => {
  348.           outputTS += `getOption(value: ${value}): {text: ${textLiteralTypes[index]}, value: ${value}};\n`;
  349.         });
  350.         outputTS += `
  351.   getOption(value: ${enumValues.attribute}_value['value']): ${enumValues.attribute}_value | null;
  352.   getOptions(): ${enumValues.attribute}_value[];
  353.   getSelectedOption(): ${enumValues.attribute}_value | null;
  354.   getValue(): ${enumName}_enum | null;
  355.   setValue(value: ${enumName}_enum | null): void;
  356.   getText(): ${enumValues.attribute}_value['text'] | null;
  357.   }
  358.   `;
  359.       }
  360.  
  361.       outputTS += `
  362.   interface ${subgridName}_attributes extends Xrm.Collection.ItemCollection<${subgridName}_attributes_types> {`;
  363.       for (const [attrType, attrNames] of Object.entries(
  364.         groupItemsByType(subgrid.attributes)
  365.       )) {
  366.         outputTS += `get(itemName: "${attrNames.join(
  367.           '" | "'
  368.         )}"): ${attrType};\n`;
  369.       }
  370.       outputTS += `
  371.       get(itemName: ${subgridName}_attributes_literals): ${subgridName}_attributes_types;
  372.       get(itemNameOrIndex: string | number): Xrm.Attributes.Attribute | null;
  373.       get(delegate?): ${subgridName}_attributes_types[];
  374.       }
  375.   `;
  376.       outputTS += `
  377.   type ${subgridName}_attributes_types = ${new Set(
  378.         Object.values(subgrid.attributes)
  379.       )
  380.         .map((attrType) => `${attrType}`)
  381.         .join(" | ")}${
  382.         Object.keys(subgrid.attributes).length === 0
  383.           ? "Xrm.Attributes.Attribute"
  384.           : ""
  385.       };\n`;
  386.  
  387.       outputTS += `
  388.   type ${subgridName}_attributes_literals = ${new Set(
  389.         Object.keys(subgrid.attributes)
  390.       )
  391.         .map((attrName) => `"${attrName}"`)
  392.         .join(" | ")}${
  393.         Object.keys(subgrid.attributes).length === 0 ? '""' : ""
  394.       };\n`;
  395.  
  396.       outputTS += `
  397.   interface ${subgridName}_entity extends Xrm.Entity {
  398.     attributes: ${subgridName}_attributes;
  399.   }
  400.   interface ${subgridName}_data extends Xrm.Data {
  401.     entity: ${subgridName}_entity;
  402.   }
  403.   
  404.   interface ${subgridName}_gridrow extends Xrm.Controls.Grid.GridRow {
  405.     data: ${subgridName}_data;
  406.   }
  407.   
  408.   interface ${subgridName}_grid extends Xrm.Controls.Grid {
  409.     getRows(): Xrm.Collection.ItemCollection<${subgridName}_gridrow>;
  410.   }
  411.   
  412.   interface ${subgridName}_gridcontrol extends Xrm.Controls.GridControl {
  413.     getGrid(): ${subgridName}_grid;
  414.   }
  415.   interface ${subgridName}_context extends Xrm.FormContext {`;
  416.       for (const [attrType, attrNames] of Object.entries(
  417.         groupItemsByType(subgrid.attributes)
  418.       )) {
  419.         outputTS += `getAttribute(attributeName: "${attrNames.join(
  420.           '" | "'
  421.         )}"): ${attrType};\n`;
  422.       }
  423.       outputTS += `getAttribute(attributeName: ${subgridName}_attributes_literals): ${subgridName}_attributes_types;`;
  424.       outputTS += `getAttribute(attributeNameOrIndex: string | number): Xrm.Attributes.Attribute | null;`;
  425.       outputTS += `getAttribute(delegateFunction?): ${subgridName}_attributes[];`;
  426.       outputTS += `
  427.   }
  428.   `;
  429.       outputTS += `
  430.   interface ${subgridName}_eventcontext extends Xrm.Events.EventContext {
  431.     getFormContext(): ${subgridName}_context;
  432. }`;
  433.     }
  434.     for (const [quickViewName, quickView] of Object.entries(
  435.       typeInfo.quickViews
  436.     )) {
  437.       for (const [enumName, enumValues] of Object.entries(quickView.enums)) {
  438.         if (typeInfo.possibleEnums.includes(enumName)) {
  439.           continue;
  440.         }
  441.         typeInfo.possibleEnums.push(enumName);
  442.         let enumTemplate = [];
  443.         let textLiteralTypes = [];
  444.         let valueLiteralTypes = [];
  445.         for (const enumValue of enumValues.values) {
  446.           enumTemplate.push(
  447.             `   ${enumValue.text.replace(/\W/g, "").replace(/[0-9]/g, "")} = ${
  448.               enumValue.value
  449.             }`
  450.           );
  451.           textLiteralTypes.push(`"${enumValue.text}"`);
  452.           valueLiteralTypes.push(
  453.             `${enumName}_enum.${enumValue.text
  454.               .replace(/\W/g, "")
  455.               .replace(/[0-9]/g, "")}`
  456.           );
  457.         }
  458.         outputTS += `
  459. const enum ${enumName}_enum {
  460. ${enumTemplate.join(",\n")}
  461.       }
  462. `;
  463.         outputTS += `
  464. interface ${enumValues.attribute}_value extends Xrm.OptionSetValue {
  465. text: ${textLiteralTypes.join(" | ")};
  466. value: ${valueLiteralTypes.join(" | ")};
  467.       }
  468. `;
  469.         outputTS += `
  470. interface ${enumValues.attribute}_attribute extends Xrm.Attributes.OptionSetAttribute<${enumName}_enum> {
  471. `;
  472.         valueLiteralTypes.forEach((value, index) => {
  473.           outputTS += `getOption(value: ${value}): {text: ${textLiteralTypes[index]}, value: ${value}};\n`;
  474.         });
  475.         outputTS += `
  476.   getOption(value: ${enumValues.attribute}_value['value']): ${enumValues.attribute}_value | null;
  477.   getOptions(): ${enumValues.attribute}_value[];
  478.   getSelectedOption(): ${enumValues.attribute}_value | null;
  479.   getValue(): ${enumName}_enum | null;
  480.   setValue(value: ${enumName}_enum | null): void;
  481.   getText(): ${enumValues.attribute}_value['text'] | null;
  482.       }
  483.   `;
  484.       }
  485.       outputTS += `type ${quickViewName}_controls_types = ${new Set(
  486.         Object.values(quickView.controls)
  487.       )
  488.         .map((controlType) => `${controlType}`)
  489.         .join(" | ")}${
  490.         Object.keys(quickView.controls).length === 0
  491.           ? "Xrm.Controls.Control"
  492.           : ""
  493.       };\n`;
  494.       outputTS += `
  495.   type ${quickViewName}_attributes_types = ${new Set(
  496.         Object.values(quickView.attributes)
  497.       )
  498.         .map((attrType) => `${attrType}`)
  499.         .join(" | ")}${
  500.         Object.keys(quickView.attributes).length === 0
  501.           ? "Xrm.Attributes.Attribute"
  502.           : ""
  503.       };\n`;
  504.       outputTS += `type ${quickViewName}_controls_literals = ${new Set(
  505.         Object.keys(quickView.controls)
  506.       )
  507.         .map((controlName) => `"${controlName}"`)
  508.         .join(" | ")}${
  509.         Object.keys(quickView.controls).length === 0 ? '""' : ""
  510.       };\n`;
  511.       outputTS += `
  512.     type ${quickViewName}_attributes_literals = ${new Set(
  513.         Object.keys(quickView.attributes)
  514.       )
  515.         .map((attrName) => `"${attrName}"`)
  516.         .join(" | ")}${
  517.         Object.keys(quickView.attributes).length === 0 ? '""' : ""
  518.       };\n`;
  519.       outputTS += `
  520.   interface ${quickViewName}_quickformcontrol extends Xrm.Controls.QuickFormControl {
  521.     `;
  522.       for (const [controlType, controlNames] of Object.entries(
  523.         groupItemsByType(quickView.controls)
  524.       )) {
  525.         outputTS += `getControl(controlName: "${controlNames.join(
  526.           '" | "'
  527.         )}"): ${controlType};\n`;
  528.       }
  529.       outputTS += `
  530.     getControl(controlName: ${quickViewName}_controls_literals): ${quickViewName}_controls_types;
  531.     getControl(controlNameOrIndex: string | number): Xrm.Controls.Control | null;
  532.     getControl(delegateFunction?): ${quickViewName}_controls_types[]
  533.     `;
  534.       for (const [attrType, attrNames] of Object.entries(
  535.         groupItemsByType(quickView.attributes)
  536.       )) {
  537.         outputTS += `getAttribute(attributeName: "${attrNames.join(
  538.           '" | "'
  539.         )}"): ${attrType};\n`;
  540.       }
  541.       outputTS += `
  542.       getAttribute(attributeName: ${quickViewName}_attributes_literals): ${quickViewName}_attributes_types;
  543.       getAttribute(attributeNameOrIndex: string | number): Xrm.Attributes.Attribute | null;
  544.     getAttribute(delegateFunction?): ${quickViewName}_attributes_types[];
  545.   
  546.   }`;
  547.     }
  548.     for (const [tabName, tab] of Object.entries(typeInfo.formTabs)) {
  549.       outputTS += `
  550.       type ${tabName}_sections_literals = ${new Set(Object.keys(tab.sections))
  551.         .map((sectionName) => `"${sectionName}"`)
  552.         .join(" | ")}${Object.keys(tab.sections).length === 0 ? '""' : ""};\n`;
  553.       outputTS += `
  554. interface ${tabName}_sections extends Xrm.Collection.ItemCollection<Xrm.Controls.Section> {`;
  555.       outputTS += `get(itemName: ${tabName}_sections_literals): Xrm.Controls.Section;\n`;
  556.       outputTS += `get(itemNameOrIndex: string | number): Xrm.Controls.Section | null;\n`;
  557.       outputTS += `get(delegate?): Xrm.Controls.Section[];\n`;
  558.       outputTS += `}`;
  559.  
  560.       outputTS += `
  561. interface ${tabName}_tab extends Xrm.Controls.Tab {
  562.   sections: ${tabName}_sections;
  563.     }`;
  564.     }
  565.     outputTS += `
  566.     type ${currentFormName}_tabs_types = ${new Set(
  567.       Object.keys(typeInfo.formTabs).map((tabType) => `${tabType}_tab`)
  568.     ).join(" | ")}${
  569.       Object.keys(typeInfo.formTabs).length === 0 ? "Xrm.Controls.Tab" : ""
  570.     };\n`;
  571.     outputTS += `
  572.     type ${currentFormName}_tabs_literals = ${new Set(
  573.       Object.keys(typeInfo.formTabs)
  574.     )
  575.       .map((tabName) => `"${tabName}"`)
  576.       .join(" | ")}${
  577.       Object.keys(typeInfo.formTabs).length === 0 ? '""' : ""
  578.     };\n`;
  579.     outputTS += `
  580. interface ${currentFormName}_tabs extends Xrm.Collection.ItemCollection<${currentFormName}_tabs_types> {`;
  581.     for (const [itemName, itemType] of Object.entries(typeInfo.formTabs)) {
  582.       outputTS += `get(itemName:"${itemName}"): ${itemName}_tab;\n`;
  583.     }
  584.     outputTS += `
  585.     get(itemName: ${currentFormName}_tabs_literals): ${currentFormName}_tabs_types;
  586.     get(itemNameOrIndex: string | number): Xrm.Controls.Tab | null;
  587.     get(delegate?): ${currentFormName}_tabs_types[];
  588.     }`;
  589.     outputTS += `
  590.     type ${currentFormName}_quickforms_types = ${new Set(
  591.       Object.keys(typeInfo.quickViews)
  592.     )
  593.       .map((quickViewName) => `${quickViewName}_quickformcontrol`)
  594.       .join(" | ")}${
  595.       Object.keys(typeInfo.quickViews).length === 0
  596.         ? "Xrm.Controls.QuickFormControl"
  597.         : ""
  598.     };\n`;
  599.     outputTS += `
  600.     type ${currentFormName}_quickforms_literals = ${new Set(
  601.       Object.keys(typeInfo.quickViews)
  602.     )
  603.       .map((quickViewName) => `"${quickViewName}"`)
  604.       .join(" | ")}${
  605.       Object.keys(typeInfo.quickViews).length === 0 ? '""' : ""
  606.     };\n`;
  607.     outputTS += `
  608. interface ${currentFormName}_quickforms extends Xrm.Collection.ItemCollection<${currentFormName}_quickform_types> {`;
  609.     for (const [itemName, itemType] of Object.entries(typeInfo.quickViews)) {
  610.       outputTS += `get(itemName:"${itemName}"): ${itemName}_quickformcontrol;\n`;
  611.     }
  612.     outputTS += `
  613.     get(itemName: ${currentFormName}_quickforms_literals): ${currentFormName}_quickforms_types;
  614.     get(itemNameOrIndex: string | number): Xrm.Controls.QuickFormControl | null;
  615.     get(delegate?): ${currentFormName}_quickforms_types[];
  616.     }`;
  617.     outputTS += `
  618.     type ${currentFormName}_attributes_types = ${new Set(
  619.       Object.values(typeInfo.formAttributes)
  620.     )
  621.       .map((attrType) => `${attrType}`)
  622.       .join(" | ")}\n`;
  623.     outputTS += `
  624.     type ${currentFormName}_attributes_literals = ${new Set(
  625.       Object.keys(typeInfo.formAttributes)
  626.     )
  627.       .map((attrName) => `"${attrName}"`)
  628.       .join(" | ")}\n`;
  629.  
  630.     outputTS += `
  631.     type ${currentFormName}_controls_types = ${new Set(
  632.       Object.values(typeInfo.formControls)
  633.     )
  634.       .map((ctrlType) => `${ctrlType}`)
  635.       .join(" | ")}\n`;
  636.     outputTS += `
  637.     type ${currentFormName}_controls_literals = ${new Set(
  638.       Object.keys(typeInfo.formControls)
  639.     )
  640.       .map((ctrlName) => `"${ctrlName}"`)
  641.       .join(" | ")}\n`;
  642.     outputTS += `
  643.     interface ${currentFormName}_ui extends Xrm.Ui {
  644.       quickForms: ${currentFormName}_quickforms | null;
  645.       tabs: ${currentFormName}_tabs;
  646.  
  647.     }
  648.     `;
  649.     outputTS += `
  650.     interface ${currentFormName}_context extends Xrm.FormContext {
  651.     ui: ${currentFormName}_ui;
  652.   `;
  653.     for (const [controlType, controlNames] of Object.entries(
  654.       groupItemsByType(typeInfo.formControls)
  655.     )) {
  656.       outputTS += `getControl(controlName: "${controlNames.join(
  657.         '" | "'
  658.       )}"): ${controlType};\n`;
  659.     }
  660.     outputTS += `
  661.     getControl(controlName: ${currentFormName}_controls_literals): ${currentFormName}_controls_types;
  662.     getControl(controlNameOrIndex: string | number): Xrm.Controls.Control | null;
  663.     getControl(delegateFunction?): ${currentFormName}_controls_types[];
  664.     `;
  665.     for (const [attrType, attrNames] of Object.entries(
  666.       groupItemsByType(typeInfo.formAttributes)
  667.     )) {
  668.       outputTS += `getAttribute(attributeName: "${attrNames.join(
  669.         '" | "'
  670.       )}"): ${attrType};\n`;
  671.     }
  672.     outputTS += `
  673.     getAttribute(attributeName: ${currentFormName}_attributes_literals): ${currentFormName}_attributes_types;
  674.     getAttribute(attributeNameOrIndex: string | number): Xrm.Attributes.Attribute | null;
  675.     getAttribute(delegateFunction?): ${currentFormName}_attributes_types[];
  676.   }`;
  677.     outputTS += `
  678.   interface ${currentFormName}_eventcontext extends Xrm.Events.EventContext {
  679.     getFormContext(): ${currentFormName}_context;
  680. }`;
  681.  
  682.     // Create a new window with a textarea showing the output.
  683.     // The textarea is set to readonly to prevent editing.
  684.     const w = window.open(
  685.       "",
  686.       "_blank",
  687.       "width=600,height=400,menubar=no,toolbar=no,location=no,resizable=yes"
  688.     );
  689.     if (w) {
  690.       w.document.write(
  691.         "<html><head><title>TypeScript Definitions</title></head><body>"
  692.       );
  693.       w.document.write(
  694.         '<textarea readonly style="width:100%; height:90%;">' +
  695.           outputTS +
  696.           "</textarea>"
  697.       );
  698.       w.document.write("</body></html>");
  699.       w.document.close();
  700.     } else {
  701.       // Fallback to prompt if popups are blocked.
  702.       prompt("Copy the TypeScript definition:", outputTS);
  703.     }
  704.   });
  705. })();