ambient-display 1.1.0

package/server/api/interact.js

@@ -0,0 +1,234 @@
+import { memo } from '../memo.js';
+import { DEFAULT_OPTIONS } from '../constants.js';
+import { trim, getContext } from './utils.js';
+
+export const SpotifyInteract = {
+	device: {
+		/**
+		 *
+		 * @param {import('@spotify/web-api-ts-sdk').SpotifyApi} sdk
+		 * @param {import('@spotify/web-api-ts-sdk').Market} market
+		 */
+		async get(sdk, market = 'GB') {
+			return sdk.player.getPlaybackState(market);
+		}
+	},
+
+	artist: {
+		/**
+		 *
+		 * @param {import('@spotify/web-api-ts-sdk').SpotifyApi} sdk
+		 * @param {string} id
+		 * @param {import('@spotify/web-api-ts-sdk').Market} market
+		 */
+		async topTracks(sdk, id, market = 'GB') {
+			/** @type {import('@spotify/web-api-ts-sdk').TopTracksResult} */
+			const results = await memo.use(memo.key('artist', 'tracks', id), () =>
+				sdk.artists.topTracks(id, market)
+			);
+
+			return {
+				tracks: results.tracks.map(trim.track)
+			};
+		}
+	},
+
+	album: {
+		/**
+		 *
+		 * @param {import('@spotify/web-api-ts-sdk').SpotifyApi} sdk
+		 * @param {string} id
+		 */
+		async get(sdk, id) {
+			/** @type {import('@spotify/web-api-ts-sdk').Album} */
+			const album = await memo.use(memo.key('album', id), () => sdk.albums.get(id));
+
+			return {
+				tracks: album.tracks.items
+					.map((item) => ({
+						...item,
+						album: album
+					}))
+					.map(trim.track)
+			};
+		}
+	},
+
+	track: {
+		/**
+		 *
+		 * @param {import('@spotify/web-api-ts-sdk').SpotifyApi} sdk
+		 * @param {string} id
+		 */
+		async get(sdk, id) {
+			/** @type {import('@spotify/web-api-ts-sdk').Track} */
+			const track = await memo.use(memo.key('track', id), () => sdk.tracks.get(id));
+
+			return {
+				tracks: [trim.track(track)]
+			};
+		}
+	},
+
+	queue: {
+		/**
+		 *
+		 * @param {import('@spotify/web-api-ts-sdk').SpotifyApi} sdk
+		 */
+		async get(sdk) {
+			const queue = await sdk.player.getUsersQueue();
+
+			if (!queue) {
+				return {
+					noQueue: true
+				};
+			}
+
+			return {
+				items: [queue.currently_playing, ...queue.queue]
+					.filter((item) => !!item)
+					.filter((item) => !['episode', 'track'].includes(item.type))
+					.map((item) => {
+						switch (item.type) {
+							case 'episode':
+								return trim.episode(item);
+							default:
+								return trim.track(item);
+						}
+					})
+			};
+		},
+
+		/**
+		 *
+		 * @param {import('@spotify/web-api-ts-sdk').SpotifyApi} sdk
+		 * @param {string} uri
+		 */
+		async add(sdk, uri) {
+			const { queue } = await sdk.player.getUsersQueue();
+
+			// Check if the item the user is trying to add is already in the queue
+			if (queue.some((item) => item.uri === uri)) {
+				return {
+					success: false
+				};
+			}
+
+			await sdk.player.addItemToPlaybackQueue(uri);
+
+			return {
+				success: true
+			};
+		}
+	},
+
+	search: {
+		/**
+		 *
+		 * @param {import('@spotify/web-api-ts-sdk').SpotifyApi} sdk
+		 * @param {string} q
+		 * @param {import('@spotify/web-api-ts-sdk').Market} q
+		 * @param {number} q
+		 */
+		async query(
+			sdk,
+			q,
+			market = DEFAULT_OPTIONS.api.market,
+			searchQueryLimit = DEFAULT_OPTIONS.api.searchQueryLimit
+		) {
+			const results = await memo.use(memo.key('search', q), () =>
+				sdk.search(q, ['track', 'artist', 'album'], market, searchQueryLimit)
+			);
+
+			return {
+				albums: results.albums.items.map(trim.album),
+				artists: results.artists.items.map(trim.artist),
+				tracks: results.tracks.items.map(trim.track)
+			};
+		}
+	},
+
+	context: {
+		/**
+		 *
+		 * @param {import('@spotify/web-api-ts-sdk').SpotifyApi} sdk
+		 */
+		async get(sdk, uri) {
+			/** @type {Types.ApiContext | {}} */
+			const context = await memo.use(uri, () => getContext(sdk, uri));
+
+			return context;
+		}
+	},
+
+	info: {
+		/**
+		 *
+		 * @param {import('@spotify/web-api-ts-sdk').SpotifyApi} sdk
+		 * @param {import('@spotify/web-api-ts-sdk').Market} [market]
+		 */
+		async get(sdk, market = DEFAULT_OPTIONS.api.market) {
+			const track = await sdk.player.getCurrentlyPlayingTrack(market, 'episode');
+
+			if (!track) {
+				return {
+					noTrack: true
+				};
+			}
+
+			const context = await SpotifyInteract.context.get(sdk, track.context.uri);
+
+			return {
+				isPlaying: track.is_playing,
+				track:
+					track.currently_playing_type === 'episode'
+						? trim.episode(track.item)
+						: trim.track(track.item),
+				context,
+				player: {
+					current: track.progress_ms,
+					duration: track.item.duration_ms
+				}
+			};
+		}
+	},
+
+	player: {
+		/**
+		 *
+		 * @param {import('@spotify/web-api-ts-sdk').SpotifyApi} sdk
+		 */
+		async play(sdk) {
+			await sdk.player.startResumePlayback();
+
+			return { success: true };
+		},
+		/**
+		 *
+		 * @param {import('@spotify/web-api-ts-sdk').SpotifyApi} sdk
+		 */
+		async pause(sdk) {
+			await sdk.player.pausePlayback();
+
+			return { success: true };
+		},
+		/**
+		 *
+		 * @param {import('@spotify/web-api-ts-sdk').SpotifyApi} sdk
+		 */
+		async forward(sdk) {
+			await sdk.player.skipToNext();
+
+			return { success: true };
+		},
+		/**
+		 *
+		 * @param {import('@spotify/web-api-ts-sdk').SpotifyApi} sdk
+		 */
+		async back(sdk) {
+			await sdk.player.skipToPrevious();
+
+			return { success: true };
+		}
+	}
+};

package/server/api/utils.js

@@ -0,0 +1,284 @@
+import * as Types from '../types/data.js';
+
+/**
+ *
+ * @param {string} id
+ * @param {string} name
+ * @param {string} subtitle
+ * @param {string} uri
+ * @param {{url: string, width: number, height: number}[]} images
+ * @returns {Types.ApiNormalisedItem}
+ */
+export const normalisedData = (id, name, subtitle, uri, images) => ({
+	id,
+	title: name,
+	subtitle,
+	uri: uri,
+	image: {
+		full: images.at(0),
+		low: images.at(-1)
+	}
+});
+
+export const trim = {
+	/**
+	 *
+	 * @param {import('@spotify/web-api-ts-sdk').Track} track
+	 * @returns {Types.ApiTrackItem & Types.ApiNormalisedItem}
+	 */
+	track(track) {
+		return {
+			id: track.id,
+			normalised: normalisedData(
+				track.id,
+				track.name,
+				track.artists[0].name,
+				track.uri,
+				track?.album?.images ?? []
+			),
+			title: track.name,
+			album: track.album.name,
+			artist: track.artists[0].name,
+			artists: track.artists.map((artist) => artist.name),
+			number: track.track_number,
+			uri: track.uri,
+			image: {
+				full: track.album.images.at(0),
+				low: track.album.images.at(-1)
+			}
+		};
+	},
+	/**
+	 *
+	 * @param {import('@spotify/web-api-ts-sdk').Playlist} playlist
+	 * @returns {Types.ApiPlaylistItem & Types.ApiNormalisedItem}
+	 */
+	playlist(playlist) {
+		return {
+			id: playlist.id,
+			normalised: normalisedData(
+				playlist.id,
+				playlist.name,
+				playlist.owner.display_name,
+				playlist.uri,
+				playlist.images
+			),
+			title: playlist.name,
+			owner: playlist.owner.display_name,
+			total: playlist.tracks.total,
+			uri: playlist.uri,
+			image: {
+				full: playlist.images.at(0),
+				low: playlist.images.at(-1)
+			}
+		};
+	},
+	/**
+	 *
+	 * @param {import('@spotify/web-api-ts-sdk').Artist} artist
+	 * @returns {Types.ApiArtistItem & Types.ApiNormalisedItem}
+	 */
+	artist(artist) {
+		return {
+			id: artist.id,
+			normalised: normalisedData(artist.id, artist.name, '', artist.uri, artist.images),
+			title: artist.name,
+			uri: artist.uri,
+			image: {
+				full: artist.images.at(0),
+				low: artist.images.at(-1)
+			}
+		};
+	},
+	/**
+	 *
+	 * @param {import('@spotify/web-api-ts-sdk').Album} album
+	 * @returns {Types.ApiAlbumItem & Types.ApiNormalisedItem}
+	 */
+	album(album) {
+		return {
+			normalised: normalisedData(
+				album.id,
+				album.name,
+				album.release_date.split('-').shift() ?? '',
+				album.uri,
+				album.images
+			),
+			id: album.id,
+			title: album.name,
+			release: album.release_date,
+			uri: album.uri,
+			total: album.total_tracks,
+			image: {
+				full: album.images.at(0),
+				low: album.images.at(-1)
+			}
+		};
+	},
+	/**
+	 *
+	 * @param {import('@spotify/web-api-ts-sdk').Episode} episode
+	 * @returns {Types.ApiEpisodeItem & Types.ApiNormalisedItem}
+	 */
+	episode(episode) {
+		return {
+			id: episode.id,
+			normalised: normalisedData(
+				episode.id,
+				episode.name,
+				episode.show.name,
+				episode.uri,
+				episode.images
+			),
+			title: episode.name,
+			show: episode.show.name,
+			release: episode.release_date,
+			uri: episode.uri,
+			image: {
+				full: episode.images.at(0),
+				low: episode.images.at(-1)
+			}
+		};
+	},
+	/**
+	 *
+	 * @param {import('@spotify/web-api-ts-sdk').Show} show
+	 * @returns {Types.ApiShowItem & Types.ApiNormalisedItem}
+	 */
+	show(show) {
+		return {
+			id: show.id,
+			normalised: normalisedData(show.id, show.name, '', show.uri, show.images),
+			title: show.name,
+			uri: show.uri,
+			image: {
+				full: show.images.at(0),
+				low: show.images.at(-1)
+			}
+		};
+	}
+};
+
+/**
+ *
+ * @param {string} uri Spotify URI
+ */
+export const deconstructUri = (uri) => {
+	const [_, type, id] = uri.split(':');
+
+	return {
+		type,
+		id
+	};
+};
+
+/**
+ *
+ * @param {import('@spotify/web-api-ts-sdk').SpotifyApi} sdk
+ * @param {string} uri
+ * @return {Promise<Types.ApiContext | {}>}
+ */
+export const getContext = async (sdk, uri) => {
+	const { type, id } = deconstructUri(uri);
+
+	try {
+		switch (type) {
+			case 'playlist': {
+				const playlist = await sdk.playlists.getPlaylist(id);
+
+				return {
+					...trim.playlist(playlist),
+					type: 'playlist'
+				};
+			}
+			case 'artist': {
+				const artist = await sdk.artists.get(id);
+
+				return {
+					...trim.artist(artist),
+					type: 'artist'
+				};
+			}
+			case 'album': {
+				const album = await sdk.albums.get(id);
+
+				return {
+					...trim.album(album),
+					type: 'album'
+				};
+			}
+			case 'show': {
+				const show = await sdk.shows.get(id);
+
+				return {
+					...trim.show(show),
+					type: 'show'
+				};
+			}
+			default: {
+				return {};
+			}
+		}
+	} catch {
+		return {};
+	}
+};
+
+/**
+ *
+ * @param {(req: import('express').Request & {sdk: import('@spotify/web-api-ts-sdk').SpotifyApi}, res: import('express').Response, next?: import('express').NextFunction)} handler
+ * @returns
+ */
+export function apiWrapper(handler) {
+	return async (
+		/** @type {import('express').Request & {sdk: import('@spotify/web-api-ts-sdk').SpotifyApi, history: import('../history.js').CommandHistory}} */ req,
+		/** @type {import('express').Response} */ res,
+		/** @type {import('express').NextFunction} */ next
+	) => {
+		try {
+			req.history.add({
+				type: req.path,
+				params: req.params
+			});
+			await handler(req, res);
+		} catch (e) {
+			console.error('API Error', e);
+			// req.comms.error('Check Logs');
+			next(e);
+		}
+	};
+}
+
+const SpotifyRegExp = new RegExp(
+	/https?:\/\/(?:embed\.|open\.)(?:spotify\.com\/)(?:(track|album|artist)\/|\?uri=spotify:(track|album|artist):)((\w|-){22})/
+);
+
+export function isSpotifyUrl(url) {
+	return SpotifyRegExp.test(url);
+}
+
+export function SpotifyUrl(url) {
+	const [_, typeOne, typeTwo, id] = SpotifyRegExp.exec(url);
+
+	return {
+		type: typeOne || typeTwo,
+		id
+	};
+}
+
+/**
+ *
+ * @param {boolean[]} switches
+ * @returns {(req: import("express").Request, req: import("express").Response, req: import("express").NextFunction)}
+ */
+export const protect = (switches) => {
+	return (req, res, next) => {
+		if (!switches.every((item) => !!item)) {
+			req.comms.error('Not allowed');
+
+			return res.json({ success: false });
+		}
+
+		next();
+	};
+};

package/server/comms.js

@@ -0,0 +1,13 @@
+export const comms = (io) => {
+	return {
+		message(message, type = 'info') {
+			return io.emit('message', {
+				type,
+				message
+			});
+		},
+		error(message) {
+			return this.message(`Error: ${message}`, 'error');
+		}
+	};
+};

package/server/config.js

@@ -0,0 +1,27 @@
+import deepmerge from 'deepmerge';
+import dotenv from 'dotenv';
+import * as Types from './types/options.js';
+
+import { DEFAULT_OPTIONS } from './constants.js';
+import { expandAliases, getIp } from './utils.js';
+
+dotenv.config();
+
+const INJECTED_OPTIONS = {
+	verbose: 'VERBOSE' in process.env && process.env.VERBOSE?.toLowerCase() !== 'false',
+	origin: process.env.ORIGIN ?? getIp(),
+	protocol: process.env.PROTOCOL ?? 'http://',
+	port: process.env.PORT ?? 3000,
+	spotify: {
+		client_id: process.env.SPOTIFY_CLIENT_ID,
+		client_secret: process.env.SPOTIFY_CLIENT_SECRET
+	}
+};
+
+/** @type {Types.Config} */
+const USER_OPTIONS = await import(expandAliases(process.env.CONFIG ?? '../ambient.config.js'))
+	.then((module) => module.default)
+	.catch(() => ({}));
+
+/** @type {Types.SpotifyAmbientDisplayOptions & {plugins: Types.Config['plugins']}} */
+export const OPTIONS = deepmerge(DEFAULT_OPTIONS, deepmerge(INJECTED_OPTIONS, USER_OPTIONS));

package/server/constants.js

@@ -0,0 +1,52 @@
+import * as Types from './types/options.js';
+
+export const ERROR = {
+	GENERAL: 'api/general',
+	UNAUTHENTICATED: 'api/unauthenticated',
+	SPOTIFY_UNAUTHENTICATED: 'spotify/unauthenticated',
+	SPOTIFY_REAUTHENTICATE: 'spotify/reauthenticate',
+
+	SPOTIFY_RATE_LIMIT: 'spotify/rate-limit',
+	SPOTIFY_RESTRICTED: 'spotify/restricted',
+	SPOTIFY_ERROR: 'spotify/spotify-general'
+};
+
+export const EVENT = {
+	APP_ERROR: 'app:error',
+	SYSTEM: 'system'
+};
+
+/** @type {Types.Config} */
+export const DEFAULT_OPTIONS = {
+	port: 3000,
+	origin: '',
+	protocol: 'http://',
+
+	verbose: false,
+
+	playerRoute: '/player',
+
+	api: {
+		market: 'GB',
+		searchQueryLimit: 10,
+		centralisedPolling: true,
+		centralisedPollingTimer: 5000,
+		canAdd: true,
+		canControl: true
+	},
+
+	spotify: {
+		client_id: '',
+		client_secret: '',
+		routePrefix: '/spotify',
+		routeToken: '/token',
+		authenticatedRedirect: '/',
+		accessTokenJsonLocation: '$HOME/.ambient/spotify_auth.json',
+		scope: []
+	},
+
+	plugins: [],
+	pluginOptions: {},
+
+	suppressErrors: []
+};

package/server/events.js

@@ -0,0 +1,41 @@
+import EventEmitter from 'node:events';
+import { EVENT } from './constants.js';
+
+export class AppEventEmitter extends EventEmitter {
+	constructor() {
+		super();
+	}
+
+	/**
+	 *
+	 * @param {string} eventName
+	 * @param {string} message
+	 * @param {Record<any, any>} [data]
+	 */
+	emit(eventName, message, data = {}) {
+		super.emit(eventName, {
+			message,
+			data
+		});
+	}
+
+	/**
+	 *
+	 * @param {string} message
+	 * @param {any} detail
+	 */
+	error(message, detail = null) {
+		this.emit(EVENT.APP_ERROR, message, detail);
+	}
+
+	/**
+	 *
+	 * @param {string} event
+	 * @param {string} message
+	 */
+	system(event, message = '') {
+		this.emit([EVENT.SYSTEM, event].join(':'), message);
+	}
+}
+
+export const events = new AppEventEmitter();

package/server/history.js

@@ -0,0 +1,47 @@
+/**
+ * @typedef {object} CommandHistory
+ * @property {CommandHistoryItem[]} items
+ * @property {CommandHistoryItem | undefined} last
+ * @property {(item: CommandHistoryItem) => CommandHistory} add
+ */
+
+/**
+ * @typedef {{type: string} & Record<string, any>} CommandHistoryItem
+ */
+
+/**
+ *
+ * @param {number} [size]
+ * @returns {CommandHistory}
+ */
+export const CommandHistory = (size = 10) => {
+	let maxSize = size;
+
+	/** @type {CommandHistoryItem[]} */
+	let items = [];
+
+	return {
+		get items() {
+			return items;
+		},
+		get last() {
+			return items.at(-1);
+		},
+
+		/**
+		 *
+		 * @param {CommandHistoryItem} item
+		 * @returns {CommandHistory}
+		 */
+		add(item) {
+			const i = items.slice().reverse();
+
+			i.unshift(item);
+			i.slice(0, maxSize);
+
+			items = i.reverse();
+
+			return this;
+		}
+	};
+};