matrix-react-sdk/lib/autocomplete/Autocompleter.js

SDK for matrix.org using React

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _CommandProvider = _interopRequireDefault(require("./CommandProvider"));

var _CommunityProvider = _interopRequireDefault(require("./CommunityProvider"));

var _DuckDuckGoProvider = _interopRequireDefault(require("./DuckDuckGoProvider"));

var _RoomProvider = _interopRequireDefault(require("./RoomProvider"));

var _UserProvider = _interopRequireDefault(require("./UserProvider"));

var _EmojiProvider = _interopRequireDefault(require("./EmojiProvider"));

var _NotifProvider = _interopRequireDefault(require("./NotifProvider"));

var _promise = require("../utils/promise");

var _SettingsStore = _interopRequireDefault(require("../settings/SettingsStore"));

var _SpaceProvider = _interopRequireDefault(require("./SpaceProvider"));

/*
Copyright 2016 Aviral Dasgupta
Copyright 2017, 2018 New Vector Ltd

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
const PROVIDERS = [_UserProvider.default, _RoomProvider.default, _EmojiProvider.default, _NotifProvider.default, _CommandProvider.default, _CommunityProvider.default, _DuckDuckGoProvider.default]; // as the spaces feature is device configurable only, and toggling it refreshes the page, we can do this here

if (_SettingsStore.default.getValue("feature_spaces")) {
  PROVIDERS.push(_SpaceProvider.default);
} // Providers will get rejected if they take longer than this.


const PROVIDER_COMPLETION_TIMEOUT = 3000;
/*:: export interface IProviderCompletions {
    completions: ICompletion[];
    provider: AutocompleteProvider;
    command: ICommand;
}*/

class Autocompleter {
  constructor(room
  /*: Room*/
  ) {
    (0, _defineProperty2.default)(this, "room", void 0);
    (0, _defineProperty2.default)(this, "providers", void 0);
    this.room = room;
    this.providers = PROVIDERS.map(Prov => {
      return new Prov(room);
    });
  }

  destroy() {
    this.providers.forEach(p => {
      p.destroy();
    });
  }

  async getCompletions(query
  /*: string*/
  , selection
  /*: ISelectionRange*/
  , force = false, limit = -1)
  /*: Promise<IProviderCompletions[]>*/
  {
    /* Note: This intentionally waits for all providers to return,
     otherwise, we run into a condition where new completions are displayed
     while the user is interacting with the list, which makes it difficult
     to predict whether an action will actually do what is intended
    */
    // list of results from each provider, each being a list of completions or null if it times out
    const completionsList
    /*: ICompletion[][]*/
    = await Promise.all(this.providers.map(async provider => {
      return await (0, _promise.timeout)(provider.getCompletions(query, selection, force, limit), null, PROVIDER_COMPLETION_TIMEOUT);
    })); // map then filter to maintain the index for the map-operation, for this.providers to line up

    return completionsList.map((completions, i) => {
      if (!completions || !completions.length) return;
      return {
        completions,
        provider: this.providers[i],

        /* the currently matched "command" the completer tried to complete
         * we pass this through so that Autocomplete can figure out when to
         * re-show itself once hidden.
         */
        command: this.providers[i].getCurrentCommand(query, selection, force)
      };
    }).filter(Boolean);
  }

}

exports.default = Autocompleter;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/autocomplete/Autocompleter.ts"],"names":["PROVIDERS","UserProvider","RoomProvider","EmojiProvider","NotifProvider","CommandProvider","CommunityProvider","DuckDuckGoProvider","SettingsStore","getValue","push","SpaceProvider","PROVIDER_COMPLETION_TIMEOUT","Autocompleter","constructor","room","providers","map","Prov","destroy","forEach","p","getCompletions","query","selection","force","limit","completionsList","Promise","all","provider","completions","i","length","command","getCurrentCommand","filter","Boolean"],"mappings":";;;;;;;;;;;AAmBA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAEA;;AACA;;AA7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAmCA,MAAMA,SAAS,GAAG,CACdC,qBADc,EAEdC,qBAFc,EAGdC,sBAHc,EAIdC,sBAJc,EAKdC,wBALc,EAMdC,0BANc,EAOdC,2BAPc,CAAlB,C,CAUA;;AACA,IAAIC,uBAAcC,QAAd,CAAuB,gBAAvB,CAAJ,EAA8C;AAC1CT,EAAAA,SAAS,CAACU,IAAV,CAAeC,sBAAf;AACH,C,CAED;;;AACA,MAAMC,2BAA2B,GAAG,IAApC;;AAlEA;AACA;AACA;AACA;;AAuEe,MAAMC,aAAN,CAAoB;AAI/BC,EAAAA,WAAW,CAACC;AAAD;AAAA,IAAa;AAAA;AAAA;AACpB,SAAKA,IAAL,GAAYA,IAAZ;AACA,SAAKC,SAAL,GAAiBhB,SAAS,CAACiB,GAAV,CAAeC,IAAD,IAAU;AACrC,aAAO,IAAIA,IAAJ,CAASH,IAAT,CAAP;AACH,KAFgB,CAAjB;AAGH;;AAEDI,EAAAA,OAAO,GAAG;AACN,SAAKH,SAAL,CAAeI,OAAf,CAAwBC,CAAD,IAAO;AAC1BA,MAAAA,CAAC,CAACF,OAAF;AACH,KAFD;AAGH;;AAED,QAAMG,cAAN,CACIC;AADJ;AAAA,IAEIC;AAFJ;AAAA,IAGIC,KAAK,GAAG,KAHZ,EAIIC,KAAK,GAAG,CAAC,CAJb;AAAA;AAKmC;AAC/B;AACR;AACA;AACA;AACA;AACQ;AACA,UAAMC;AAAgC;AAAA,MAAG,MAAMC,OAAO,CAACC,GAAR,CAAY,KAAKb,SAAL,CAAeC,GAAf,CAAmB,MAAMa,QAAN,IAAkB;AAC5F,aAAO,MAAM,sBACTA,QAAQ,CAACR,cAAT,CAAwBC,KAAxB,EAA+BC,SAA/B,EAA0CC,KAA1C,EAAiDC,KAAjD,CADS,EAET,IAFS,EAGTd,2BAHS,CAAb;AAKH,KAN0D,CAAZ,CAA/C,CAP+B,CAe/B;;AACA,WAAOe,eAAe,CAACV,GAAhB,CAAoB,CAACc,WAAD,EAAcC,CAAd,KAAoB;AAC3C,UAAI,CAACD,WAAD,IAAgB,CAACA,WAAW,CAACE,MAAjC,EAAyC;AAEzC,aAAO;AACHF,QAAAA,WADG;AAEHD,QAAAA,QAAQ,EAAE,KAAKd,SAAL,CAAegB,CAAf,CAFP;;AAIH;AAChB;AACA;AACA;AACgBE,QAAAA,OAAO,EAAE,KAAKlB,SAAL,CAAegB,CAAf,EAAkBG,iBAAlB,CAAoCZ,KAApC,EAA2CC,SAA3C,EAAsDC,KAAtD;AARN,OAAP;AAUH,KAbM,EAaJW,MAbI,CAaGC,OAbH,CAAP;AAcH;;AApD8B","sourcesContent":["/*\nCopyright 2016 Aviral Dasgupta\nCopyright 2017, 2018 New Vector Ltd\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport {ReactElement} from 'react';\nimport Room from 'matrix-js-sdk/src/models/room';\nimport CommandProvider from './CommandProvider';\nimport CommunityProvider from './CommunityProvider';\nimport DuckDuckGoProvider from './DuckDuckGoProvider';\nimport RoomProvider from './RoomProvider';\nimport UserProvider from './UserProvider';\nimport EmojiProvider from './EmojiProvider';\nimport NotifProvider from './NotifProvider';\nimport {timeout} from \"../utils/promise\";\nimport AutocompleteProvider, {ICommand} from \"./AutocompleteProvider\";\nimport SettingsStore from \"../settings/SettingsStore\";\nimport SpaceProvider from \"./SpaceProvider\";\n\nexport interface ISelectionRange {\n    beginning?: boolean; // whether the selection is in the first block of the editor or not\n    start: number; // byte offset relative to the start anchor of the current editor selection.\n    end: number; // byte offset relative to the end anchor of the current editor selection.\n}\n\nexport interface ICompletion {\n    type: \"at-room\" | \"command\" | \"community\" | \"room\" | \"user\";\n    completion: string;\n    completionId?: string;\n    component?: ReactElement;\n    range: ISelectionRange;\n    command?: string;\n    suffix?: string;\n    // If provided, apply a LINK entity to the completion with the\n    // data = { url: href }.\n    href?: string;\n}\n\nconst PROVIDERS = [\n    UserProvider,\n    RoomProvider,\n    EmojiProvider,\n    NotifProvider,\n    CommandProvider,\n    CommunityProvider,\n    DuckDuckGoProvider,\n];\n\n// as the spaces feature is device configurable only, and toggling it refreshes the page, we can do this here\nif (SettingsStore.getValue(\"feature_spaces\")) {\n    PROVIDERS.push(SpaceProvider);\n}\n\n// Providers will get rejected if they take longer than this.\nconst PROVIDER_COMPLETION_TIMEOUT = 3000;\n\nexport interface IProviderCompletions {\n    completions: ICompletion[];\n    provider: AutocompleteProvider;\n    command: ICommand;\n}\n\nexport default class Autocompleter {\n    room: Room;\n    providers: AutocompleteProvider[];\n\n    constructor(room: Room) {\n        this.room = room;\n        this.providers = PROVIDERS.map((Prov) => {\n            return new Prov(room);\n        });\n    }\n\n    destroy() {\n        this.providers.forEach((p) => {\n            p.destroy();\n        });\n    }\n\n    async getCompletions(\n        query: string,\n        selection: ISelectionRange,\n        force = false,\n        limit = -1,\n    ): Promise<IProviderCompletions[]> {\n        /* Note: This intentionally waits for all providers to return,\n         otherwise, we run into a condition where new completions are displayed\n         while the user is interacting with the list, which makes it difficult\n         to predict whether an action will actually do what is intended\n        */\n        // list of results from each provider, each being a list of completions or null if it times out\n        const completionsList: ICompletion[][] = await Promise.all(this.providers.map(async provider => {\n            return await timeout(\n                provider.getCompletions(query, selection, force, limit),\n                null,\n                PROVIDER_COMPLETION_TIMEOUT,\n            );\n        }));\n\n        // map then filter to maintain the index for the map-operation, for this.providers to line up\n        return completionsList.map((completions, i) => {\n            if (!completions || !completions.length) return;\n\n            return {\n                completions,\n                provider: this.providers[i],\n\n                /* the currently matched \"command\" the completer tried to complete\n                 * we pass this through so that Autocomplete can figure out when to\n                 * re-show itself once hidden.\n                 */\n                command: this.providers[i].getCurrentCommand(query, selection, force),\n            };\n        }).filter(Boolean);\n    }\n}\n"]}