A music player that connects to your cloud/distributed storage. diffuse.sh
Something went wrong. Try again.
JavaScript
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289import { xxh32r } from "xxh32/dist/raw.js";
/** * @import {Track} from "~/definitions/types.d.ts" */
/** * @template T * @param {Array<T>} array * @returns Array<T> * * @example Returns same elements in (possibly different) order without mutating the original * ```js * import { arrayShuffle } from "~/common/utils.js"; * * if (arrayShuffle([]).length !== 0) throw new Error("empty array should return empty"); * * const sorted = arrayShuffle([1, 2, 3, 4, 5]).sort((a, b) => a - b); * if (sorted.join(",") !== "1,2,3,4,5") throw new Error("shuffled array should contain same elements"); * * const original = [1, 2, 3]; * arrayShuffle(original); * if (original.join(",") !== "1,2,3") throw new Error("original array should not be mutated"); * * if (arrayShuffle([42]).join(",") !== "42") throw new Error("single-element array should be unchanged"); * ``` */export function arrayShuffle(array) { if (array.length === 0) { return []; }
array = [...array];
for (let index = array.length - 1; index > 0; index--) { const randArr = crypto.getRandomValues(new Uint32Array(1)); const randVal = randArr[0] / 2 ** 32; const newIndex = Math.floor(randVal * (index + 1)); [array[index], array[newIndex]] = [array[newIndex], array[index]]; }
return array;}
/** * @param {string | undefined | null} value * * @example Returns true only for empty string (present attribute) * ```js * import { boolAttr } from "~/common/utils.js"; * * if (!boolAttr("")) throw new Error("empty string should return true"); * if (boolAttr(null)) throw new Error("null should return false"); * if (boolAttr(undefined)) throw new Error("undefined should return false"); * if (boolAttr("true")) throw new Error("non-empty string should return false"); * ``` */export function boolAttr(value) { return value === "";}
/** * @param {any} object * * @example Returns a consistent string hash for the same object * ```js * import { hash } from "~/common/utils.js"; * * if (typeof hash({ a: 1 }) !== "string") throw new Error("hash should return a string"); * if (hash({ a: 1, b: 2 }) !== hash({ a: 1, b: 2 })) throw new Error("same objects should produce same hash"); * if (hash({ a: 1 }) === hash({ a: 2 })) throw new Error("different objects should produce different hashes"); * ``` */export function hash(object) { return xxh32r(jsonEncode(object)).toString();}
/** * @param {Track[]} tracks * @param {Record<string, Track[]>} initial * @returns {Record<string, Track[]>} * * @example Groups tracks by URI scheme * ```js * import { groupTracksPerScheme } from "~/common/utils.js"; * * const tracks = [ * { $type: "sh.diffuse.output.track", id: "1", uri: "http://example.com/a.mp3" }, * { $type: "sh.diffuse.output.track", id: "2", uri: "s3://bucket/b.mp3" }, * { $type: "sh.diffuse.output.track", id: "3", uri: "http://example.com/c.mp3" }, * ]; * // @ts-ignore * const groups = groupTracksPerScheme(tracks); * if (groups["http"].length !== 2) throw new Error("expected 2 http tracks"); * if (groups["s3"].length !== 1) throw new Error("expected 1 s3 track"); * ``` * * @example Merges into a provided initial object * ```js * import { groupTracksPerScheme } from "~/common/utils.js"; * * const initial = { http: [{ $type: "sh.diffuse.output.track", id: "0", uri: "http://existing.com/x.mp3" }] }; * const tracks = [{ $type: "sh.diffuse.output.track", id: "1", uri: "http://example.com/a.mp3" }]; * // @ts-ignore * const merged = groupTracksPerScheme(tracks, initial); * if (merged["http"].length !== 2) throw new Error("expected 2 http tracks after merge"); * ``` */export function groupTracksPerScheme( tracks, initial = {},) { /** @type {Record<string, Track[]>} */ const acc = initial;
tracks.forEach((track) => { const scheme = track.uri.substring(0, track.uri.indexOf(":")); acc[scheme] ??= []; acc[scheme].push(track); });
return acc;}
/** * @param {string[]} uris * @returns {Record<string, string[]>} * * @example Groups URIs by scheme * ```js * import { groupUrisPerScheme } from "~/common/utils.js"; * * const groups = groupUrisPerScheme(["http://a.com/t.mp3", "s3://b/t.flac", "http://c.com/t.mp3"]); * if (groups["http"].length !== 2) throw new Error("expected 2 http URIs"); * if (groups["s3"].length !== 1) throw new Error("expected 1 s3 URI"); * * if (Object.keys(groupUrisPerScheme([])).length !== 0) throw new Error("expected empty object for empty input"); * ``` */export function groupUrisPerScheme(uris) { /** @type {Record<string, string[]>} */ const acc = {};
uris.forEach((uri) => { const scheme = uri.substring(0, uri.indexOf(":")); acc[scheme] ??= []; acc[scheme].push(uri); });
return acc;}
/** * @param {unknown} test * * @example Returns true for primitives and false for objects/arrays * ```js * import { isPrimitive } from "~/common/utils.js"; * * if (!isPrimitive(42)) throw new Error("number should be primitive"); * if (!isPrimitive("hello")) throw new Error("string should be primitive"); * if (!isPrimitive(true)) throw new Error("boolean should be primitive"); * if (!isPrimitive(null)) throw new Error("null should be primitive"); * if (isPrimitive({ a: 1 })) throw new Error("object should not be primitive"); * if (isPrimitive([1, 2])) throw new Error("array should not be primitive"); * ``` */export function isPrimitive(test) { return test !== Object(test);}
/** * @template T * @param {any} a * @returns {T} */export function jsonDecode(a) { return JSON.parse(new TextDecoder().decode(a));}
/** * @template T * @param {T} a * @returns Uint8Array * * @example jsonEncode returns a Uint8Array that round-trips through jsonDecode * ```js * import { jsonEncode, jsonDecode } from "~/common/utils.js"; * * const original = { a: 1, b: "hello", c: [1, 2, 3] }; * if (!(jsonEncode(original) instanceof Uint8Array)) throw new Error("jsonEncode should return a Uint8Array"); * * const roundTripped = jsonDecode(jsonEncode(original)); * if (JSON.stringify(roundTripped) !== JSON.stringify(original)) throw new Error("round-trip should preserve values"); * ``` */export function jsonEncode(a) { return new TextEncoder().encode(JSON.stringify(a));}
/** * @template {Record<string, any>} T * @param {T} rec * * @example Removes keys with undefined values without mutating the original * ```js * import { removeUndefinedValuesFromRecord } from "~/common/utils.js"; * * const result = removeUndefinedValuesFromRecord({ a: 1, b: undefined, c: "x" }); * if ("b" in result) throw new Error("undefined key should be removed"); * if (result["a"] !== 1 || result["c"] !== "x") throw new Error("defined keys should be preserved"); * * const original = { a: 1, b: undefined }; * removeUndefinedValuesFromRecord(original); * if (!("b" in original)) throw new Error("original should not be mutated"); * * const noUndef = removeUndefinedValuesFromRecord({ a: 1, b: 2 }); * if (noUndef["a"] !== 1 || noUndef["b"] !== 2) throw new Error("record without undefined values should be unchanged"); * ``` */export function removeUndefinedValuesFromRecord(rec) { const recClone = { ...rec };
Object.entries(recClone).forEach(([key, value]) => { if (value === undefined) { delete recClone[key]; } });
return recClone;}
/** * @template {Record<string, any>} T * @param {T} rec * * @example Deep-clones nested records without sharing references * ```js * import { recursivelyCloneRecords } from "~/common/utils.js"; * * const original = { a: 1, b: "x" }; * const clone = recursivelyCloneRecords(original); * if (clone === original) throw new Error("clone should be a different object"); * if (clone.a !== 1 || clone.b !== "x") throw new Error("values should be preserved"); * * const nested = { outer: { inner: 42 } }; * const nestedClone = recursivelyCloneRecords(nested); * if (nestedClone.outer === nested.outer) throw new Error("nested objects should not share references"); * if (nestedClone.outer.inner !== 42) throw new Error("nested values should be preserved"); * ``` */export function recursivelyCloneRecords(rec) { const recClone = { ...rec };
Object.entries(recClone).forEach(([key, value]) => { if (typeof value === "object") { /** @ts-ignore */ recClone[key] = recursivelyCloneRecords(value); } });
return recClone;}
/** * @param {string} str * @returns {string} * * @example Decodes percent-encoded and %u unicode escapes, leaves plain strings unchanged * ```js * import { safeDecodeURIComponent } from "~/common/utils.js"; * * if (safeDecodeURIComponent("hello%20world") !== "hello world") throw new Error("should decode %20 as space"); * if (safeDecodeURIComponent("%u0041") !== "A") throw new Error("should decode %u unicode escape"); * if (safeDecodeURIComponent("plain-string") !== "plain-string") throw new Error("plain string should be unchanged"); * if (safeDecodeURIComponent("hello%2Fworld") !== "hello/world") throw new Error("should decode %2F as slash"); * ``` */export function safeDecodeURIComponent(str) { return str.replace( /%u([0-9A-Fa-f]{4})|%([0-9A-Fa-f]{2})/g, (_, unicode, byte) => unicode ? String.fromCharCode(parseInt(unicode, 16)) : String.fromCharCode(parseInt(byte, 16)), );}