matrix-react-sdk
Version:
SDK for matrix.org using React
169 lines (143 loc) • 14.9 kB
JavaScript
;
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.Singleflight = void 0;
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _maps = require("./maps");
/*
Copyright 2021 The Matrix.org Foundation C.I.C.
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.
*/
// Inspired by https://pkg.go.dev/golang.org/x/sync/singleflight
const keyMap = new _maps.EnhancedMap();
/**
* Access class to get a singleflight context. Singleflights execute a
* function exactly once, unless instructed to forget about a result.
*
* Typically this is used to de-duplicate an action, such as a save button
* being pressed, without having to track state internally for an operation
* already being in progress. This doesn't expose a flag which can be used
* to disable a button, however it would be capable of returning a Promise
* from the first call.
*
* The result of the function call is cached indefinitely, just in case a
* second call comes through late. There are various functions named "forget"
* to have the cache be cleared of a result.
*
* Singleflights in our usecase are tied to an instance of something, combined
* with a string key to differentiate between multiple possible actions. This
* means that a "save" key will be scoped to the instance which defined it and
* not leak between other instances. This is done to avoid having to concatenate
* variables to strings to essentially namespace the field, for most cases.
*/
class Singleflight {
constructor() {}
/**
* A void marker to help with returning a value in a singleflight context.
* If your code doesn't return anything, return this instead.
*/
/**
* Acquire a singleflight context.
* @param {Object} instance An instance to associate the context with. Can be any object.
* @param {string} key A string key relevant to that instance to namespace under.
* @returns {SingleflightContext} Returns the context to execute the function.
*/
static for(instance
/*: Object*/
, key
/*: string*/
)
/*: SingleflightContext*/
{
if (!instance || !key) throw new Error("An instance and key must be supplied");
return new SingleflightContext(instance, key);
}
/**
* Forgets all results for a given instance.
* @param {Object} instance The instance to forget about.
*/
static forgetAllFor(instance
/*: Object*/
) {
keyMap.delete(instance);
}
/**
* Forgets all cached results for all instances. Intended for use by tests.
*/
static forgetAll() {
for (const k of keyMap.keys()) {
keyMap.remove(k);
}
}
}
exports.Singleflight = Singleflight;
(0, _defineProperty2.default)(Singleflight, "Void", Symbol("void"));
class SingleflightContext {
constructor(instance
/*: Object*/
, key
/*: string*/
) {
this.instance
/*:: */
= instance
/*:: */
;
this.key
/*:: */
= key
/*:: */
;
}
/**
* Forget this particular instance and key combination, discarding the result.
*/
forget() {
const map = keyMap.get(this.instance);
if (!map) return;
map.remove(this.key);
if (!map.size) keyMap.remove(this.instance);
}
/**
* Execute a function. If a result is already known, that will be returned instead
* of executing the provided function. However, if no result is known then the function
* will be called, with its return value cached. The function must return a value
* other than `undefined` - take a look at Singleflight.Void if you don't have a return
* to make.
*
* Note that this technically allows the caller to provide a different function each time:
* this is largely considered a bad idea and should not be done. Singleflights work off the
* premise that something needs to happen once, so duplicate executions will be ignored.
*
* For ideal performance and behaviour, functions which return promises are preferred. If
* a function is not returning a promise, it should return as soon as possible to avoid a
* second call potentially racing it. The promise returned by this function will be that
* of the first execution of the function, even on duplicate calls.
* @param {Function} fn The function to execute.
* @returns The recorded value.
*/
do(fn
/*: () => T*/
)
/*: T*/
{
const map = keyMap.getOrCreate(this.instance, new _maps.EnhancedMap()); // We have to manually getOrCreate() because we need to execute the fn
let val = map.get(this.key);
if (val === undefined) {
val = fn();
map.set(this.key, val);
}
return val;
}
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/utils/Singleflight.ts"],"names":["keyMap","EnhancedMap","Singleflight","constructor","for","instance","key","Error","SingleflightContext","forgetAllFor","delete","forgetAll","k","keys","remove","Symbol","forget","map","get","size","do","fn","getOrCreate","val","undefined","set"],"mappings":";;;;;;;;;;;AAgBA;;AAhBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAIA;AAEA,MAAMA,MAAM,GAAG,IAAIC,iBAAJ,EAAf;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACO,MAAMC,YAAN,CAAmB;AACdC,EAAAA,WAAR,GAAsB,CACrB;AAED;AACJ;AACA;AACA;;;AAGI;AACJ;AACA;AACA;AACA;AACA;AACI,SAAcC,GAAd,CAAkBC;AAAlB;AAAA,IAAoCC;AAApC;AAAA;AAAA;AAAsE;AAClE,QAAI,CAACD,QAAD,IAAa,CAACC,GAAlB,EAAuB,MAAM,IAAIC,KAAJ,CAAU,sCAAV,CAAN;AACvB,WAAO,IAAIC,mBAAJ,CAAwBH,QAAxB,EAAkCC,GAAlC,CAAP;AACH;AAED;AACJ;AACA;AACA;;;AACI,SAAcG,YAAd,CAA2BJ;AAA3B;AAAA,IAA6C;AACzCL,IAAAA,MAAM,CAACU,MAAP,CAAcL,QAAd;AACH;AAED;AACJ;AACA;;;AACI,SAAcM,SAAd,GAA0B;AACtB,SAAK,MAAMC,CAAX,IAAgBZ,MAAM,CAACa,IAAP,EAAhB,EAA+B;AAC3Bb,MAAAA,MAAM,CAACc,MAAP,CAAcF,CAAd;AACH;AACJ;;AApCqB;;;8BAAbV,Y,UAQYa,MAAM,CAAC,MAAD,C;;AA+B/B,MAAMP,mBAAN,CAA0B;AACfL,EAAAA,WAAP,CAA2BE;AAA3B;AAAA,IAAqDC;AAArD;AAAA,IAAkE;AAAA,SAAvCD;AAAuC;AAAA,MAAvCA;AAAuC;AAAA;AAAA,SAAbC;AAAa;AAAA,MAAbA;AAAa;AAAA;AACjE;AAED;AACJ;AACA;;;AACWU,EAAAA,MAAP,GAAgB;AACZ,UAAMC,GAAG,GAAGjB,MAAM,CAACkB,GAAP,CAAW,KAAKb,QAAhB,CAAZ;AACA,QAAI,CAACY,GAAL,EAAU;AACVA,IAAAA,GAAG,CAACH,MAAJ,CAAW,KAAKR,GAAhB;AACA,QAAI,CAACW,GAAG,CAACE,IAAT,EAAenB,MAAM,CAACc,MAAP,CAAc,KAAKT,QAAnB;AAClB;AAED;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACWe,EAAAA,EAAP,CAAaC;AAAb;AAAA;AAAA;AAA6B;AACzB,UAAMJ,GAAG,GAAGjB,MAAM,CAACsB,WAAP,CAAmB,KAAKjB,QAAxB,EAAkC,IAAIJ,iBAAJ,EAAlC,CAAZ,CADyB,CAGzB;;AACA,QAAIsB,GAAG,GAAMN,GAAG,CAACC,GAAJ,CAAQ,KAAKZ,GAAb,CAAb;;AACA,QAAIiB,GAAG,KAAKC,SAAZ,EAAuB;AACnBD,MAAAA,GAAG,GAAGF,EAAE,EAAR;AACAJ,MAAAA,GAAG,CAACQ,GAAJ,CAAQ,KAAKnB,GAAb,EAAkBiB,GAAlB;AACH;;AAED,WAAOA,GAAP;AACH;;AA3CqB","sourcesContent":["/*\nCopyright 2021 The Matrix.org Foundation C.I.C.\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 {EnhancedMap} from \"./maps\";\n\n// Inspired by https://pkg.go.dev/golang.org/x/sync/singleflight\n\nconst keyMap = new EnhancedMap<Object, EnhancedMap<string, unknown>>();\n\n/**\n * Access class to get a singleflight context. Singleflights execute a\n * function exactly once, unless instructed to forget about a result.\n *\n * Typically this is used to de-duplicate an action, such as a save button\n * being pressed, without having to track state internally for an operation\n * already being in progress. This doesn't expose a flag which can be used\n * to disable a button, however it would be capable of returning a Promise\n * from the first call.\n *\n * The result of the function call is cached indefinitely, just in case a\n * second call comes through late. There are various functions named \"forget\"\n * to have the cache be cleared of a result.\n *\n * Singleflights in our usecase are tied to an instance of something, combined\n * with a string key to differentiate between multiple possible actions. This\n * means that a \"save\" key will be scoped to the instance which defined it and\n * not leak between other instances. This is done to avoid having to concatenate\n * variables to strings to essentially namespace the field, for most cases.\n */\nexport class Singleflight {\n    private constructor() {\n    }\n\n    /**\n     * A void marker to help with returning a value in a singleflight context.\n     * If your code doesn't return anything, return this instead.\n     */\n    public static Void = Symbol(\"void\");\n\n    /**\n     * Acquire a singleflight context.\n     * @param {Object} instance An instance to associate the context with. Can be any object.\n     * @param {string} key A string key relevant to that instance to namespace under.\n     * @returns {SingleflightContext} Returns the context to execute the function.\n     */\n    public static for(instance: Object, key: string): SingleflightContext {\n        if (!instance || !key) throw new Error(\"An instance and key must be supplied\");\n        return new SingleflightContext(instance, key);\n    }\n\n    /**\n     * Forgets all results for a given instance.\n     * @param {Object} instance The instance to forget about.\n     */\n    public static forgetAllFor(instance: Object) {\n        keyMap.delete(instance);\n    }\n\n    /**\n     * Forgets all cached results for all instances. Intended for use by tests.\n     */\n    public static forgetAll() {\n        for (const k of keyMap.keys()) {\n            keyMap.remove(k);\n        }\n    }\n}\n\nclass SingleflightContext {\n    public constructor(private instance: Object, private key: string) {\n    }\n\n    /**\n     * Forget this particular instance and key combination, discarding the result.\n     */\n    public forget() {\n        const map = keyMap.get(this.instance);\n        if (!map) return;\n        map.remove(this.key);\n        if (!map.size) keyMap.remove(this.instance);\n    }\n\n    /**\n     * Execute a function. If a result is already known, that will be returned instead\n     * of executing the provided function. However, if no result is known then the function\n     * will be called, with its return value cached. The function must return a value\n     * other than `undefined` - take a look at Singleflight.Void if you don't have a return\n     * to make.\n     *\n     * Note that this technically allows the caller to provide a different function each time:\n     * this is largely considered a bad idea and should not be done. Singleflights work off the\n     * premise that something needs to happen once, so duplicate executions will be ignored.\n     *\n     * For ideal performance and behaviour, functions which return promises are preferred. If\n     * a function is not returning a promise, it should return as soon as possible to avoid a\n     * second call potentially racing it. The promise returned by this function will be that\n     * of the first execution of the function, even on duplicate calls.\n     * @param {Function} fn The function to execute.\n     * @returns The recorded value.\n     */\n    public do<T>(fn: () => T): T {\n        const map = keyMap.getOrCreate(this.instance, new EnhancedMap<string, unknown>());\n\n        // We have to manually getOrCreate() because we need to execute the fn\n        let val = <T>map.get(this.key);\n        if (val === undefined) {\n            val = fn();\n            map.set(this.key, val);\n        }\n\n        return val;\n    }\n}\n"]}