matrix-react-sdk
Version:
SDK for matrix.org using React
126 lines (114 loc) • 13.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 2024 New Vector Ltd.
Copyright 2021 The Matrix.org Foundation C.I.C.
SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only
Please see LICENSE files in the repository root for full details.
*/
// 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 use case 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, key) {
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) {
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, key) {
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) {
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,"names":["_maps","require","keyMap","EnhancedMap","Singleflight","constructor","for","instance","key","Error","SingleflightContext","forgetAllFor","delete","forgetAll","k","keys","remove","exports","_defineProperty2","default","Symbol","forget","map","get","size","do","fn","getOrCreate","val","undefined","set"],"sources":["../../src/utils/Singleflight.ts"],"sourcesContent":["/*\nCopyright 2024 New Vector Ltd.\nCopyright 2021 The Matrix.org Foundation C.I.C.\n\nSPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only\nPlease see LICENSE files in the repository root for full details.\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 use case 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     * 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 | null, key?: string | null): 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): void {\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(): void {\n        for (const k of keyMap.keys()) {\n            keyMap.remove(k);\n        }\n    }\n}\n\nclass SingleflightContext {\n    public constructor(\n        private instance: Object,\n        private key: string,\n    ) {}\n\n    /**\n     * Forget this particular instance and key combination, discarding the result.\n     */\n    public forget(): void {\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"],"mappings":";;;;;;;;AAQA,IAAAA,KAAA,GAAAC,OAAA;AARA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA;;AAEA,MAAMC,MAAM,GAAG,IAAIC,iBAAW,CAAuC,CAAC;;AAEtE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMC,YAAY,CAAC;EACdC,WAAWA,CAAA,EAAG,CAAC;;EAEvB;AACJ;AACA;AACA;;EAGI;AACJ;AACA;AACA;AACA;AACA;EACI,OAAcC,GAAGA,CAACC,QAAwB,EAAEC,GAAmB,EAAuB;IAClF,IAAI,CAACD,QAAQ,IAAI,CAACC,GAAG,EAAE,MAAM,IAAIC,KAAK,CAAC,sCAAsC,CAAC;IAC9E,OAAO,IAAIC,mBAAmB,CAACH,QAAQ,EAAEC,GAAG,CAAC;EACjD;;EAEA;AACJ;AACA;AACA;EACI,OAAcG,YAAYA,CAACJ,QAAgB,EAAQ;IAC/CL,MAAM,CAACU,MAAM,CAACL,QAAQ,CAAC;EAC3B;;EAEA;AACJ;AACA;EACI,OAAcM,SAASA,CAAA,EAAS;IAC5B,KAAK,MAAMC,CAAC,IAAIZ,MAAM,CAACa,IAAI,CAAC,CAAC,EAAE;MAC3Bb,MAAM,CAACc,MAAM,CAACF,CAAC,CAAC;IACpB;EACJ;AACJ;AAACG,OAAA,CAAAb,YAAA,GAAAA,YAAA;AAAA,IAAAc,gBAAA,CAAAC,OAAA,EApCYf,YAAY,UAOAgB,MAAM,CAAC,MAAM,CAAC;AA+BvC,MAAMV,mBAAmB,CAAC;EACfL,WAAWA,CACNE,QAAgB,EAChBC,GAAW,EACrB;IAAA,KAFUD,QAAgB,GAAhBA,QAAgB;IAAA,KAChBC,GAAW,GAAXA,GAAW;EACpB;;EAEH;AACJ;AACA;EACWa,MAAMA,CAAA,EAAS;IAClB,MAAMC,GAAG,GAAGpB,MAAM,CAACqB,GAAG,CAAC,IAAI,CAAChB,QAAQ,CAAC;IACrC,IAAI,CAACe,GAAG,EAAE;IACVA,GAAG,CAACN,MAAM,CAAC,IAAI,CAACR,GAAG,CAAC;IACpB,IAAI,CAACc,GAAG,CAACE,IAAI,EAAEtB,MAAM,CAACc,MAAM,CAAC,IAAI,CAACT,QAAQ,CAAC;EAC/C;;EAEA;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACWkB,EAAEA,CAAIC,EAAW,EAAK;IACzB,MAAMJ,GAAG,GAAGpB,MAAM,CAACyB,WAAW,CAAC,IAAI,CAACpB,QAAQ,EAAE,IAAIJ,iBAAW,CAAkB,CAAC,CAAC;;IAEjF;IACA,IAAIyB,GAAG,GAAMN,GAAG,CAACC,GAAG,CAAC,IAAI,CAACf,GAAG,CAAC;IAC9B,IAAIoB,GAAG,KAAKC,SAAS,EAAE;MACnBD,GAAG,GAAGF,EAAE,CAAC,CAAC;MACVJ,GAAG,CAACQ,GAAG,CAAC,IAAI,CAACtB,GAAG,EAAEoB,GAAG,CAAC;IAC1B;IAEA,OAAOA,GAAG;EACd;AACJ","ignoreList":[]}