@spicetify/kit 0.1.0

package/vendor/stdlib/src/registers/topbarLeftButton.tsx

@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import { React } from "../expose/React.ts";
+import { createIconComponent } from "../createIconComponent.tsx";
+import { transformer } from "../../mixin.ts";
+import { Tooltip } from "../webpack/ReactComponents.ts";
+import { UI } from "../webpack/ComponentLibrary.ts";
+import { mountRegistryAnchor } from "./mount.ts";
+import { Registry } from "./registry.ts";
+
+const registry = new (class extends Registry<React.ReactNode> {
+	override add(value: React.ReactNode): this {
+		refresh?.();
+		return super.add(value);
+	}
+
+	override delete(value: React.ReactNode): boolean {
+		refresh?.();
+		return super.delete(value);
+	}
+})();
+export default registry;
+
+let refresh: React.DispatchWithoutAction | undefined;
+
+declare global {
+	var __renderTopbarLeftButtons: () => React.ReactNode;
+}
+
+globalThis.__renderTopbarLeftButtons = () =>
+	React.createElement(() => {
+		[, refresh] = React.useReducer((n) => n + 1, 0);
+
+		return <>{registry.all()}</>;
+	});
+transformer(
+	(emit) => (str) => {
+		emit();
+
+		str = str.replace(/("top-bar-forward-button"[^\]]*)/g, "$1,__renderTopbarLeftButtons()");
+
+		return str;
+	},
+	{
+		glob: /^\/xpui\.js/,
+	},
+);
+
+mountRegistryAnchor({
+	className: "spicetify-topbar-left-buttons",
+	registry,
+	setRefresh: (cb) => {
+		refresh = cb;
+	},
+	findSlot: () => {
+		const history = document.querySelector(".main-globalNav-historyButtons");
+		return history?.parentElement ? { parent: history.parentElement, before: history.nextSibling } : null;
+	},
+});
+
+type TopbarLeftButtonProps = {
+	label: string;
+	disabled?: boolean;
+	onClick: () => void;
+	icon?: string;
+	/** Position within the module-button group; lower renders earlier. Read by the mount sorter. */
+	order?: number;
+};
+
+type TopbarLeftButtonFactory = React.FC<TopbarLeftButtonProps>;
+export const TopbarLeftButton: TopbarLeftButtonFactory = (props) => (
+	<Tooltip label={props.label}>
+		<UI.ButtonTertiary
+			size="medium"
+			iconOnly={() => props.icon && createIconComponent({ icon: props.icon, iconSize: 16, realIconSize: 24 })}
+			condensed
+			aria-label={props.label}
+			disabled={props.disabled}
+			onClick={props.onClick}
+			className={MAP.main.topbar.left.button_t.wrapper}
+		/>
+	</Tooltip>
+);

package/vendor/stdlib/src/registers/topbarRightButton.tsx

@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import { React } from "../expose/React.ts";
+import { createIconComponent } from "../createIconComponent.tsx";
+import { transformer } from "../../mixin.ts";
+import { Tooltip } from "../webpack/ReactComponents.ts";
+import { UI } from "../webpack/ComponentLibrary.ts";
+import { mountRegistryAnchor } from "./mount.ts";
+import { Registry } from "./registry.ts";
+
+const registry = new (class extends Registry<React.ReactNode> {
+	override add(value: React.ReactNode): this {
+		refresh?.();
+		return super.add(value);
+	}
+
+	override delete(value: React.ReactNode): boolean {
+		refresh?.();
+		return super.delete(value);
+	}
+})();
+export default registry;
+
+let refresh: React.DispatchWithoutAction | undefined;
+
+declare global {
+	var __renderTopbarRightButtons: () => React.ReactNode;
+}
+
+globalThis.__renderTopbarRightButtons = () =>
+	React.createElement(() => {
+		[, refresh] = React.useReducer((n) => n + 1, 0);
+
+		return <>{registry.all().reverse()}</>;
+	});
+transformer(
+	(emit) => (str) => {
+		emit();
+
+		str = str.replace(/("login-button"[^\}]*\}[^\}]*\}[^\}]*\}\))/, "$1,__renderTopbarRightButtons()");
+
+		return str;
+	},
+	{
+		glob: /^\/xpui\.js/,
+	},
+);
+
+mountRegistryAnchor({
+	className: "spicetify-topbar-right-buttons",
+	registry,
+	setRefresh: (cb) => {
+		refresh = cb;
+	},
+	findSlot: () => {
+		const actions = document.querySelector(".main-actionButtons");
+		return actions ? { parent: actions, before: actions.firstChild } : null;
+	},
+});
+
+type TopbarRightButtonProps = {
+	label: string;
+	disabled?: boolean;
+	onClick: () => void;
+	icon?: string;
+	/** Position within the module-button group; lower renders earlier. Read by the mount sorter. */
+	order?: number;
+};
+
+type TopbarRightButtonFactory = React.FC<TopbarRightButtonProps>;
+
+export const TopbarRightButton: TopbarRightButtonFactory = (props) => (
+	<Tooltip label={props.label}>
+		<UI.ButtonTertiary
+			aria-label={props.label}
+			onClick={props.onClick}
+			size="small"
+			condensedAll
+			className={MAP.main.topbar.right.button_t.wrapper}
+		>
+			{props.icon && createIconComponent({ icon: props.icon, iconSize: 16 })}
+		</UI.ButtonTertiary>
+	</Tooltip>
+);

package/vendor/stdlib/src/storage.ts

@@ -0,0 +1,163 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import type { ModuleRuntimeContext } from "../mod.ts";
+
+import { Platform } from "./expose/Platform.ts";
+import { fromString } from "./webpack/URI.ts";
+
+export const createStorage = (ctx: ModuleRuntimeContext) => {
+	const hookedNativeStorageMethods = new Set(["getItem", "setItem", "removeItem"]);
+
+	return new Proxy(globalThis.localStorage, {
+		get(target, p, receiver) {
+			const func: unknown = Reflect.get(target, p, receiver);
+
+			if (typeof p === "string" && hookedNativeStorageMethods.has(p) && typeof func === "function") {
+				return (key: string, ...data: any[]) => func.call(target, `module:${ctx.identifier}:${key}`, ...data);
+			}
+
+			return func;
+		},
+	});
+};
+
+export function createSyncedStorage(playlistUri: string) {
+	const CHUNK_SIZE = 200;
+	const MAX_DOUBLE_CHUNKS = 1000;
+
+	const PlaylistAPI = Platform.getPlaylistAPI();
+
+	function markKey(key: string) {
+		return `\x02${key}\x03`;
+	}
+
+	function assertSmallerSize(encodedKey: string, chunk_size: number, chunk_count: number, message: string) {
+		for (let n = 0, o = 0, l = 0; ; l++) {
+			if (chunk_size * n + l + o >= encodedKey.length) {
+				return encodedKey;
+			}
+			if (n >= chunk_count) {
+				throw new Error(message);
+			}
+			if (encodedKey[chunk_size * n + l + o] === "%") {
+				o += 2;
+			}
+			if (l === chunk_size - 1) {
+				l = -1;
+				n++;
+			}
+		}
+	}
+
+	async function getUris(key: string) {
+		assertSmallerSize(encodeURIComponent(key), CHUNK_SIZE, 1, "Can't fit key in a single chunk");
+
+		const { items } = await PlaylistAPI.getContents(playlistUri, {
+			filter: key,
+			limit: 1e9,
+		});
+
+		return items
+			.map((item) => fromString(item.uri))
+			.filter((uri) => uri.type === "local")
+			.filter((uri) => uri.track === key);
+	}
+
+	async function getKey(key: string) {
+		const uris = await getUris(key);
+		if (uris.length === 0) return null;
+		return uris
+			.sort((a, b) => a.duration - b.duration)
+			.map((uri) => uri.artist + uri.album)
+			.join("");
+	}
+
+	async function removeKey(key: string) {
+		const uris = await getUris(key);
+		if (uris.length > 0) {
+			await PlaylistAPI.remove(
+				playlistUri,
+				uris.map((u) => ({ uri: u.toURI(), uid: "" })),
+			);
+		}
+	}
+	async function addKey(key: string, encodedValue: string) {
+		assertSmallerSize(encodeURIComponent(key), CHUNK_SIZE, 1, "Can't fit key in a single chunk");
+		assertSmallerSize(
+			encodedValue,
+			CHUNK_SIZE,
+			MAX_DOUBLE_CHUNKS,
+			`Can't fit value in ${MAX_DOUBLE_CHUNKS} double chunks`,
+		);
+
+		const uris = Array.from(collectTuples(generateStringChunks(encodedValue, CHUNK_SIZE), 2, "")).map(
+			([a, b], i) => `spotify:local:${a}:${b}:${key}:${i + 1}`,
+		);
+
+		await PlaylistAPI.add(playlistUri, uris, { after: "end" });
+	}
+
+	return {
+		async getItem(key: string) {
+			const encodedData = await getKey(markKey(key));
+			// decodeURIComponent(null) is the string "null", so a missing key
+			// would read back as truthy text instead of absent.
+			return encodedData === null ? null : decodeURIComponent(encodedData);
+		},
+		async removeItem(key: string) {
+			try {
+				await removeKey(markKey(key));
+			} catch (_) {
+				return false;
+			}
+			return true;
+		},
+		async setItem(key: string, value: string) {
+			const encodedValue = encodeURIComponent(value);
+			await removeKey(markKey(key));
+			await addKey(markKey(key), encodedValue);
+			return value;
+		},
+	};
+}
+
+function* generateStringChunks(string: string, chunk_size: number) {
+	for (let s = "", n = 0, o = 0, l = 0; ; l++) {
+		if (chunk_size * n + l + o >= string.length) {
+			if (l > 0) {
+				yield s;
+			}
+			break;
+		}
+		s += string[chunk_size * n + l + o];
+		if (string[chunk_size * n + l + o] === "%") {
+			s += string[chunk_size * n + l + ++o] + string[chunk_size * n + l + ++o];
+		}
+		if (l === chunk_size - 1) {
+			l = -1;
+			n++;
+			yield s;
+			s = "";
+		}
+	}
+}
+
+function* collectTuples<T>(gen: Generator<T, void, unknown>, l: number, unit: T) {
+	let result: IteratorResult<T, void>;
+	let done: boolean | undefined;
+
+	function next() {
+		if (done) return unit;
+		result = gen.next();
+		done = result.done;
+		if (done) return unit;
+		return result.value;
+	}
+
+	while (!done) {
+		yield Array.from({ length: l }, next);
+	}
+}

package/vendor/stdlib/src/util.ts

@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * Copyright (C) 2026 Afonso Jorge Ramos
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+// Inlined from the hooks-era /hooks/util.ts and /hooks/std/text.ts (a
+// data-URL bundle of jsr:@std/text), which were stdlib's last imports
+// from the retired hooks runtime. findBy carries the CLI compat pack's
+// hostile-exports fix, which the hooks repo never received; inlining
+// ends that typecheck-vs-runtime divergence.
+
+type Predicate<A> = (value: A) => boolean;
+
+// Some client exports are functions whose own toString is not callable;
+// they can never match a needle, so they stringify to "".
+const safeString = (x: any): string => {
+	try {
+		return x.toString();
+	} catch {
+		try {
+			return Function.prototype.toString.call(x);
+		} catch {
+			return "";
+		}
+	}
+};
+
+export function findBy(...tests: Array<string | RegExp | Predicate<any>>) {
+	const testFns = tests.map((test): Predicate<any> => {
+		switch (typeof test) {
+			case "string":
+				return (x) => safeString(x).includes(test);
+			case "function":
+				return (x) => test(x);
+			default: // assume regex
+				return (x) => test.test(safeString(x));
+		}
+	});
+	const testFn = (x: any) => testFns.map((t) => t(x)).every(Boolean);
+	return <A>(xs: A[]) => xs.find(testFn)!;
+}
+
+export const matchLast = (str: string, pattern: RegExp) => {
+	const matches = str.matchAll(pattern);
+	return Array.from(matches).at(-1)!;
+};
+
+// toPascalCase must stay byte-identical to @std/text@1.0.4: its outputs
+// become webpack-needle registry keys (URI types, component names).
+// Alternatives, in @std/text's order: capitalized word, acronym,
+// lowercase word, any letters, digits.
+const WORD_OR_NUMBER = /\p{Lu}\p{Ll}+|\p{Lu}+(?=(\p{Lu}\p{Ll})|\P{L}|\b)|(\p{Ll}+)|\p{L}+|\p{N}+/gu;
+
+const splitToWords = (input: string) => input.match(WORD_OR_NUMBER) ?? [];
+
+const capitalizeWord = (word: string) =>
+	word ? word[0].toLocaleUpperCase() + word.slice(1).toLocaleLowerCase() : word;
+
+export function toPascalCase(input: string): string {
+	return splitToWords(input.trim()).map(capitalizeWord).join("");
+}

package/vendor/stdlib/src/utils/index.ts

@@ -0,0 +1,16 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+export const isGlobalNavBarEnabled = () => {
+	return true;
+	// if (!Platform) {
+	// 	return undefined;
+	// }
+	// const RemoteConfiguration = Platform.getRemoteConfiguration();
+	// const enableGlobalNavBar = RemoteConfiguration.getValue("enableGlobalNavBar");
+	// return (
+	// 	enableGlobalNavBar === "home-next-to-navigation" || enableGlobalNavBar === "home-next-to-search"
+	// );
+};

package/vendor/stdlib/src/webpack/ClassNames.gen.ts

@@ -0,0 +1,10 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import type * as ClassNames_xpui_ts from "./ClassNames.xpui.ts";
+export let classnames: typeof ClassNames_xpui_ts.classnames;
+import("./ClassNames.xpui.ts").then(m => {
+	classnames = m.classnames;
+}).catch((e) => console.warn("[stdlib] lazy webpack surface ./ClassNames.xpui.ts failed:", e));

package/vendor/stdlib/src/webpack/ClassNames.ts

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+export * from "./ClassNames.gen.ts";

package/vendor/stdlib/src/webpack/ClassNames.xpui.ts

@@ -0,0 +1,16 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import { modules } from "./index.ts";
+import { webpackRequire } from "../wpunpk.mix.ts";
+
+type classNames = (...args: any[]) => string;
+
+await globalThis.CHUNKS.xpui.promise;
+
+export const classnames: classNames = modules
+	.filter(([_, v]) => v.toString().includes("[native code]"))
+	.map(([i]) => webpackRequire(i))
+	.find((e) => typeof e === "function");

package/vendor/stdlib/src/webpack/ComponentLibrary.gen.ts

@@ -0,0 +1,10 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import type * as ComponentLibrary_xpui_ts from "./ComponentLibrary.xpui.ts";
+export let UI: typeof ComponentLibrary_xpui_ts.UI;
+import("./ComponentLibrary.xpui.ts").then(m => {
+	UI = m.UI;
+}).catch((e) => console.warn("[stdlib] lazy webpack surface ./ComponentLibrary.xpui.ts failed:", e));

package/vendor/stdlib/src/webpack/ComponentLibrary.ts

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+export * from "./ComponentLibrary.gen.ts";

package/vendor/stdlib/src/webpack/ComponentLibrary.xpui.ts

@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import { exported, exportedForwardRefs, exportedFunctions, src } from "./index.ts";
+
+await CHUNKS.xpui.promise;
+
+const componentNames = Object.keys(
+	exported.find((e) => e.BrowserDefaultFocusStyleProvider && Object.hasOwn(e, "BrowserDefaultFocusStyleProvider")),
+);
+const componentRegexes = componentNames.map((n) => new RegExp(`"data-encore-id":(?:[a-zA-Z_\$][\w\$]*\\.){2}${n}\\b`));
+const componentPairs = [exportedFunctions.map((f) => [f, f]), exportedForwardRefs.map((f) => [(f as any).render, f])]
+	.flat()
+	.map(([s, f]) => [componentNames.find((n, i) => src(s).match(componentRegexes[i])), f]);
+
+export const UI: any = Object.fromEntries(componentPairs);

package/vendor/stdlib/src/webpack/FilterContext.gen.ts

@@ -0,0 +1,10 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import type * as FilterContext_xpui_ts from "./FilterContext.xpui.ts";
+export let FilterContext: typeof FilterContext_xpui_ts.FilterContext;
+import("./FilterContext.xpui.ts").then(m => {
+	FilterContext = m.FilterContext;
+}).catch((e) => console.warn("[stdlib] lazy webpack surface ./FilterContext.xpui.ts failed:", e));

package/vendor/stdlib/src/webpack/FilterContext.ts

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+export * from "./FilterContext.gen.ts";

package/vendor/stdlib/src/webpack/FilterContext.xpui.ts

@@ -0,0 +1,10 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import { exportedContexts } from "./index.ts";
+
+await CHUNKS.xpui.promise;
+
+export const FilterContext = exportedContexts.find((c) => (c as any)._currentValue2?.setFilter)!;

package/vendor/stdlib/src/webpack/Mousetrap.gen.ts

@@ -0,0 +1,10 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import type * as Mousetrap_xpui_ts from "./Mousetrap.xpui.ts";
+export let Mousetrap: typeof Mousetrap_xpui_ts.Mousetrap;
+import("./Mousetrap.xpui.ts").then(m => {
+	Mousetrap = m.Mousetrap;
+}).catch((e) => console.warn("[stdlib] lazy webpack surface ./Mousetrap.xpui.ts failed:", e));

package/vendor/stdlib/src/webpack/Mousetrap.ts

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+export * from "./Mousetrap.gen.ts";

package/vendor/stdlib/src/webpack/Mousetrap.xpui.ts

@@ -0,0 +1,12 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import { exports } from "./index.ts";
+
+import type MousetrapT from "npm:@types/mousetrap";
+
+await CHUNKS.xpui.promise;
+
+export const Mousetrap: typeof MousetrapT = exports.find((m) => m.addKeycodes);

package/vendor/stdlib/src/webpack/React.gen.ts

@@ -0,0 +1,14 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import type * as React_xpui_ts from "./React.xpui.ts";
+export let ReactJSX: typeof React_xpui_ts.ReactJSX;
+export let ReactDOM: typeof React_xpui_ts.ReactDOM;
+export let ReactDOMServer: typeof React_xpui_ts.ReactDOMServer;
+import("./React.xpui.ts").then(m => {
+	ReactJSX = m.ReactJSX;
+	ReactDOM = m.ReactDOM;
+	ReactDOMServer = m.ReactDOMServer;
+}).catch((e) => console.warn("[stdlib] lazy webpack surface ./React.xpui.ts failed:", e));

package/vendor/stdlib/src/webpack/React.ts

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+export * from "./React.gen.ts";

package/vendor/stdlib/src/webpack/React.xpui.ts

@@ -0,0 +1,15 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import { exports } from "./index.ts";
+
+import type ReactDOMT from "npm:@types/react-dom";
+import type ReactDOMServerT from "npm:@types/react-dom/server";
+
+await CHUNKS.xpui.promise;
+
+export const ReactJSX: any = exports.find((m) => m.jsx)!;
+export const ReactDOM: typeof ReactDOMT = exports.find((m) => m.createRoot)!;
+export const ReactDOMServer: typeof ReactDOMServerT = exports.find((m) => m.renderToString)!;

package/vendor/stdlib/src/webpack/ReactComponents.desktop.ts

@@ -0,0 +1,17 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import { analyzeWebpackRequire } from "./index.ts";
+import { webpackRequire } from "../wpunpk.mix.ts";
+
+await (CHUNKS["/xpui-desktop-routes-settings.js"] ??= Promise.withResolvers()).promise;
+
+const { exports } = analyzeWebpackRequire(webpackRequire);
+export const Settings: {
+	SettingsLabel: React.FC<any>;
+	SettingsRow: React.FC<any>;
+	SettingsRowEnd: React.FC<any>;
+	SettingsRowStart: React.FC<any>;
+} = exports.find((m) => m.SettingsRow) as any;