matrix-react-sdk
Version:
SDK for matrix.org using React
353 lines (327 loc) • 38.9 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.GroupedArray = exports.ArrayUtil = void 0;
exports.arrayDiff = arrayDiff;
exports.arrayFastClone = arrayFastClone;
exports.arrayFastResample = arrayFastResample;
exports.arrayHasDiff = arrayHasDiff;
exports.arrayHasOrderChange = arrayHasOrderChange;
exports.arrayIntersection = arrayIntersection;
exports.arrayRescale = arrayRescale;
exports.arraySeed = arraySeed;
exports.arraySmoothingResample = arraySmoothingResample;
exports.arrayTrimFill = arrayTrimFill;
exports.arrayUnion = arrayUnion;
exports.asyncEvery = asyncEvery;
exports.asyncSome = asyncSome;
exports.concat = void 0;
exports.filterBoolean = filterBoolean;
exports.moveElement = moveElement;
var _numbers = require("./numbers");
/*
Copyright 2024 New Vector Ltd.
Copyright 2020, 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.
*/
/**
* Quickly resample an array to have less/more data points. If an input which is larger
* than the desired size is provided, it will be downsampled. Similarly, if the input
* is smaller than the desired size then it will be upsampled.
* @param {number[]} input The input array to resample.
* @param {number} points The number of samples to end up with.
* @returns {number[]} The resampled array.
*/
function arrayFastResample(input, points) {
if (input.length === points) return input; // short-circuit a complicated call
// Heavily inspired by matrix-media-repo (used with permission)
// https://github.com/turt2live/matrix-media-repo/blob/abe72c87d2e29/util/util_audio/fastsample.go#L10
const samples = [];
if (input.length > points) {
// Danger: this loop can cause out of memory conditions if the input is too small.
const everyNth = Math.round(input.length / points);
for (let i = 0; i < input.length; i += everyNth) {
samples.push(input[i]);
}
} else {
// Smaller inputs mean we have to spread the values over the desired length. We
// end up overshooting the target length in doing this, but we're not looking to
// be super accurate so we'll let the sanity trims do their job.
const spreadFactor = Math.ceil(points / input.length);
for (const val of input) {
samples.push(...arraySeed(val, spreadFactor));
}
}
// Trim to size & return
return arrayTrimFill(samples, points, arraySeed(input[input.length - 1], points));
}
/**
* Attempts a smooth resample of the given array. This is functionally similar to arrayFastResample
* though can take longer due to the smoothing of data.
* @param {number[]} input The input array to resample.
* @param {number} points The number of samples to end up with.
* @returns {number[]} The resampled array.
*/
// ts-prune-ignore-next
function arraySmoothingResample(input, points) {
if (input.length === points) return input; // short-circuit a complicated call
let samples = [];
if (input.length > points) {
// We're downsampling. To preserve the curve we'll actually reduce our sample
// selection and average some points between them.
// All we're doing here is repeatedly averaging the waveform down to near our
// target value. We don't average down to exactly our target as the loop might
// never end, and we can over-average the data. Instead, we'll get as far as
// we can and do a followup fast resample (the neighbouring points will be close
// to the actual waveform, so we can get away with this safely).
while (samples.length > points * 2 || samples.length === 0) {
samples = [];
for (let i = 1; i < input.length - 1; i += 2) {
const prevPoint = input[i - 1];
const nextPoint = input[i + 1];
const currPoint = input[i];
const average = (prevPoint + nextPoint + currPoint) / 3;
samples.push(average);
}
input = samples;
}
return arrayFastResample(samples, points);
} else {
// In practice there's not much purpose in burning CPU for short arrays only to
// end up with a result that can't possibly look much different than the fast
// resample, so just skip ahead to the fast resample.
return arrayFastResample(input, points);
}
}
/**
* Rescales the input array to have values that are inclusively within the provided
* minimum and maximum.
* @param {number[]} input The array to rescale.
* @param {number} newMin The minimum value to scale to.
* @param {number} newMax The maximum value to scale to.
* @returns {number[]} The rescaled array.
*/
// ts-prune-ignore-next
function arrayRescale(input, newMin, newMax) {
const min = Math.min(...input);
const max = Math.max(...input);
return input.map(v => (0, _numbers.percentageWithin)((0, _numbers.percentageOf)(v, min, max), newMin, newMax));
}
/**
* Creates an array of the given length, seeded with the given value.
* @param {T} val The value to seed the array with.
* @param {number} length The length of the array to create.
* @returns {T[]} The array.
*/
function arraySeed(val, length) {
// Size the array up front for performance, and use `fill` to let the browser
// optimize the operation better than we can with a `for` loop, if it wants.
return new Array(length).fill(val);
}
/**
* Trims or fills the array to ensure it meets the desired length. The seed array
* given is pulled from to fill any missing slots - it is recommended that this be
* at least `len` long. The resulting array will be exactly `len` long, either
* trimmed from the source or filled with the some/all of the seed array.
* @param {T[]} a The array to trim/fill.
* @param {number} len The length to trim or fill to, as needed.
* @param {T[]} seed Values to pull from if the array needs filling.
* @returns {T[]} The resulting array of `len` length.
*/
function arrayTrimFill(a, len, seed) {
// Dev note: we do length checks because the spread operator can result in some
// performance penalties in more critical code paths. As a utility, it should be
// as fast as possible to not cause a problem for the call stack, no matter how
// critical that stack is.
if (a.length === len) return a;
if (a.length > len) return a.slice(0, len);
return a.concat(seed.slice(0, len - a.length));
}
/**
* Clones an array as fast as possible, retaining references of the array's values.
* @param a The array to clone. Must be defined.
* @returns A copy of the array.
*/
function arrayFastClone(a) {
return a.slice(0, a.length);
}
/**
* Determines if the two arrays are different either in length, contents,
* or order of those contents.
* @param a The first array. Must be defined.
* @param b The second array. Must be defined.
* @returns True if they are different, false otherwise.
*/
function arrayHasOrderChange(a, b) {
if (a.length === b.length) {
for (let i = 0; i < a.length; i++) {
if (a[i] !== b[i]) return true;
}
return false;
} else {
return true; // like arrayHasDiff, a difference in length is a natural change
}
}
/**
* Determines if two arrays are different through a shallow comparison.
* @param a The first array. Must be defined.
* @param b The second array. Must be defined.
* @returns True if they are different, false otherwise.
*/
function arrayHasDiff(a, b) {
if (a.length === b.length) {
// When the lengths are equal, check to see if either array is missing
// an element from the other.
if (b.some(i => !a.includes(i))) return true;
if (a.some(i => !b.includes(i))) return true;
// if all the keys are common, say so
return false;
} else {
return true; // different lengths means they are naturally diverged
}
}
/**
* Performs a diff on two arrays. The result is what is different with the
* first array (`added` in the returned object means objects in B that aren't
* in A). Shallow comparisons are used to perform the diff.
* @param a The first array. Must be defined.
* @param b The second array. Must be defined.
* @returns The diff between the arrays.
*/
function arrayDiff(a, b) {
return {
added: b.filter(i => !a.includes(i)),
removed: a.filter(i => !b.includes(i))
};
}
/**
* Returns the intersection of two arrays.
* @param a The first array. Must be defined.
* @param b The second array. Must be defined.
* @returns The intersection of the arrays.
*/
function arrayIntersection(a, b) {
return a.filter(i => b.includes(i));
}
/**
* Unions arrays, deduping contents using a Set.
* @param a The arrays to merge.
* @returns The union of all given arrays.
*/
function arrayUnion(...a) {
return Array.from(a.reduce((c, v) => {
v.forEach(i => c.add(i));
return c;
}, new Set()));
}
/**
* Moves a single element from fromIndex to toIndex.
* @param {array} list the list from which to construct the new list.
* @param {number} fromIndex the index of the element to move.
* @param {number} toIndex the index of where to put the element.
* @returns {array} A new array with the requested value moved.
*/
function moveElement(list, fromIndex, toIndex) {
const result = Array.from(list);
const [removed] = result.splice(fromIndex, 1);
result.splice(toIndex, 0, removed);
return result;
}
/**
* Helper functions to perform LINQ-like queries on arrays.
*/
class ArrayUtil {
/**
* Create a new array helper.
* @param a The array to help. Can be modified in-place.
*/
constructor(a) {
this.a = a;
}
/**
* The value of this array, after all appropriate alterations.
*/
get value() {
return this.a;
}
/**
* Groups an array by keys.
* @param fn The key-finding function.
* @returns This.
*/
groupBy(fn) {
const obj = this.a.reduce((rv, val) => {
const k = fn(val);
if (!rv.has(k)) rv.set(k, []);
rv.get(k).push(val);
return rv;
}, new Map());
return new GroupedArray(obj);
}
}
/**
* Helper functions to perform LINQ-like queries on groups (maps).
*/
exports.ArrayUtil = ArrayUtil;
class GroupedArray {
/**
* Creates a new group helper.
* @param val The group to help. Can be modified in-place.
*/
constructor(val) {
this.val = val;
}
/**
* The value of this group, after all applicable alterations.
*/
get value() {
return this.val;
}
/**
* Orders the grouping into an array using the provided key order.
* @param keyOrder The key order.
* @returns An array helper of the result.
*/
orderBy(keyOrder) {
const a = [];
for (const k of keyOrder) {
if (!this.val.has(k)) continue;
a.push(...this.val.get(k));
}
return new ArrayUtil(a);
}
}
exports.GroupedArray = GroupedArray;
const concat = (...arrays) => {
return arrays.reduce((concatenatedSoFar, toBeConcatenated) => {
const concatenated = new Uint8Array(concatenatedSoFar.length + toBeConcatenated.length);
concatenated.set(concatenatedSoFar, 0);
concatenated.set(toBeConcatenated, concatenatedSoFar.length);
return concatenated;
}, new Uint8Array(0));
};
/**
* Async version of Array.every.
*/
exports.concat = concat;
async function asyncEvery(values, predicate) {
for (const value of values) {
if (!(await predicate(value))) return false;
}
return true;
}
/**
* Async version of Array.some.
*/
async function asyncSome(values, predicate) {
for (const value of values) {
if (await predicate(value)) return true;
}
return false;
}
function filterBoolean(values) {
return values.filter(Boolean);
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_numbers","require","arrayFastResample","input","points","length","samples","everyNth","Math","round","i","push","spreadFactor","ceil","val","arraySeed","arrayTrimFill","arraySmoothingResample","prevPoint","nextPoint","currPoint","average","arrayRescale","newMin","newMax","min","max","map","v","percentageWithin","percentageOf","Array","fill","a","len","seed","slice","concat","arrayFastClone","arrayHasOrderChange","b","arrayHasDiff","some","includes","arrayDiff","added","filter","removed","arrayIntersection","arrayUnion","from","reduce","c","forEach","add","Set","moveElement","list","fromIndex","toIndex","result","splice","ArrayUtil","constructor","value","groupBy","fn","obj","rv","k","has","set","get","Map","GroupedArray","exports","orderBy","keyOrder","arrays","concatenatedSoFar","toBeConcatenated","concatenated","Uint8Array","asyncEvery","values","predicate","asyncSome","filterBoolean","Boolean"],"sources":["../../src/utils/arrays.ts"],"sourcesContent":["/*\nCopyright 2024 New Vector Ltd.\nCopyright 2020, 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 { percentageOf, percentageWithin } from \"./numbers\";\n\n/**\n * Quickly resample an array to have less/more data points. If an input which is larger\n * than the desired size is provided, it will be downsampled. Similarly, if the input\n * is smaller than the desired size then it will be upsampled.\n * @param {number[]} input The input array to resample.\n * @param {number} points The number of samples to end up with.\n * @returns {number[]} The resampled array.\n */\nexport function arrayFastResample(input: number[], points: number): number[] {\n    if (input.length === points) return input; // short-circuit a complicated call\n\n    // Heavily inspired by matrix-media-repo (used with permission)\n    // https://github.com/turt2live/matrix-media-repo/blob/abe72c87d2e29/util/util_audio/fastsample.go#L10\n    const samples: number[] = [];\n    if (input.length > points) {\n        // Danger: this loop can cause out of memory conditions if the input is too small.\n        const everyNth = Math.round(input.length / points);\n        for (let i = 0; i < input.length; i += everyNth) {\n            samples.push(input[i]);\n        }\n    } else {\n        // Smaller inputs mean we have to spread the values over the desired length. We\n        // end up overshooting the target length in doing this, but we're not looking to\n        // be super accurate so we'll let the sanity trims do their job.\n        const spreadFactor = Math.ceil(points / input.length);\n        for (const val of input) {\n            samples.push(...arraySeed(val, spreadFactor));\n        }\n    }\n\n    // Trim to size & return\n    return arrayTrimFill(samples, points, arraySeed(input[input.length - 1], points));\n}\n\n/**\n * Attempts a smooth resample of the given array. This is functionally similar to arrayFastResample\n * though can take longer due to the smoothing of data.\n * @param {number[]} input The input array to resample.\n * @param {number} points The number of samples to end up with.\n * @returns {number[]} The resampled array.\n */\n// ts-prune-ignore-next\nexport function arraySmoothingResample(input: number[], points: number): number[] {\n    if (input.length === points) return input; // short-circuit a complicated call\n\n    let samples: number[] = [];\n    if (input.length > points) {\n        // We're downsampling. To preserve the curve we'll actually reduce our sample\n        // selection and average some points between them.\n\n        // All we're doing here is repeatedly averaging the waveform down to near our\n        // target value. We don't average down to exactly our target as the loop might\n        // never end, and we can over-average the data. Instead, we'll get as far as\n        // we can and do a followup fast resample (the neighbouring points will be close\n        // to the actual waveform, so we can get away with this safely).\n        while (samples.length > points * 2 || samples.length === 0) {\n            samples = [];\n            for (let i = 1; i < input.length - 1; i += 2) {\n                const prevPoint = input[i - 1];\n                const nextPoint = input[i + 1];\n                const currPoint = input[i];\n                const average = (prevPoint + nextPoint + currPoint) / 3;\n                samples.push(average);\n            }\n            input = samples;\n        }\n\n        return arrayFastResample(samples, points);\n    } else {\n        // In practice there's not much purpose in burning CPU for short arrays only to\n        // end up with a result that can't possibly look much different than the fast\n        // resample, so just skip ahead to the fast resample.\n        return arrayFastResample(input, points);\n    }\n}\n\n/**\n * Rescales the input array to have values that are inclusively within the provided\n * minimum and maximum.\n * @param {number[]} input The array to rescale.\n * @param {number} newMin The minimum value to scale to.\n * @param {number} newMax The maximum value to scale to.\n * @returns {number[]} The rescaled array.\n */\n// ts-prune-ignore-next\nexport function arrayRescale(input: number[], newMin: number, newMax: number): number[] {\n    const min: number = Math.min(...input);\n    const max: number = Math.max(...input);\n    return input.map((v) => percentageWithin(percentageOf(v, min, max), newMin, newMax));\n}\n\n/**\n * Creates an array of the given length, seeded with the given value.\n * @param {T} val The value to seed the array with.\n * @param {number} length The length of the array to create.\n * @returns {T[]} The array.\n */\nexport function arraySeed<T>(val: T, length: number): T[] {\n    // Size the array up front for performance, and use `fill` to let the browser\n    // optimize the operation better than we can with a `for` loop, if it wants.\n    return new Array<T>(length).fill(val);\n}\n\n/**\n * Trims or fills the array to ensure it meets the desired length. The seed array\n * given is pulled from to fill any missing slots - it is recommended that this be\n * at least `len` long. The resulting array will be exactly `len` long, either\n * trimmed from the source or filled with the some/all of the seed array.\n * @param {T[]} a The array to trim/fill.\n * @param {number} len The length to trim or fill to, as needed.\n * @param {T[]} seed Values to pull from if the array needs filling.\n * @returns {T[]} The resulting array of `len` length.\n */\nexport function arrayTrimFill<T>(a: T[], len: number, seed: T[]): T[] {\n    // Dev note: we do length checks because the spread operator can result in some\n    // performance penalties in more critical code paths. As a utility, it should be\n    // as fast as possible to not cause a problem for the call stack, no matter how\n    // critical that stack is.\n    if (a.length === len) return a;\n    if (a.length > len) return a.slice(0, len);\n    return a.concat(seed.slice(0, len - a.length));\n}\n\n/**\n * Clones an array as fast as possible, retaining references of the array's values.\n * @param a The array to clone. Must be defined.\n * @returns A copy of the array.\n */\nexport function arrayFastClone<T>(a: T[]): T[] {\n    return a.slice(0, a.length);\n}\n\n/**\n * Determines if the two arrays are different either in length, contents,\n * or order of those contents.\n * @param a The first array. Must be defined.\n * @param b The second array. Must be defined.\n * @returns True if they are different, false otherwise.\n */\nexport function arrayHasOrderChange(a: any[], b: any[]): boolean {\n    if (a.length === b.length) {\n        for (let i = 0; i < a.length; i++) {\n            if (a[i] !== b[i]) return true;\n        }\n        return false;\n    } else {\n        return true; // like arrayHasDiff, a difference in length is a natural change\n    }\n}\n\n/**\n * Determines if two arrays are different through a shallow comparison.\n * @param a The first array. Must be defined.\n * @param b The second array. Must be defined.\n * @returns True if they are different, false otherwise.\n */\nexport function arrayHasDiff(a: any[], b: any[]): boolean {\n    if (a.length === b.length) {\n        // When the lengths are equal, check to see if either array is missing\n        // an element from the other.\n        if (b.some((i) => !a.includes(i))) return true;\n        if (a.some((i) => !b.includes(i))) return true;\n\n        // if all the keys are common, say so\n        return false;\n    } else {\n        return true; // different lengths means they are naturally diverged\n    }\n}\n\nexport type Diff<T> = { added: T[]; removed: T[] };\n\n/**\n * Performs a diff on two arrays. The result is what is different with the\n * first array (`added` in the returned object means objects in B that aren't\n * in A). Shallow comparisons are used to perform the diff.\n * @param a The first array. Must be defined.\n * @param b The second array. Must be defined.\n * @returns The diff between the arrays.\n */\nexport function arrayDiff<T>(a: T[], b: T[]): Diff<T> {\n    return {\n        added: b.filter((i) => !a.includes(i)),\n        removed: a.filter((i) => !b.includes(i)),\n    };\n}\n\n/**\n * Returns the intersection of two arrays.\n * @param a The first array. Must be defined.\n * @param b The second array. Must be defined.\n * @returns The intersection of the arrays.\n */\nexport function arrayIntersection<T>(a: T[], b: T[]): T[] {\n    return a.filter((i) => b.includes(i));\n}\n\n/**\n * Unions arrays, deduping contents using a Set.\n * @param a The arrays to merge.\n * @returns The union of all given arrays.\n */\nexport function arrayUnion<T>(...a: T[][]): T[] {\n    return Array.from(\n        a.reduce((c, v) => {\n            v.forEach((i) => c.add(i));\n            return c;\n        }, new Set<T>()),\n    );\n}\n\n/**\n * Moves a single element from fromIndex to toIndex.\n * @param {array} list the list from which to construct the new list.\n * @param {number} fromIndex the index of the element to move.\n * @param {number} toIndex the index of where to put the element.\n * @returns {array} A new array with the requested value moved.\n */\nexport function moveElement<T>(list: T[], fromIndex: number, toIndex: number): T[] {\n    const result = Array.from(list);\n    const [removed] = result.splice(fromIndex, 1);\n    result.splice(toIndex, 0, removed);\n\n    return result;\n}\n\n/**\n * Helper functions to perform LINQ-like queries on arrays.\n */\nexport class ArrayUtil<T> {\n    /**\n     * Create a new array helper.\n     * @param a The array to help. Can be modified in-place.\n     */\n    public constructor(private a: T[]) {}\n\n    /**\n     * The value of this array, after all appropriate alterations.\n     */\n    public get value(): T[] {\n        return this.a;\n    }\n\n    /**\n     * Groups an array by keys.\n     * @param fn The key-finding function.\n     * @returns This.\n     */\n    public groupBy<K>(fn: (a: T) => K): GroupedArray<K, T> {\n        const obj = this.a.reduce((rv: Map<K, T[]>, val: T) => {\n            const k = fn(val);\n            if (!rv.has(k)) rv.set(k, []);\n            rv.get(k)!.push(val);\n            return rv;\n        }, new Map<K, T[]>());\n        return new GroupedArray(obj);\n    }\n}\n\n/**\n * Helper functions to perform LINQ-like queries on groups (maps).\n */\nexport class GroupedArray<K, T> {\n    /**\n     * Creates a new group helper.\n     * @param val The group to help. Can be modified in-place.\n     */\n    public constructor(private val: Map<K, T[]>) {}\n\n    /**\n     * The value of this group, after all applicable alterations.\n     */\n    public get value(): Map<K, T[]> {\n        return this.val;\n    }\n\n    /**\n     * Orders the grouping into an array using the provided key order.\n     * @param keyOrder The key order.\n     * @returns An array helper of the result.\n     */\n    public orderBy(keyOrder: K[]): ArrayUtil<T> {\n        const a: T[] = [];\n        for (const k of keyOrder) {\n            if (!this.val.has(k)) continue;\n            a.push(...this.val.get(k)!);\n        }\n        return new ArrayUtil(a);\n    }\n}\n\nexport const concat = (...arrays: Uint8Array[]): Uint8Array => {\n    return arrays.reduce((concatenatedSoFar: Uint8Array, toBeConcatenated: Uint8Array) => {\n        const concatenated = new Uint8Array(concatenatedSoFar.length + toBeConcatenated.length);\n        concatenated.set(concatenatedSoFar, 0);\n        concatenated.set(toBeConcatenated, concatenatedSoFar.length);\n        return concatenated;\n    }, new Uint8Array(0));\n};\n\n/**\n * Async version of Array.every.\n */\nexport async function asyncEvery<T>(values: Iterable<T>, predicate: (value: T) => Promise<boolean>): Promise<boolean> {\n    for (const value of values) {\n        if (!(await predicate(value))) return false;\n    }\n    return true;\n}\n\n/**\n * Async version of Array.some.\n */\nexport async function asyncSome<T>(values: Iterable<T>, predicate: (value: T) => Promise<boolean>): Promise<boolean> {\n    for (const value of values) {\n        if (await predicate(value)) return true;\n    }\n    return false;\n}\n\nexport function filterBoolean<T>(values: Array<T | null | undefined>): T[] {\n    return values.filter(Boolean) as T[];\n}\n"],"mappings":"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","ignoreList":[]}