Home Reference Source

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

  1. import { Events } from "cables-shared-client";
  2. import { CG, CgContext } from "cables-corelibs";
  3. import { 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.  * search through opdocs, e.g. for opselect
  12.  *
  13.  * @export
  14.  * @class OpSearch
  15.  * @extends {Events}
  16.  */
  17. export default class OpSearch extends Events
  18. {
  19.     _newOpOptions = {};
  20.     constructor()
  21.     {
  22.         super();
  23.         this._list = null;
  24.         this._wordsDb = null;
  25.         this.numPatchops = 0;
  26.         this.originalSearch = "";
  27.         this.hideUserOps = false;
  28.     }
  30.     get list()
  31.     {
  32.         return this._list;
  33.     }
  35.     resetList()
  36.     {
  37.         this._list = null;
  38.     }
  40.     _buildList()
  41.     {
  42.         const perf = gui.uiProfiler.start("opsearch.getlist");
  44.         const codeOpNames = this._getOpsNamesFromCode([], "Ops", Ops, "");
  45.         let items = this._createListItemsByNames(codeOpNames);
  47.         const docOpName = gui.opDocs.getOpDocs().map((ext) => { return ext.name; });
  48.         items = items.concat(this._createListItemsByNames(docOpName, items));
  50.         const extensionNames = gui.opDocs.getExtensions().map((ext) => { return ext.name; });
  51.         items = items.concat(this._createListItemsByNames(extensionNames, items));
  53.         const teamNamespaces = gui.opDocs.getTeamNamespaces().map((ext) => { return ext.name; });
  54.         items = items.concat(this._createListItemsByNames(teamNamespaces, items));
  56.         const ns = platform.getPatchOpsNamespace();
  57.         const patchOpNames = gui.opDocs.getNamespaceDocs(ns).map((ext) => { return ext.name; });
  59.         this.numPatchops = utils.uniqueArray(patchOpNames || []).length;
  60.         items = items.concat(this._createListItemsByNames(patchOpNames, items));
  62.         const newList = {};
  63.         items.forEach((item) =>
  64.         {
  65.             if (!newList.hasOwnProperty(item.opId))
  66.             {
  67.                 newList[item.opId] = item;
  68.             }
  69.         });
  71.         this._list = Object.values(newList);
  72.         this._list.sort((a, b) => { return b.pop - a.pop; });
  73.         perf.finish();
  75.         /// --------------
  77.         let maxPop = 0;
  79.         for (let i = 0; i < this._list.length; i++)
  80.         {
  81.             if (!this._list[i].shortName) this._list[i].shortName = this._list[i].name;
  83.             maxPop = Math.max(this._list[i].pop || 0, maxPop);
  84.             this._list[i].id = i;
  85.             this._list[i].summary = this._list[i].summary || "";
  86.             this._list[i]._summary = this._list[i].summary.toLowerCase();
  87.             this._list[i]._shortName = this._list[i].shortName.toLowerCase();
  88.             this._list[i]._lowerCaseName = this._list[i].name.toLowerCase();
  89.             this._list[i]._nameSpace = this._list[i].nameSpace.toLowerCase() + ".";
  90.             this._list[i]._nameSpaceFull = this._list[i].nameSpace.toLowerCase() + "." + this._list[i].shortName.toLowerCase();
  92.             const opdoc = gui.opDocs.getOpDocByName(this._list[i].name);
  93.             if (namespace.isDeprecatedOp(this._list[i].name) || (opdoc && opdoc.oldVersion)) this._list[i].old = true;
  94.         }
  95.         this._rebuildWordList();
  96.         CABLES.UI.OPSELECT.maxPop = maxPop;
  97.     }
  99.     _searchWord(wordIndex, orig, list, query)
  100.     {
  101.         if (!query || query === " " || query === "") return;
  103.         const perf = gui.uiProfiler.start("opsearch._searchWord");
  105.         for (let i = 0; i < list.length; i++)
  106.         {
  107.             if (wordIndex > 0 && list[i].score === 0) continue; // when second word was found, but first was not
  109.             let scoreDebug = "<b>Query: " + query + " </b><br/>";
  110.             let found = false;
  111.             let points = 0;
  113.             if (list[i].lowercasename.indexOf(query) > -1)
  114.             {
  115.                 if (list[i].name === defaultOps.glMainloop)
  116.                 {
  117.                     found = true;
  118.                     scoreDebug += "+2 vip op<br/>";
  119.                     points += 2;
  120.                 }
  121.             }
  123.             if (this.prefereGApi == CgContext.API_WEBGL)
  124.             {
  125.                 if (list[i].name.startsWith(defaultOps.prefixes.webgpu))
  126.                 {
  127.                     found = true;
  128.                     scoreDebug += "-5 different graphics api<br/>";
  129.                     points -= 5;
  130.                 }
  131.             }
  132.             else if (this.prefereGApi == CgContext.API_WEBGPU)
  133.             {
  134.                 if (list[i].name.startsWith(defaultOps.prefixes.webgl))
  135.                 {
  136.                     found = true;
  137.                     scoreDebug += "-5 different graphics api<br/>";
  138.                     points -= 5;
  139.                 }
  140.             }
  142.             if (list[i].abbrev && list[i].abbrev.indexOf(orig) === 0)
  143.             {
  144.                 found = true;
  145.                 let p = 4;
  146.                 if (orig.length === 2)p = 12;
  147.                 if (orig.length === 3)p = 10;
  148.                 if (orig.length === 4)p = 8;
  150.                 if (query === query.toUpperCase())
  151.                 {
  152.                     const ppo = 5;
  153.                     p += ppo;
  154.                     scoreDebug += "+" + ppo + " uppercase abbreviation<br/>";
  155.                 }
  157.                 scoreDebug += "+" + p + " abbreviation<br/>";
  159.                 points += p;
  160.             }
  162.             if (list[i].userOp && this.hideUserOps) continue;
  164.             if (list[i]._summary.indexOf(query) > -1)
  165.             {
  166.                 found = true;
  167.                 points += 1;
  168.                 scoreDebug += "+1 found in summary (" + query + ")<br/>";
  169.             }
  171.             if (list[i]._nameSpace.indexOf(query) > -1)
  172.             {
  173.                 found = true;
  174.                 points += 1;
  175.                 scoreDebug += "+1 found in namespace (" + query + ")<br/>";
  176.             }
  178.             if (list[i]._shortName.indexOf(query) > -1)
  179.             {
  180.                 found = true;
  181.                 points += 4;
  182.                 scoreDebug += "+4 found in shortname (" + query + ")<br/>";
  183.             }
  185.             if (list[i]._shortName == query)
  186.             {
  187.                 found = true;
  188.                 points += 5;
  189.                 scoreDebug += "+5 query quals shortname<br/>";
  190.             }
  192.             if (orig.length > 1 && list[i]._lowerCaseName.indexOf(orig) > -1)
  193.             {
  194.                 found = true;
  195.                 points += 2;
  196.                 scoreDebug += "+2 found full namespace (" + query + ")<br/>";
  197.             }
  199.             if (points == 0)
  200.             {
  201.                 if (list[i]._lowerCaseName.indexOf(query) > -1)
  202.                 {
  203.                     found = true;
  204.                     points += 2;
  205.                     scoreDebug += "+2 found full namespace (" + query + ")<br/>";
  206.                 }
  207.             }
  209.             if (list[i].collectionOpNames && list[i].collectionOpNames.indexOf(orig) > -1)
  210.             {
  211.                 found = true;
  212.                 points += 1;
  213.                 scoreDebug += "+1 is op in collection (" + query + ")<br/>";
  214.             }
  216.             if (found)
  217.             {
  218.                 if (this._newOpOptions)
  219.                 {
  220.                     const firstportfitspoints = 3;
  221.                     const firstportfitsText = "+3 First Port fits<br/>";
  223.                     const docs = gui.opDocs.getOpDocByName(list[i].name);
  225.                     if (docs && docs.hasOwnProperty("version"))
  226.                     {
  227.                         const p = docs.version * 0.01;
  228.                         points += p;
  229.                         scoreDebug += "+" + p + " version<br/>";
  230.                     }
  232.                     if (docs && docs.layout && docs.layout.portsIn && docs.layout.portsOut && docs.layout.portsIn.length > 0 && docs.layout.portsOut.length > 0)
  233.                     {
  234.                         // when inserting into link - find fitting ports
  235.                         if (this._newOpOptions.linkNewLink)
  236.                         {
  237.                             let foundPortTypeIn = false;
  238.                             for (let j = 0; j < docs.layout.portsIn.length; j++)
  239.                             {
  240.                                 if (docs.layout.portsIn[j] &&
  241.                                     this._newOpOptions.linkNewLink.portIn &&
  242.                                     docs.layout.portsIn[j].type == this._newOpOptions.linkNewLink.portIn.type)
  243.                                 {
  244.                                     foundPortTypeIn = true;
  245.                                     break;
  246.                                 }
  247.                             }
  249.                             let foundPortTypeOut = false;
  250.                             for (let j = 0; j < docs.layout.portsOut.length; j++)
  251.                             {
  252.                                 if (docs.layout.portsOut[j].type == this._newOpOptions.linkNewLink.portOut.type)
  253.                                 {
  254.                                     foundPortTypeOut = true;
  255.                                     break;
  256.                                 }
  257.                             }
  259.                             if (
  260.                                 docs.layout.portsIn[0].type == this._newOpOptions.linkNewLink.portOut.type &&
  261.                                 docs.layout.portsOut[0].type == this._newOpOptions.linkNewLink.portIn.type
  262.                             )
  263.                             {
  264.                                 points += firstportfitspoints;
  265.                                 scoreDebug += firstportfitsText;
  266.                             }
  268.                             if (!foundPortTypeOut && !foundPortTypeIn)
  269.                             {
  270.                                 points -= 5.0; // seems harsh, but is only used when dragging a port, so it should be fine...
  271.                                 scoreDebug += "-5.0 no compatible port found<br/>";
  272.                             }
  273.                         }
  275.                         // when dragging a port - find fitting  input/output port
  276.                         if (this._newOpOptions.linkNewOpToPort)
  277.                         {
  278.                             let foundPortType = false;
  279.                             if (this._newOpOptions.linkNewOpToPort.direction === Port.DIR_OUT)
  280.                             {
  281.                                 if (docs.layout.portsIn[0].type == this._newOpOptions.linkNewOpToPort.type)
  282.                                 {
  283.                                     points += firstportfitspoints;
  284.                                     scoreDebug += firstportfitsText;
  285.                                 }
  287.                                 for (let j = 0; j < docs.layout.portsIn.length; j++)
  288.                                 {
  289.                                     if (docs.layout.portsIn[j].type == this._newOpOptions.linkNewOpToPort.type)
  290.                                     {
  291.                                         foundPortType = true;
  292.                                         break;
  293.                                     }
  294.                                 }
  295.                             }
  296.                             else
  297.                             {
  298.                                 if (docs.layout.portsOut[0].type == this._newOpOptions.linkNewOpToPort.type)
  299.                                 {
  300.                                     points += firstportfitspoints;
  301.                                     scoreDebug += firstportfitsText;
  302.                                 }
  304.                                 for (let j = 0; j < docs.layout.portsOut.length; j++)
  305.                                 {
  306.                                     if (docs.layout.portsOut[j].type == this._newOpOptions.linkNewOpToPort.type)
  307.                                     {
  308.                                         foundPortType = true;
  309.                                         break;
  310.                                     }
  311.                                 }
  312.                             }
  314.                             if (!foundPortType)
  315.                             {
  316.                                 points -= 10.0; // seems harsh, but is only used when dragging a port, so it should be fine...
  317.                                 scoreDebug += "-10.0 no comparible port found<br/>";
  318.                             }
  319.                         }
  320.                     }
  321.                 }
  323.                 if (list[i]._shortName.indexOf(orig) === 0)
  324.                 {
  325.                     points += 2.5;
  326.                     scoreDebug += "+2.5 found in shortname at beginning (" + query + ")<br/>";
  328.                     if (list[i]._shortName == orig)
  329.                     {
  330.                         points += 2;
  331.                         scoreDebug += "+2 exact name (" + query + ")<br/>";
  332.                     }
  333.                 }
  335.                 if (list[i]._nameSpace.indexOf("ops.math") > -1)
  336.                 {
  337.                     points += 1;
  338.                     scoreDebug += "+1 is math op (" + query + ")<br/>";
  339.                 }
  340.                 else if (list[i]._nameSpace.indexOf("ops.patch") > -1)
  341.                 {
  342.                     points += 3;
  343.                     scoreDebug += "+1 is patch op (" + query + ")<br/>";
  344.                 }
  345.                 else if (list[i]._nameSpace.indexOf("ops.team") > -1)
  346.                 {
  347.                     points += 2;
  348.                     scoreDebug += "+2 is team op (" + query + ")<br/>";
  349.                 }
  351.                 const shortnessPoints = 2 * Math.round((1.0 - Math.min(1, (list[i]._nameSpace + list[i]._shortName).length / 100)) * 100) / 100;
  352.                 points += shortnessPoints;
  353.                 scoreDebug += "+" + shortnessPoints + " shortness namespace<br/>";
  354.             }
  356.             if (found && this._list[i].old)
  357.             {
  358.                 points -= 1;
  359.                 scoreDebug += "-1 outdated<br/>";
  360.             }
  362.             if (found && list[i].pop > 0)
  363.             {
  364.                 points += (list[i].pop || 2) / CABLES.UI.OPSELECT.maxPop || 1;
  365.             }
  367.             if (found && this._list[i].notUsable)
  368.             {
  369.                 points = 0.1;
  370.                 scoreDebug += "0.1 not usable<br/>";
  371.             }
  373.             if (!found) points = 0;
  375.             if (points === 0 && list[i].score > 0) list[i].score = 0;
  376.             else list[i].score += points;
  378.             list[i].scoreDebug = (list[i].scoreDebug || "") + scoreDebug + " (" + Math.round(points * 100) / 100 + " points)<br/><br/>";
  379.         }
  381.         perf.finish();
  382.     }
  384.     /**
  385.      * @param {string} query
  386.      * @param {string} [originalSearch]
  387.      */
  388.     search(query, originalSearch)
  389.     {
  391.         this.prefereGApi = gui.canvasManager.currentContextCg()?.gApi;
  393.         document.getElementById("realsearch").innerHTML = "";
  394.         document.getElementById("opOptions").innerHTML = "";
  395.         if (!query) return;
  397.         const origQuery = query;
  398.         if (this._wordsDb) // search through word db
  399.         {
  400.             let q = query;
  401.             const queryParts = [];
  402.             let found = false;
  403.             do
  404.             {
  405.                 found = false;
  406.                 for (let i = 0; i < this._wordsDb.length; i++)
  407.                 {
  408.                     const idx = q.indexOf(this._wordsDb[i]);
  409.                     if (idx > -1) // && queryParts.indexOf(this._wordsDb[i])==-1
  410.                     {
  411.                         found = true;
  412.                         queryParts.push(this._wordsDb[i]);
  413.                         q = q.substr(0, idx) + " " + q.substr(idx + this._wordsDb[i].length, q.length - idx);
  414.                         break;
  415.                     }
  416.                 }
  417.             }
  418.             while (found);
  420.             if (queryParts.length > 0)
  421.             {
  422.                 let nquery = queryParts.join(" ");
  423.                 nquery += " " + q;
  424.                 if (nquery.trim() !== query) document.getElementById("realsearch").innerHTML = "Searching for: <b>" + nquery + "</b>";
  425.                 query = nquery;
  426.             }
  427.             else document.getElementById("realsearch").innerHTML = "";
  428.         }
  429.         if (query.length > 1 && this._list)
  430.         {
  431.             for (let i = 0; i < this._list.length; i++)
  432.             {
  433.                 this._list[i].score = 0;
  434.                 this._list[i].scoreDebug = "";
  435.             }
  437.             if (query.indexOf(" ") > -1)
  438.             {
  439.                 const words = query.split(" ");
  440.                 for (let i = 0; i < words.length; i++) { this._searchWord(i, origQuery, this._list, words[i]); }
  441.             }
  442.             else
  443.             {
  444.                 this._searchWord(0, query, this._list, originalSearch);
  445.             }
  446.         }
  447.     }
  449.     _rebuildWordList()
  450.     {
  451.         if (!this._list) return;
  452.         const buildWordDB = {};
  453.         for (let i = 0; i < this._list.length; i++)
  454.         {
  455.             const res = this._list[i].name.split(/(?=[A-Z,0-9,/.])/);
  457.             for (let j = 0; j < res.length; j++)
  458.             {
  459.                 if (res[j][res[j].length - 2] === "_") res[j] = res[j].substr(0, res[j].length - 2);
  460.                 if (res[j][0] === ".") res[j] = res[j].substr(1);
  461.                 if (res[j].length > 2) buildWordDB[res[j].toLowerCase()] = 1;
  462.             }
  464.             let shortName = "";
  465.             const ccParts = this._list[i].shortName.split(/(?=[A-Z,0-9,/.])/);
  466.             for (let j = 0; j < ccParts.length; j++)
  467.                 shortName += ccParts[j].substr(0, 1);
  468.             this._list[i].abbrev = shortName.toLocaleLowerCase();
  469.         }
  471.         this._wordsDb = Object.keys(buildWordDB);
  472.         this._wordsDb.sort((a, b) => { return b.length - a.length; });
  473.     }
  475.     _getOpsNamesFromCode(opnames, ns, val, parentname)
  476.     {
  477.         if (Object.prototype.toString.call(val) === "[object Object]")
  478.         {
  479.             for (const propertyName in val)
  480.             {
  481.                 if (val.hasOwnProperty(propertyName))
  482.                 {
  483.                     const opName = ns + "." + parentname + propertyName;
  484.                     if (typeof (Patch.getOpClass(opName)) === "function") opnames.push(opName);
  485.                     opnames = this._getOpsNamesFromCode(opnames, ns, val[propertyName], parentname + propertyName + ".");
  486.                 }
  487.             }
  488.         }
  489.         return opnames;
  490.     }
  492.     _createListItemsByNames(_opNames, listItems = [])
  493.     {
  494.         if (!_opNames) return;
  495.         const items = [];
  496.         for (let i = 0; i < _opNames.length; i++)
  497.         {
  498.             const opName = _opNames[i];
  499.             if (!opName) continue;
  500.             const parts = opName.split(".");
  501.             const lowerCaseName = opName.toLowerCase() + "_" + parts.join("").toLowerCase();
  502.             const opDoc = gui.opDocs.getOpDocByName(opName);
  503.             let shortName = parts[parts.length - 1];
  504.             let hidden = false;
  505.             let opDocHidden = false;
  506.             let opId = null;
  508.             if (opDoc)
  509.             {
  510.                 opId = opDoc.id;
  511.                 opDocHidden = opDoc.hidden;
  512.                 hidden = opDoc.hidden;
  513.                 shortName = opDoc.shortNameDisplay;
  514.             }
  516.             if (namespace.isDevOp(opName) && !platform.isDevEnv()) hidden = true;
  518.             parts.length -= 1;
  519.             const nameSpace = parts.join(".");
  521.             if (namespace.isCollection(opName))
  522.             {
  523.                 const inUse = listItems && listItems.some((op) => { return op.name.startsWith(opName); });
  524.                 if (inUse) hidden = true;
  525.             }
  527.             if (!hidden)
  528.             {
  529.                 let oldState = "";
  530.                 if (hidden)oldState = "OLD";
  531.                 if (opDocHidden)oldState = "OLD";
  532.                 if (namespace.isDeprecatedOp(opName)) oldState = "DEPREC";
  534.                 let popularity = -1;
  535.                 let summary = gui.opDocs.getSummary(opName);
  536.                 let type = "op";
  537.                 if (namespace.isTeamNamespace(opName)) type = "team";
  538.                 if (namespace.isExtension(opName)) type = "extension";
  539.                 if (namespace.isPatchOp(opName)) type = "patchop";
  541.                 const isTeamOp = namespace.isTeamOp(opName);
  542.                 const isCollection = namespace.isCollection(opName);
  544.                 let collectionOpNames = null;
  545.                 if (isCollection)
  546.                 {
  547.                     const a = gui.opDocs.getNamespaceDocs(opName);
  548.                     if (a && a.length > 0 && a[0].ops) collectionOpNames = a[0].ops.join(" ").toLowerCase();
  549.                 }
  551.                 const op = {
  552.                     "opId": opId || utils.simpleId(),
  553.                     "name": opName,
  554.                     "summary": summary,
  555.                     "collectionOpNames": collectionOpNames,
  556.                     "nscolor": opNames.getNamespaceClassName(opName),
  557.                     "isOp": !namespace.isCollection(opName),
  558.                     "userOp": namespace.isUserOp(opName),
  559.                     "devOp": namespace.isDevOp(opName),
  560.                     "extensionOp": namespace.isExtensionOp(opName),
  561.                     "teamOp": namespace.isTeamOp(opName),
  562.                     "patchOp": namespace.isPatchOp(opName),
  563.                     "isExtension": namespace.isExtension(opName),
  564.                     "isTeamNamespace": isTeamOp,
  565.                     "shortName": shortName,
  566.                     "nameSpace": nameSpace,
  567.                     "oldState": oldState,
  568.                     "lowercasename": lowerCaseName,
  569.                     "isCollection": isCollection,
  570.                     "buttonText": isCollection ? "Load" : "Add",
  571.                     "type": type,
  572.                     "pop": popularity,
  574.                 };
  575.                 if (opDoc && opDoc.notUsable)
  576.                 {
  577.                     op.notUsable = true;
  578.                     op.notUsableReasons = opDoc.notUsableReasons;
  579.                 }
  580.                 if (namespace.isCollection(opName))
  581.                 {
  582.                     op.isOp = false;
  583.                     op.pop = 1;
  584.                     if (opDoc)
  585.                     {
  586.                         op.summary = opDoc.summary;
  587.                         op.description = opDoc.description;
  588.                         op.teamName = opDoc.teamName;
  589.                         op.teamLink = opDoc.teamLink;
  590.                         op.numOps = opDoc.numOps;
  591.                         op.ops = opDoc.ops || [];
  592.                     }
  593.                 }
  594.                 items.push(op);
  595.             }
  596.         }
  597.         return items;
  598.     }
  599. }