@keystrokehq/spotify 0.0.1

package/dist/player.mjs

@@ -0,0 +1,220 @@
+import { spotifyDeviceSchema, spotifyIdSchema, spotifyMarketSchema, spotifyMutationSuccessSchema, spotifyPlaybackStateSchema, spotifyQueueSchema, spotifyRecentlyPlayedPageSchema, spotifyUriSchema } from "./schemas.mjs";
+import { createSpotifyClient } from "./client.mjs";
+import { t as spotifyOperation } from "./factory-tZba6Hij.mjs";
+import { z } from "zod";
+
+//#region src/player.ts
+const emptyInputSchema = z.object({});
+const playbackTypesSchema = z.array(z.enum(["track", "episode"])).min(1).optional();
+const deviceIdSchema = spotifyIdSchema.optional();
+const currentlyPlayingInputSchema = z.object({
+	market: spotifyMarketSchema.optional(),
+	additionalTypes: playbackTypesSchema
+});
+const transferPlaybackInputSchema = z.object({
+	deviceIds: z.array(spotifyIdSchema).min(1).max(50),
+	play: z.boolean().optional()
+});
+const playbackOffsetSchema = z.object({
+	position: z.number().int().nonnegative().optional(),
+	uri: spotifyUriSchema.optional()
+}).refine((value) => value.position !== void 0 || value.uri !== void 0, { error: "Playback offset must include a position or uri." });
+const startOrResumePlaybackInputSchema = z.object({
+	deviceId: deviceIdSchema,
+	contextUri: spotifyUriSchema.optional(),
+	uris: z.array(spotifyUriSchema).min(1).max(100).optional(),
+	offset: playbackOffsetSchema.optional(),
+	positionMs: z.number().int().nonnegative().optional()
+});
+const withOptionalDeviceIdSchema = z.object({ deviceId: deviceIdSchema });
+const seekToPositionInputSchema = withOptionalDeviceIdSchema.extend({ positionMs: z.number().int().nonnegative() });
+const repeatModeInputSchema = withOptionalDeviceIdSchema.extend({ state: z.enum([
+	"track",
+	"context",
+	"off"
+]) });
+const playbackVolumeInputSchema = withOptionalDeviceIdSchema.extend({ volumePercent: z.number().int().min(0).max(100) });
+const shuffleModeInputSchema = withOptionalDeviceIdSchema.extend({ state: z.boolean() });
+const getRecentlyPlayedInputSchema = z.object({
+	limit: z.number().int().positive().max(50).optional(),
+	after: z.number().int().nonnegative().optional(),
+	before: z.number().int().nonnegative().optional()
+}).refine((value) => !(value.after !== void 0 && value.before !== void 0), { error: "Specify only one of after or before." });
+const addToQueueInputSchema = withOptionalDeviceIdSchema.extend({ uri: spotifyUriSchema });
+const availableDevicesResponseSchema = z.object({ devices: z.array(spotifyDeviceSchema) });
+function hasPlaybackBody(input) {
+	return input.contextUri !== void 0 || input.uris !== void 0 || input.offset !== void 0 || input.positionMs !== void 0;
+}
+const getPlaybackState = spotifyOperation({
+	id: "get_playback_state",
+	name: "Get Playback State",
+	description: "Fetch the current Spotify playback state for the connected account.",
+	input: z.object({ market: spotifyMarketSchema.optional() }),
+	output: spotifyPlaybackStateSchema.nullable(),
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).player.getPlaybackState(input.market);
+	}
+});
+const transferPlayback = spotifyOperation({
+	id: "transfer_playback",
+	name: "Transfer Playback",
+	description: "Transfer Spotify playback to another available device.",
+	input: transferPlaybackInputSchema,
+	output: spotifyMutationSuccessSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).player.transferPlayback(input);
+	}
+});
+const getAvailableDevices = spotifyOperation({
+	id: "get_available_devices",
+	name: "Get Available Devices",
+	description: "List Spotify devices available for playback.",
+	input: emptyInputSchema,
+	output: availableDevicesResponseSchema,
+	run: async (_input, credentials) => {
+		return createSpotifyClient(credentials).player.getAvailableDevices();
+	}
+});
+const getCurrentlyPlaying = spotifyOperation({
+	id: "get_currently_playing",
+	name: "Get Currently Playing",
+	description: "Fetch the currently playing Spotify track or episode, if any.",
+	input: currentlyPlayingInputSchema,
+	output: spotifyPlaybackStateSchema.nullable(),
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).player.getCurrentlyPlaying({
+			market: input.market,
+			additional_types: input.additionalTypes
+		});
+	}
+});
+const startOrResumePlayback = spotifyOperation({
+	id: "start_or_resume_playback",
+	name: "Start Or Resume Playback",
+	description: "Start or resume Spotify playback on an active or selected device.",
+	input: startOrResumePlaybackInputSchema,
+	output: spotifyMutationSuccessSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = createSpotifyClient(credentials);
+		const body = hasPlaybackBody(input) ? {
+			contextUri: input.contextUri,
+			uris: input.uris,
+			offset: input.offset,
+			positionMs: input.positionMs
+		} : void 0;
+		return client.player.startOrResumePlayback(body, input.deviceId);
+	}
+});
+const pausePlayback = spotifyOperation({
+	id: "pause_playback",
+	name: "Pause Playback",
+	description: "Pause Spotify playback on the current or selected device.",
+	input: withOptionalDeviceIdSchema,
+	output: spotifyMutationSuccessSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).player.pausePlayback(input.deviceId);
+	}
+});
+const skipToNext = spotifyOperation({
+	id: "skip_to_next",
+	name: "Skip To Next",
+	description: "Skip to the next Spotify item in the active queue.",
+	input: withOptionalDeviceIdSchema,
+	output: spotifyMutationSuccessSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).player.skipToNext(input.deviceId);
+	}
+});
+const skipToPrevious = spotifyOperation({
+	id: "skip_to_previous",
+	name: "Skip To Previous",
+	description: "Skip to the previous Spotify item in the active queue.",
+	input: withOptionalDeviceIdSchema,
+	output: spotifyMutationSuccessSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).player.skipToPrevious(input.deviceId);
+	}
+});
+const seekToPosition = spotifyOperation({
+	id: "seek_to_position",
+	name: "Seek To Position",
+	description: "Seek the currently playing Spotify item to a new playback position.",
+	input: seekToPositionInputSchema,
+	output: spotifyMutationSuccessSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).player.seekToPosition(input.positionMs, input.deviceId);
+	}
+});
+const setRepeatMode = spotifyOperation({
+	id: "set_repeat_mode",
+	name: "Set Repeat Mode",
+	description: "Set Spotify repeat mode for the current or selected device.",
+	input: repeatModeInputSchema,
+	output: spotifyMutationSuccessSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).player.setRepeatMode(input.state, input.deviceId);
+	}
+});
+const setPlaybackVolume = spotifyOperation({
+	id: "set_playback_volume",
+	name: "Set Playback Volume",
+	description: "Set Spotify playback volume on the current or selected device.",
+	input: playbackVolumeInputSchema,
+	output: spotifyMutationSuccessSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).player.setPlaybackVolume(input.volumePercent, input.deviceId);
+	}
+});
+const setShuffleMode = spotifyOperation({
+	id: "set_shuffle_mode",
+	name: "Set Shuffle Mode",
+	description: "Enable or disable Spotify shuffle mode.",
+	input: shuffleModeInputSchema,
+	output: spotifyMutationSuccessSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).player.setShuffleMode(input.state, input.deviceId);
+	}
+});
+const getRecentlyPlayed = spotifyOperation({
+	id: "get_recently_played",
+	name: "Get Recently Played",
+	description: "List recently played Spotify tracks for the connected account.",
+	input: getRecentlyPlayedInputSchema,
+	output: spotifyRecentlyPlayedPageSchema,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).player.getRecentlyPlayed(input);
+	}
+});
+const addToQueue = spotifyOperation({
+	id: "add_to_queue",
+	name: "Add To Queue",
+	description: "Add a track or episode to the Spotify playback queue.",
+	input: addToQueueInputSchema,
+	output: spotifyMutationSuccessSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		return createSpotifyClient(credentials).player.addToQueue(input.uri, input.deviceId);
+	}
+});
+const getQueue = spotifyOperation({
+	id: "get_queue",
+	name: "Get Queue",
+	description: "Fetch the current Spotify playback queue.",
+	input: emptyInputSchema,
+	output: spotifyQueueSchema,
+	run: async (_input, credentials) => {
+		return createSpotifyClient(credentials).player.getQueue();
+	}
+});
+
+//#endregion
+export { addToQueue, getAvailableDevices, getCurrentlyPlaying, getPlaybackState, getQueue, getRecentlyPlayed, pausePlayback, seekToPosition, setPlaybackVolume, setRepeatMode, setShuffleMode, skipToNext, skipToPrevious, startOrResumePlayback, transferPlayback };