Home Reference Source

cables_dev/cables_ui/src/ui/components/opsearch.js

  1. import { Events } from "cables-shared-client";
  2. import { CgContext } from "cables-corelibs";
  3. import { Link, Patch, Port, utils } from "cables";
  4. import defaultOps from "../defaultops.js";
  5. import namespace from "../namespaceutils.js";
  6. import opNames from "../opnameutils.js";
  7. import { gui } from "../gui.js";
  8. import { platform } from "../platform.js";
  10. /**
  11.  * @typedef OpSearchListItem
  12.  * @property {string|number} opId simpleId if op has no doc
  13.  * @property {string} name full op name, e.g. Ops.Math.Sum
  14.  * @property {string} summary
  15.  * @property {string} [description] collections only
  16.  * @property {string} [collectionOpNames] lowercase, space separated op names of a collection
  17.  * @property {string} nscolor namespace css class name
  18.  * @property {boolean} isOp false for collections
  19.  * @property {boolean} userOp
  20.  * @property {boolean} devOp
  21.  * @property {boolean} extensionOp
  22.  * @property {boolean} teamOp
  23.  * @property {boolean} patchOp
  24.  * @property {boolean} isExtension
  25.  * @property {boolean} isTeamNamespace
  26.  * @property {boolean} isCollection
  27.  * @property {string} shortName
  28.  * @property {string} nameSpace
  29.  * @property {string[]} namespaces all parent namespaces, e.g. ["Ops.Math"]
  30.  * @property {string} oldState "", "OLD" or "DEPREC"
  31.  * @property {string} lowercasename
  32.  * @property {string} buttonText
  33.  * @property {string} type "op", "team", "extension" or "patchop"
  34.  * @property {number} pop popularity
  35.  * @property {string} [teamName] collections only
  36.  * @property {string} [teamLink] collections only
  37.  * @property {number} [numOps] collections only
  38.  * @property {string[]} [ops] collections only
  39.  * @property {number} [id] index in list, set by buildList
  40.  * @property {boolean} [old] deprecated or outdated version
  41.  * @property {string} [abbrev] abbreviation of shortName
  42.  * @property {string} [_summary] lowercase search cache
  43.  * @property {string} [_shortName] lowercase search cache
  44.  * @property {string} [_lowerCaseName] lowercase search cache
  45.  * @property {string} [_nameSpace] lowercase search cache
  46.  * @property {string} [_nameSpaceFull] lowercase search cache
  47.  * @property {number} [score] search score
  48.  * @property {string} [scoreDebug] html explaining the score
  49.  * @property {HTMLElement} [element] result element in opselect
  50.  * @property {boolean} [elementHidden]
  51.  */
  53. /** @typedef NewOpOptions
  54.   * @property {Link} [linkNewLink]
  55.   * @property {Port} [linkNewOpToPort]
  56.   */
  58. /** Searches through the op docs, e.g. for the op select dialog. */
  59. export default class OpSearch extends Events
  60. {
  62.     /** @type {NewOpOptions} */
  63.     newOpOptions = {};
  64.     constructor()
  65.     {
  66.         super();
  68.         /** @type {OpSearchListItem[]} */
  69.         this._list = null;
  70.         this._wordsDb = null;
  71.         this.numPatchops = 0;
  72.         this.originalSearch = "";
  73.         this.hideUserOps = false;
  74.     }
  76.     /** @returns {OpSearchListItem[]} */
  77.     get list()
  78.     {
  79.         return this._list;
  80.     }
  82.     resetList()
  83.     {
  84.         this._list = null;
  85.     }
  87.     buildList()
  88.     {
  89.         const perf = gui.uiProfiler.start("opsearch.getlist");
  91.         const codeOpNames = this._getOpsNamesFromCode([], "Ops", Ops, "");
  92.         let items = this._createListItemsByNames(codeOpNames);
  94.         const docOpName = gui.opDocs.getOpDocs().map((ext) => { return ext.name; });
  95.         items = items.concat(this._createListItemsByNames(docOpName, items));
  97.         const extensionNames = gui.opDocs.getExtensions().map((ext) => { return ext.name; });
  98.         items = items.concat(this._createListItemsByNames(extensionNames, items));
  100.         const teamNamespaces = gui.opDocs.getTeamNamespaces().map((ext) => { return ext.name; });
  101.         items = items.concat(this._createListItemsByNames(teamNamespaces, items));
  103.         const ns = platform.getPatchOpsNamespace();
  104.         const patchOpNames = gui.opDocs.getNamespaceDocs(ns).map((ext) => { return ext.name; });
  106.         this.numPatchops = utils.uniqueArray(patchOpNames || []).length;
  107.         items = items.concat(this._createListItemsByNames(patchOpNames, items));
  109.         const newList = {};
  110.         items.forEach((item) =>
  111.         {
  112.             if (!newList.hasOwnProperty(item.opId))
  113.             {
  114.                 newList[item.opId] = item;
  115.             }
  116.         });
  118.         this._list = Object.values(newList);
  119.         this._list.sort((a, b) => { return b.pop - a.pop; });
  120.         perf.finish();
  122.         /// --------------
  124.         let maxPop = 0;
  126.         for (let i = 0; i < this._list.length; i++)
  127.         {
  128.             if (!this._list[i].shortName) this._list[i].shortName = this._list[i].name;
  130.             maxPop = Math.max(this._list[i].pop || 0, maxPop);
  131.             this._list[i].id = i;
  132.             this._list[i].summary = this._list[i].summary || "";
  133.             this._list[i]._summary = this._list[i].summary.toLowerCase();
  134.             this._list[i]._shortName = this._list[i].shortName.toLowerCase();
  135.             this._list[i]._lowerCaseName = this._list[i].name.toLowerCase();
  136.             this._list[i]._nameSpace = this._list[i].nameSpace.toLowerCase() + ".";
  137.             this._list[i]._nameSpaceFull = this._list[i].nameSpace.toLowerCase() + "." + this._list[i].shortName.toLowerCase();
  139.             const opdoc = gui.opDocs.getOpDocByName(this._list[i].name);
  140.             if (namespace.isDeprecatedOp(this._list[i].name) || (opdoc && opdoc.oldVersion)) this._list[i].old = true;
  141.         }
  142.         this._rebuildWordList();
  143.         CABLES.UI.OPSELECT.maxPop = maxPop;
  144.     }
  146.     /**
  147.      * @param {number} wordIndex
  148.      * @param {string} orig
  149.      * @param {OpSearchListItem[]} list
  150.      * @param {string} query
  151.      */
  152.     _searchWord(wordIndex, orig, list, query)
  153.     {
  154.         if (!query || query === " " || query === "") return;
  156.         const perf = gui.uiProfiler.start("opsearch._searchWord");
  158.         for (let i = 0; i < list.length; i++)
  159.         {
  160.             if (wordIndex > 0 && list[i].score === 0) continue; // when second word was found, but first was not
  162.             let scoreDebug = "<b>Query: " + query + " </b><br/>";
  163.             let found = false;
  164.             let points = 0;
  166.             if (list[i].lowercasename.indexOf(query) > -1)
  167.             {
  168.                 if (list[i].name === defaultOps.glMainloop)
  169.                 {
  170.                     found = true;
  171.                     scoreDebug += "+2 vip op<br/>";
  172.                     points += 2;
  173.                 }
  174.             }
  176.             if (this.preferGApi == CgContext.API_WEBGL)
  177.             {
  178.                 if (list[i].name.startsWith(defaultOps.prefixes.webgpu))
  179.                 {
  180.                     found = true;
  181.                     scoreDebug += "-5 different graphics api<br/>";
  182.                     points -= 5;
  183.                 }
  184.             }
  185.             else if (this.preferGApi == CgContext.API_WEBGPU)
  186.             {
  187.                 if (list[i].name.startsWith(defaultOps.prefixes.webgl))
  188.                 {
  189.                     found = true;
  190.                     scoreDebug += "-5 different graphics api<br/>";
  191.                     points -= 5;
  192.                 }
  193.             }
  195.             if (list[i].abbrev && list[i].abbrev.indexOf(orig) === 0)
  196.             {
  197.                 found = true;
  198.                 let p = 4;
  199.                 if (orig.length === 2)p = 12;
  200.                 if (orig.length === 3)p = 10;
  201.                 if (orig.length === 4)p = 8;
  203.                 if (query === query.toUpperCase())
  204.                 {
  205.                     const ppo = 5;
  206.                     p += ppo;
  207.                     scoreDebug += "+" + ppo + " uppercase abbreviation<br/>";
  208.                 }
  210.                 scoreDebug += "+" + p + " abbreviation<br/>";
  212.                 points += p;
  213.             }
  215.             if (list[i].userOp && this.hideUserOps) continue;
  217.             if (list[i]._summary.indexOf(query) > -1)
  218.             {
  219.                 found = true;
  220.                 points += 1;
  221.                 scoreDebug += "+1 found in summary (" + query + ")<br/>";
  222.             }
  224.             if (list[i]._nameSpace.indexOf(query) > -1)
  225.             {
  226.                 found = true;
  227.                 points += 1;
  228.                 scoreDebug += "+1 found in namespace (" + query + ")<br/>";
  229.             }
  231.             if (list[i]._shortName.indexOf(query) > -1)
  232.             {
  233.                 found = true;
  234.                 points += 4;
  235.                 scoreDebug += "+4 found in shortname (" + query + ")<br/>";
  236.             }
  238.             if (list[i]._shortName.startsWith(query))
  239.             {
  240.                 found = true;
  241.                 points += 2;
  242.                 scoreDebug += "+2 query startswith shortname<br/>";
  243.             }
  245.             if (list[i]._shortName.endsWith(query))
  246.             {
  247.                 found = true;
  248.                 points += 2;
  249.                 scoreDebug += "+2 query endsWith shortname<br/>";
  250.             }
  252.             if (orig.length > 1 && list[i]._lowerCaseName.indexOf(orig) > -1)
  253.             {
  254.                 found = true;
  255.                 points += 2;
  256.                 scoreDebug += "+2 found full namespace (" + query + ")<br/>";
  257.             }
  259.             if (points == 0)
  260.             {
  261.                 if (list[i]._lowerCaseName.indexOf(query) > -1)
  262.                 {
  263.                     found = true;
  264.                     points += 2;
  265.                     scoreDebug += "+2 found full namespace (" + query + ")<br/>";
  266.                 }
  267.             }
  269.             if (list[i].collectionOpNames && list[i].collectionOpNames.indexOf(orig) > -1)
  270.             {
  271.                 found = true;
  272.                 points += 1;
  273.                 scoreDebug += "+1 is op in collection (" + query + ")<br/>";
  274.             }
  276.             if (found)
  277.             {
  278.                 if (this.newOpOptions)
  279.                 {
  280.                     const firstportfitspoints = 3;
  281.                     const firstportfitsText = "+3 First Port fits<br/>";
  283.                     const docs = gui.opDocs.getOpDocByName(list[i].name);
  285.                     // if (docs && docs.hasOwnProperty("version"))
  286.                     // {
  287.                     //     const p = docs.version * 0.01;
  288.                     //     points += p;
  289.                     //     scoreDebug += "+" + p + " version<br/>";
  290.                     // }
  292.                     /// ////////////////////
  293.                     // namespace similarity
  295.                     let linkPortIn = null;
  296.                     let linkPortOut = null;
  297.                     if (this.newOpOptions.linkNewLink)
  298.                     {
  299.                         linkPortIn = this.newOpOptions.linkNewLink.portIn;
  300.                         linkPortOut = this.newOpOptions.linkNewLink.portOut;
  301.                     }
  303.                     let nspoints = 0;
  304.                     if (this.newOpOptions.linkNewOpToPort)
  305.                     {
  306.                         if (this.newOpOptions.linkNewOpToPort.op)
  307.                             for (let nsi = 0; nsi < list[i].namespaces.length; nsi++)
  308.                             {
  309.                                 if (!this.newOpOptions.linkNewOpToPort.op.objName.startsWith(list[i].namespaces[nsi])) break;
  310.                                 nspoints++;
  311.                             }
  312.                     }
  314.                     if (list[i].nameSpace.startsWith("Ops.Graphics") &&
  315.                              (this.newOpOptions.linkNewOpToPort && this.newOpOptions.linkNewOpToPort.op.objName.startsWith("Ops.Gl")) ||
  316.                              (linkPortIn && linkPortIn.op.objName.startsWith("Ops.Gl")) ||
  317.                              (linkPortIn && linkPortOut.op.objName.startsWith("Ops.Gl")))
  318.                     {
  319.                         scoreDebug += "+2 compatible namespace similarity<br/>";
  320.                         nspoints += 2;
  321.                     }
  323.                     if (linkPortIn)
  324.                         for (let nsi = 0; nsi < list[i].namespaces.length; nsi++)
  325.                         {
  326.                             if (!linkPortIn.op.objName.startsWith(list[i].namespaces[nsi])) break;
  327.                             nspoints++;
  328.                         }
  330.                     if (linkPortOut)
  331.                         for (let nsi = 0; nsi < list[i].namespaces.length; nsi++)
  332.                         {
  333.                             if (!linkPortOut.op.objName.startsWith(list[i].namespaces[nsi])) break;
  334.                             nspoints++;
  335.                         }
  337.                     if (nspoints > 0)
  338.                     {
  339.                         points += nspoints;
  340.                         scoreDebug += "+" + nspoints + " namespace similarity<br/>";
  341.                     }
  343.                     /// ////////////////////
  344.                     if (docs && docs.layout && docs.layout.portsIn && docs.layout.portsOut && docs.layout.portsIn.length > 0 && docs.layout.portsOut.length > 0)
  345.                     {
  347.                         // when inserting into link - find fitting ports
  348.                         if (linkPortIn && linkPortOut)
  349.                         {
  350.                             let foundPortTypeIn = false;
  351.                             for (let j = 0; j < docs.layout.portsIn.length; j++)
  352.                             {
  353.                                 if (docs.layout.portsIn[j] && docs.layout.portsIn[j].type == linkPortIn.type)
  354.                                 {
  355.                                     foundPortTypeIn = true;
  356.                                     break;
  357.                                 }
  358.                             }
  360.                             let foundPortTypeOut = false;
  361.                             for (let j = 0; j < docs.layout.portsOut.length; j++)
  362.                             {
  363.                                 if (docs.layout.portsOut[j] && docs.layout.portsOut[j].type == linkPortOut.type)
  364.                                 {
  365.                                     foundPortTypeOut = true;
  366.                                     break;
  367.                                 }
  368.                             }
  370.                             if (
  371.                                 docs.layout.portsIn[0] && docs.layout.portsOut[0] &&
  372.                                 docs.layout.portsIn[0].type == linkPortOut.type &&
  373.                                 docs.layout.portsOut[0].type == linkPortIn.type
  374.                             )
  375.                             {
  376.                                 points += firstportfitspoints;
  377.                                 scoreDebug += firstportfitsText;
  378.                             }
  380.                             if (!foundPortTypeOut && !foundPortTypeIn)
  381.                             {
  382.                                 points -= 5.0; // seems harsh, but is only used when dragging a port, so it should be fine...
  383.                                 scoreDebug += "-5.0 no compatible port found<br/>";
  384.                             }
  385.                         }
  387.                         // when dragging a port - find fitting  input/output port
  388.                         if (this.newOpOptions.linkNewOpToPort)
  389.                         {
  390.                             let foundPortType = false;
  391.                             if (this.newOpOptions.linkNewOpToPort.direction === Port.DIR_OUT)
  392.                             {
  393.                                 if (docs.layout.portsIn[0] && docs.layout.portsIn[0].type == this.newOpOptions.linkNewOpToPort.type)
  394.                                 {
  395.                                     points += firstportfitspoints;
  396.                                     scoreDebug += firstportfitsText;
  397.                                 }
  399.                                 for (let j = 0; j < docs.layout.portsIn.length; j++)
  400.                                 {
  401.                                     if (docs.layout.portsIn[j] && docs.layout.portsIn[j].type == this.newOpOptions.linkNewOpToPort.type)
  402.                                     {
  403.                                         foundPortType = true;
  404.                                         break;
  405.                                     }
  406.                                 }
  407.                             }
  408.                             else
  409.                             {
  410.                                 if (docs.layout.portsOut[0] && docs.layout.portsOut[0].type == this.newOpOptions.linkNewOpToPort.type)
  411.                                 {
  412.                                     points += firstportfitspoints;
  413.                                     scoreDebug += firstportfitsText;
  414.                                 }
  416.                                 for (let j = 0; j < docs.layout.portsOut.length; j++)
  417.                                 {
  418.                                     if (docs.layout.portsOut[j] && docs.layout.portsOut[j].type == this.newOpOptions.linkNewOpToPort.type)
  419.                                     {
  420.                                         foundPortType = true;
  421.                                         break;
  422.                                     }
  423.                                 }
  424.                             }
  426.                             if (!foundPortType)
  427.                             {
  428.                                 points -= 10.0; // seems harsh, but is only used when dragging a port, so it should be fine...
  429.                                 scoreDebug += "-10.0 no compatible port found<br/>";
  430.                             }
  431.                         }
  432.                     }
  433.                 }
  435.                 if (list[i]._shortName.indexOf(orig) === 0)
  436.                 {
  437.                     points += 2.5;
  438.                     scoreDebug += "+2.5 found in shortname at beginning (" + query + ")<br/>";
  440.                     if (list[i]._shortName == orig)
  441.                     {
  442.                         points += 2;
  443.                         scoreDebug += "+2 exact name (" + query + ")<br/>";
  444.                     }
  445.                 }
  447.                 if (list[i]._nameSpace.indexOf("ops.math") > -1)
  448.                 {
  449.                     points += 1;
  450.                     scoreDebug += "+1 is math op (" + query + ")<br/>";
  451.                 }
  452.                 else if (list[i]._nameSpace.indexOf("ops.patch") > -1)
  453.                 {
  454.                     points += 3;
  455.                     scoreDebug += "+1 is patch op (" + query + ")<br/>";
  456.                 }
  457.                 else if (list[i]._nameSpace.indexOf("ops.team") > -1)
  458.                 {
  459.                     points += 2;
  460.                     scoreDebug += "+2 is team op (" + query + ")<br/>";
  461.                 }
  463.                 const shortnessPoints = 2 * Math.round((1.0 - Math.min(1, (list[i]._nameSpace + list[i]._shortName).length / 100)) * 100) / 100;
  464.                 points += shortnessPoints;
  465.                 scoreDebug += "+" + shortnessPoints + " shortness namespace<br/>";
  466.             }
  468.             if (found && this._list[i].old)
  469.             {
  470.                 points -= 1;
  471.                 scoreDebug += "-1 outdated<br/>";
  472.             }
  474.             if (found && list[i].pop > 0)
  475.             {
  476.                 points += (list[i].pop || 2) / CABLES.UI.OPSELECT.maxPop || 1;
  477.             }
  479.             if (!found) points = 0;
  481.             if (points === 0 && list[i].score > 0) list[i].score = 0;
  482.             else list[i].score += points;
  484.             list[i].scoreDebug = (list[i].scoreDebug || "") + scoreDebug + " (" + Math.round(points * 100) / 100 + " points)<br/><br/>";
  485.         }
  487.         perf.finish();
  488.     }
  490.     /**
  491.      * @param {string} query
  492.      * @param {string} [originalSearch]
  493.      */
  494.     search(query, originalSearch)
  495.     {
  496.         this.preferGApi = gui.canvasManager.currentContextCg()?.gApi;
  498.         document.getElementById("realsearch").innerHTML = "";
  499.         document.getElementById("opOptions").innerHTML = "";
  500.         // if (!query) return console.log("no query");
  502.         const origQuery = query;
  503.         if (this._wordsDb) // search through word db
  504.         {
  505.             let q = query;
  506.             const queryParts = [];
  507.             let found = false;
  508.             do
  509.             {
  510.                 found = false;
  511.                 for (let i = 0; i < this._wordsDb.length; i++)
  512.                 {
  513.                     const idx = q.indexOf(this._wordsDb[i]);
  514.                     if (idx > -1) // && queryParts.indexOf(this._wordsDb[i])==-1
  515.                     {
  516.                         found = true;
  517.                         queryParts.push(this._wordsDb[i]);
  518.                         q = q.substr(0, idx) + " " + q.substr(idx + this._wordsDb[i].length, q.length - idx);
  519.                         break;
  520.                     }
  521.                 }
  522.             }
  523.             while (found);
  525.             if (queryParts.length > 0)
  526.             {
  527.                 let nquery = queryParts.join(" ");
  528.                 nquery += " " + q;
  529.                 if (nquery.trim() !== query) document.getElementById("realsearch").innerHTML = "Searching for: <b>" + nquery + "</b>";
  530.                 query = nquery;
  531.             }
  532.             else document.getElementById("realsearch").innerHTML = "";
  533.         }
  534.         else console.warn("no wordsdb");
  536.         if (query.length > 1 && this._list)
  537.         {
  538.             for (let i = 0; i < this._list.length; i++)
  539.             {
  540.                 this._list[i].score = 0;
  541.                 this._list[i].scoreDebug = "";
  542.             }
  544.             if (query.indexOf(" ") > -1)
  545.             {
  546.                 const words = query.split(" ");
  547.                 for (let i = 0; i < words.length; i++) { this._searchWord(i, origQuery, this._list, words[i]); }
  548.             }
  549.             else
  550.             {
  551.                 this._searchWord(0, query, this._list, originalSearch);
  552.             }
  553.         }
  554.     }
  556.     _rebuildWordList()
  557.     {
  558.         if (!this._list) return;
  559.         const buildWordDB = {};
  560.         for (let i = 0; i < this._list.length; i++)
  561.         {
  562.             const res = this._list[i].name.split(/(?=[A-Z,0-9,/.])/);
  564.             for (let j = 0; j < res.length; j++)
  565.             {
  566.                 if (res[j][res[j].length - 2] === "_") res[j] = res[j].substr(0, res[j].length - 2);
  567.                 if (res[j][0] === ".") res[j] = res[j].substr(1);
  568.                 if (res[j].length > 2) buildWordDB[res[j].toLowerCase()] = 1;
  569.             }
  571.             let shortName = "";
  572.             const ccParts = this._list[i].shortName.split(/(?=[A-Z,0-9,/.])/);
  573.             for (let j = 0; j < ccParts.length; j++)
  574.                 shortName += ccParts[j].substr(0, 1);
  575.             this._list[i].abbrev = shortName.toLocaleLowerCase();
  576.         }
  578.         this._wordsDb = Object.keys(buildWordDB);
  579.         this._wordsDb.sort((a, b) => { return b.length - a.length; });
  580.     }
  582.     _getOpsNamesFromCode(opnames, ns, val, parentname)
  583.     {
  584.         if (Object.prototype.toString.call(val) === "[object Object]")
  585.         {
  586.             for (const propertyName in val)
  587.             {
  588.                 if (val.hasOwnProperty(propertyName))
  589.                 {
  590.                     const opName = ns + "." + parentname + propertyName;
  591.                     if (typeof (Patch.getOpClass(opName)) === "function") opnames.push(opName);
  592.                     opnames = this._getOpsNamesFromCode(opnames, ns, val[propertyName], parentname + propertyName + ".");
  593.                 }
  594.             }
  595.         }
  596.         return opnames;
  597.     }
  599.     /**
  600.      * @param {string[]} _opNames
  601.      * @param {OpSearchListItem[]} [listItems]
  602.      * @returns {OpSearchListItem[]}
  603.      */
  604.     _createListItemsByNames(_opNames, listItems = [])
  605.     {
  606.         if (!_opNames) return;
  607.         const items = [];
  608.         for (let i = 0; i < _opNames.length; i++)
  609.         {
  610.             const opName = _opNames[i];
  611.             if (!opName) continue;
  612.             const parts = opName.split(".");
  613.             const lowerCaseName = opName.toLowerCase() + "_" + parts.join("").toLowerCase();
  614.             const opDoc = gui.opDocs.getOpDocByName(opName);
  615.             let shortName = opNames.getShortName(opName, true);
  616.             let hidden = false;
  617.             let opDocHidden = false;
  618.             let opId = null;
  620.             if (opDoc)
  621.             {
  622.                 opId = opDoc.id;
  623.                 opDocHidden = opDoc.hidden;
  624.                 hidden = opDoc.hidden;
  625.                 shortName = opDoc.shortNameDisplay;
  626.             }
  628.             if (namespace.isDevOp(opName) && !platform.isDevEnv()) hidden = true;
  630.             parts.length -= 1;
  631.             const nameSpace = parts.join(".");
  633.             if (namespace.isCollection(opName))
  634.             {
  635.                 const inUse = listItems && listItems.some((op) => { return op.name.startsWith(opName); });
  636.                 if (inUse) hidden = true;
  637.             }
  639.             if (!hidden)
  640.             {
  641.                 let oldState = "";
  642.                 if (hidden)oldState = "OLD";
  643.                 if (opDocHidden)oldState = "OLD";
  644.                 if (namespace.isDeprecatedOp(opName)) oldState = "DEPREC";
  646.                 let popularity = -1;
  647.                 let summary = gui.opDocs.getSummary(opName);
  648.                 let type = "op";
  649.                 if (namespace.isTeamNamespace(opName)) type = "team";
  650.                 if (namespace.isExtension(opName)) type = "extension";
  651.                 if (namespace.isPatchOp(opName)) type = "patchop";
  653.                 const isTeamOp = namespace.isTeamOp(opName);
  654.                 const isCollection = namespace.isCollection(opName);
  656.                 let collectionOpNames = null;
  657.                 if (isCollection)
  658.                 {
  659.                     const a = gui.opDocs.getNamespaceDocs(opName);
  660.                     if (a && a.length > 0 && a[0].ops) collectionOpNames = a[0].ops.join(" ").toLowerCase();
  661.                 }
  663.                 /** @type {OpSearchListItem} */
  664.                 const op = {
  665.                     "opId": opId || utils.simpleId(),
  666.                     "name": opName,
  667.                     "summary": summary,
  668.                     "collectionOpNames": collectionOpNames,
  669.                     "nscolor": opNames.getNamespaceClassName(opName),
  670.                     "isOp": !namespace.isCollection(opName),
  671.                     "userOp": namespace.isUserOp(opName),
  672.                     "devOp": namespace.isDevOp(opName),
  673.                     "extensionOp": namespace.isExtensionOp(opName),
  674.                     "teamOp": namespace.isTeamOp(opName),
  675.                     "patchOp": namespace.isPatchOp(opName),
  676.                     "isExtension": namespace.isExtension(opName),
  677.                     "isTeamNamespace": isTeamOp,
  678.                     "shortName": shortName,
  679.                     "nameSpace": nameSpace,
  680.                     "oldState": oldState,
  681.                     "lowercasename": lowerCaseName,
  682.                     "isCollection": isCollection,
  683.                     "buttonText": isCollection ? "Load" : "Add",
  684.                     "type": type,
  685.                     "pop": popularity,
  686.                     "namespaces": []
  688.                 };
  689.                 if (namespace.isCollection(opName))
  690.                 {
  691.                     op.isOp = false;
  692.                     op.pop = 1;
  693.                     if (opDoc)
  694.                     {
  695.                         op.summary = opDoc.summary;
  696.                         op.description = opDoc.description;
  697.                         op.teamName = opDoc.teamName;
  698.                         op.teamLink = opDoc.teamLink;
  699.                         op.numOps = opDoc.numOps;
  700.                         op.ops = opDoc.ops || [];
  701.                     }
  702.                 }
  704.                 let ns = "Ops";
  705.                 for (let j = 1; j < parts.length; j++)
  706.                 {
  707.                     ns += "." + parts[j];
  708.                     op.namespaces.push(ns);
  709.                 }
  711.                 items.push(op);
  712.             }
  713.         }
  714.         return items;
  715.     }
  716. }