@benliam12/spotify-api-helper 1.0.0-DEV.3

package/README.md

@@ -0,0 +1,2 @@
+# Spotify API Helper
+Help you use the Spotify API without having to implement everything. 

package/dist/core/KPI_Data.d.ts

@@ -0,0 +1,9 @@
+import { MetricDataType } from "./types";
+export declare class KPI_Data {
+    Date: Date | undefined;
+    Data: Partial<Record<MetricDataType, number>>;
+    constructor(date?: Date);
+    set(metric: MetricDataType, value: number): void;
+    get(metric: MetricDataType): number | undefined;
+    clear(metric?: MetricDataType): void;
+}

package/dist/core/KPI_Data.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KPI_Data = void 0;
+class KPI_Data {
+    constructor(date) {
+        this.Data = {};
+        this.Date = date;
+    }
+    set(metric, value) {
+        this.Data[metric] = value;
+    }
+    get(metric) {
+        return this.Data[metric];
+    }
+    clear(metric) {
+        if (metric) {
+            delete this.Data[metric];
+        }
+        else {
+            this.Data = {};
+        }
+    }
+}
+exports.KPI_Data = KPI_Data;

package/dist/core/Project.d.ts

@@ -0,0 +1,21 @@
+import { IProject, ISection } from "./types";
+export declare class Project implements IProject {
+    id: string | undefined;
+    name: string | undefined;
+    description?: string | undefined;
+    sections?: ISection[];
+    constructor(id?: string, name?: string);
+    create(): void;
+    /**
+     * Check if a section exists in the project
+     * @param sectionId Section number.
+     * @returns boolean
+     */
+    hasSection(sectionId: string): boolean;
+    /**
+     * Remove a section from the project
+     * @param sectionId Section number.
+     */
+    removeSection(sectionId: string): void;
+    addSection(section: ISection): void;
+}

package/dist/core/Project.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Project = void 0;
+class Project {
+    constructor(id, name) {
+        this.sections = [];
+        this.id = id;
+        this.name = name;
+    }
+    create() {
+        throw new Error("Method not implemented.");
+    }
+    /**
+     * Check if a section exists in the project
+     * @param sectionId Section number.
+     * @returns boolean
+     */
+    hasSection(sectionId) {
+        for (const section of this.sections || []) {
+            if (section.id === sectionId) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Remove a section from the project
+     * @param sectionId Section number.
+     */
+    removeSection(sectionId) {
+        if (!this.sections) {
+            return;
+        }
+        this.sections = this.sections.filter(section => section.id !== sectionId);
+    }
+    addSection(section) {
+        if (!this.sections) {
+            this.sections = [];
+        }
+        let exists = false;
+        for (const existingSection of this.sections) {
+            if (existingSection.id === section.id) {
+                exists = true;
+                break;
+            }
+        }
+        if (!exists) {
+            this.sections.push(section);
+        }
+    }
+}
+exports.Project = Project;

package/dist/core/Section.d.ts

@@ -0,0 +1,13 @@
+import { IProject, ISection, ITask } from "./types";
+export declare class Section implements ISection {
+    id: string | undefined;
+    projectId: string | undefined;
+    title: string | undefined;
+    content: string | undefined;
+    tasks: ITask[];
+    parentProject?: IProject | undefined;
+    addTask(task: ITask): void;
+    hasTask(taskId: string): boolean;
+    removeTask(taskId: string): void;
+    create(): void;
+}

package/dist/core/Section.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Section = void 0;
+class Section {
+    constructor() {
+        this.tasks = [];
+    }
+    addTask(task) {
+        if (!this.tasks) {
+            this.tasks = [];
+        }
+        let exists = false;
+        for (const existingTask of this.tasks) {
+            if (existingTask.id === task.id) {
+                exists = true;
+                break;
+            }
+        }
+        if (!exists) {
+            this.tasks.push(task);
+        }
+    }
+    hasTask(taskId) {
+        for (const task of this.tasks) {
+            if (task.id === taskId) {
+                return true;
+            }
+        }
+        return false;
+    }
+    removeTask(taskId) {
+        this.tasks = this.tasks.filter(task => task.id !== taskId);
+    }
+    create() {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.Section = Section;

package/dist/core/Spotify/SpotifyConfiguration.d.ts

@@ -0,0 +1,6 @@
+export declare class SpotifyConfiguration {
+    clientId: string;
+    clientSecret: string;
+    redirectUri: string;
+    constructor(clientId: string, clientSecret: string, redirectUri: string);
+}

package/dist/core/Spotify/SpotifyConfiguration.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpotifyConfiguration = void 0;
+class SpotifyConfiguration {
+    constructor(clientId, clientSecret, redirectUri) {
+        this.clientId = clientId;
+        this.clientSecret = clientSecret;
+        this.redirectUri = redirectUri;
+    }
+}
+exports.SpotifyConfiguration = SpotifyConfiguration;

package/dist/core/Spotify/SpotifyHelper.d.ts

@@ -0,0 +1,8 @@
+import { SpotifyConfiguration } from "./SpotifyConfiguration";
+import { Album } from "./SpotifyTypes";
+export declare class SpotifyHelper {
+    config: SpotifyConfiguration;
+    constructor(config: SpotifyConfiguration);
+    getAlbum(albumId: string): Promise<Album | null>;
+    getTrack(trackId: string): Promise<void>;
+}

package/dist/core/Spotify/SpotifyHelper.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpotifyHelper = void 0;
+class SpotifyHelper {
+    constructor(config) {
+        this.config = config;
+    }
+    async getAlbum(albumId) {
+        try {
+        }
+        catch (error) {
+            return null;
+        }
+        return null;
+    }
+    async getTrack(trackId) {
+    }
+}
+exports.SpotifyHelper = SpotifyHelper;

package/dist/core/Spotify/SpotifyTypes.d.ts

@@ -0,0 +1,9 @@
+export interface Album {
+    id: string;
+    market: string;
+    album_type: string;
+    total_tracks: number;
+    available_markets: string[];
+}
+export interface Track {
+}

package/dist/core/Spotify/SpotifyTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/SpotifyConfiguration.d.ts

@@ -0,0 +1,15 @@
+export interface SpotifyConfigOptions {
+    clientId: string;
+    clientSecret: string;
+    redirectUri: string;
+}
+export declare class SpotifyConfiguration {
+    clientId: string;
+    clientSecret: string;
+    redirectUri: string;
+    constructor(config: SpotifyConfigOptions);
+    isValid(): boolean;
+    getClientID(): string;
+    getClientSecret(): string;
+    getRedirectUri(): string;
+}

package/dist/core/SpotifyConfiguration.js

@@ -0,0 +1,19 @@
+export class SpotifyConfiguration {
+    constructor(config) {
+        this.clientId = config.clientId ?? "";
+        this.clientSecret = config.clientSecret ?? "";
+        this.redirectUri = config.redirectUri ?? "";
+    }
+    isValid() {
+        return this.clientId !== "" && this.clientSecret !== "" && this.redirectUri !== "";
+    }
+    getClientID() {
+        return this.clientId;
+    }
+    getClientSecret() {
+        return this.clientSecret;
+    }
+    getRedirectUri() {
+        return this.redirectUri;
+    }
+}

package/dist/core/SpotifyHelper.d.ts

@@ -0,0 +1,116 @@
+import { SpotifyConfiguration } from "./SpotifyConfiguration.js";
+import { Album, Track, Artist } from "./SpotifyTypes.js";
+/**
+ * Result wrapper for operations that can fail
+ */
+export type SpotifyResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: string;
+    statusCode?: number;
+};
+/**
+ * Options for configuring the SpotifyHelper
+ */
+export interface SpotifyHelperOptions {
+    /**
+     * How long before token expiry to refresh (in milliseconds)
+     * Default: 60000 (60 seconds)
+     */
+    tokenRefreshBufferMs?: number;
+    /**
+     * Callback for when errors occur (for logging/monitoring)
+     */
+    onError?: (error: SpotifyError) => void;
+    /**
+     * Whether to log errors to console
+     * Default: false
+     */
+    logErrors?: boolean;
+}
+export interface SpotifyError {
+    message: string;
+    statusCode?: number;
+    operation: string;
+    timestamp: Date;
+}
+export declare class SpotifyHelper {
+    config: SpotifyConfiguration;
+    private clientToken;
+    private tokenRefreshPromise;
+    private readonly options;
+    constructor(config: SpotifyConfiguration, options?: SpotifyHelperOptions);
+    /**
+     * Initialize the helper by fetching the first token.
+     * Returns true if successful, false otherwise.
+     */
+    initialize(): Promise<boolean>;
+    /**
+     * Ensures we have a valid token, refreshing if necessary.
+     * Returns null if token fetch fails (instead of throwing).
+     */
+    private ensureValidToken;
+    /**
+     * Checks if the token is expired or about to expire soon
+     */
+    private isTokenExpiringSoon;
+    /**
+     * Fetches a new token from Spotify.
+     * Returns null if fetch fails (instead of throwing).
+     */
+    private fetchNewToken;
+    /**
+     * Makes an authenticated request to the Spotify API.
+     * Returns a result object instead of throwing.
+     */
+    private makeAuthenticatedRequest;
+    /**
+     * Handle errors consistently - log and/or call callback
+     */
+    private handleError;
+    test(): string;
+    /**
+     * Get an album by ID.
+     * Returns null if the request fails.
+     */
+    getAlbum(albumId: string): Promise<Album | null>;
+    /**
+     * Get a track by ID.
+     * Returns null if the request fails.
+     */
+    getTrack(trackId: string): Promise<Track | null>;
+    /**
+     * Get an artist by ID.
+     * Returns null if the request fails.
+     */
+    getArtist(artistId: string): Promise<Artist | null>;
+    /**
+     * Get a playlist by ID.
+     * Returns null if the request fails.
+     */
+    getPlaylist(playlistId: string): Promise<any | null>;
+    /**
+     * Get available markets.
+     * Returns empty array if the request fails.
+     */
+    getAvailableMarkets(): Promise<string[]>;
+    /**
+     * Check if the helper is properly authenticated.
+     * Useful for health checks.
+     */
+    isAuthenticated(): Promise<boolean>;
+    /**
+     * Manually clear the token (useful for testing or forcing a refresh).
+     */
+    clearToken(): void;
+    /**
+     * Get token info for debugging (without exposing the actual token).
+     */
+    getTokenInfo(): {
+        hasToken: boolean;
+        expiresAt: Date | null;
+        isExpiringSoon: boolean;
+    };
+}

package/dist/core/SpotifyHelper.js

@@ -0,0 +1,263 @@
+export class SpotifyHelper {
+    constructor(config, options = {}) {
+        this.clientToken = null;
+        this.tokenRefreshPromise = null;
+        this.config = config;
+        this.options = {
+            tokenRefreshBufferMs: options.tokenRefreshBufferMs ?? 60000,
+            onError: options.onError ?? (() => { }),
+            logErrors: options.logErrors ?? false
+        };
+    }
+    /**
+     * Initialize the helper by fetching the first token.
+     * Returns true if successful, false otherwise.
+     */
+    async initialize() {
+        const token = await this.ensureValidToken();
+        return token !== null;
+    }
+    /**
+     * Ensures we have a valid token, refreshing if necessary.
+     * Returns null if token fetch fails (instead of throwing).
+     */
+    async ensureValidToken() {
+        // If there's already a refresh in progress, wait for it
+        if (this.tokenRefreshPromise) {
+            return this.tokenRefreshPromise;
+        }
+        // Check if we need to refresh
+        const needsRefresh = !this.clientToken || this.isTokenExpiringSoon();
+        if (needsRefresh) {
+            // Start the refresh and store the promise
+            this.tokenRefreshPromise = this.fetchNewToken();
+            try {
+                this.clientToken = await this.tokenRefreshPromise;
+                return this.clientToken;
+            }
+            finally {
+                // Clear the promise once done (success or failure)
+                this.tokenRefreshPromise = null;
+            }
+        }
+        // Token is still valid, return it
+        return this.clientToken;
+    }
+    /**
+     * Checks if the token is expired or about to expire soon
+     */
+    isTokenExpiringSoon() {
+        if (!this.clientToken) {
+            return true;
+        }
+        const now = new Date();
+        const expiryTime = this.clientToken.expires_at.getTime();
+        const currentTime = now.getTime();
+        return currentTime >= (expiryTime - this.options.tokenRefreshBufferMs);
+    }
+    /**
+     * Fetches a new token from Spotify.
+     * Returns null if fetch fails (instead of throwing).
+     */
+    async fetchNewToken() {
+        const params = new URLSearchParams();
+        params.append('grant_type', 'client_credentials');
+        try {
+            const response = await fetch("https://accounts.spotify.com/api/token", {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                    "Authorization": "Basic " + Buffer.from(this.config.clientId + ":" + this.config.clientSecret).toString("base64")
+                },
+                body: params.toString()
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                this.handleError({
+                    message: `Failed to get token: ${response.status} ${response.statusText} - ${errorText}`,
+                    statusCode: response.status,
+                    operation: "fetchNewToken",
+                    timestamp: new Date()
+                });
+                return null;
+            }
+            const data = await response.json();
+            if (!data.access_token || !data.expires_in) {
+                this.handleError({
+                    message: "Invalid token response from Spotify - missing access_token or expires_in",
+                    operation: "fetchNewToken",
+                    timestamp: new Date()
+                });
+                return null;
+            }
+            const token = {
+                access_token: data.access_token,
+                token_type: data.token_type,
+                expires_at: new Date(Date.now() + data.expires_in * 1000)
+            };
+            return token;
+        }
+        catch (error) {
+            this.handleError({
+                message: `Network error fetching token: ${error instanceof Error ? error.message : String(error)}`,
+                operation: "fetchNewToken",
+                timestamp: new Date()
+            });
+            return null;
+        }
+    }
+    /**
+     * Makes an authenticated request to the Spotify API.
+     * Returns a result object instead of throwing.
+     */
+    async makeAuthenticatedRequest(url, operation, options = {}) {
+        const token = await this.ensureValidToken();
+        if (!token) {
+            return {
+                success: false,
+                error: "Failed to obtain valid authentication token"
+            };
+        }
+        try {
+            const response = await fetch(url, {
+                ...options,
+                headers: {
+                    ...options.headers,
+                    "Authorization": `Bearer ${token.access_token}`
+                }
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                this.handleError({
+                    message: `API request failed: ${response.status} ${response.statusText} - ${errorText}`,
+                    statusCode: response.status,
+                    operation,
+                    timestamp: new Date()
+                });
+                return {
+                    success: false,
+                    error: `Request failed: ${response.status} ${response.statusText}`,
+                    statusCode: response.status
+                };
+            }
+            const data = await response.json();
+            return { success: true, data };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.handleError({
+                message: `Network error during ${operation}: ${errorMessage}`,
+                operation,
+                timestamp: new Date()
+            });
+            return {
+                success: false,
+                error: `Network error: ${errorMessage}`
+            };
+        }
+    }
+    /**
+     * Handle errors consistently - log and/or call callback
+     */
+    handleError(error) {
+        if (this.options.logErrors) {
+            console.error(`[SpotifyHelper] ${error.operation}:`, error.message);
+        }
+        this.options.onError(error);
+    }
+    test() {
+        return "SpotifyHelper is working!";
+    }
+    /**
+     * Get an album by ID.
+     * Returns null if the request fails.
+     */
+    async getAlbum(albumId) {
+        const result = await this.makeAuthenticatedRequest(`https://api.spotify.com/v1/albums/${albumId}`, "getAlbum", { method: "GET" });
+        if (!result.success) {
+            return null;
+        }
+        const data = result.data;
+        const album = {
+            id: data.id,
+            name: data.name,
+            market: data.market,
+            album_type: data.album_type,
+            total_tracks: data.total_tracks,
+            available_markets: data.available_markets
+        };
+        return album;
+    }
+    /**
+     * Get a track by ID.
+     * Returns null if the request fails.
+     */
+    async getTrack(trackId) {
+        const result = await this.makeAuthenticatedRequest(`https://api.spotify.com/v1/tracks/${trackId}`, "getTrack", { method: "GET" });
+        if (!result.success) {
+            return null;
+        }
+        // Map to your Track type based on your type definition
+        // For now returning null as placeholder
+        return null;
+    }
+    /**
+     * Get an artist by ID.
+     * Returns null if the request fails.
+     */
+    async getArtist(artistId) {
+        const result = await this.makeAuthenticatedRequest(`https://api.spotify.com/v1/artists/${artistId}`, "getArtist", { method: "GET" });
+        if (!result.success) {
+            return null;
+        }
+        // Map to your Artist type based on your type definition
+        // For now returning null as placeholder
+        return null;
+    }
+    /**
+     * Get a playlist by ID.
+     * Returns null if the request fails.
+     */
+    async getPlaylist(playlistId) {
+        const result = await this.makeAuthenticatedRequest(`https://api.spotify.com/v1/playlists/${playlistId}`, "getPlaylist", { method: "GET" });
+        if (!result.success) {
+            return null;
+        }
+        return result.data;
+    }
+    /**
+     * Get available markets.
+     * Returns empty array if the request fails.
+     */
+    async getAvailableMarkets() {
+        const result = await this.makeAuthenticatedRequest(`https://api.spotify.com/v1/markets`, "getAvailableMarkets", { method: "GET" });
+        if (!result.success) {
+            return [];
+        }
+        return result.data.markets || [];
+    }
+    /**
+     * Check if the helper is properly authenticated.
+     * Useful for health checks.
+     */
+    async isAuthenticated() {
+        const token = await this.ensureValidToken();
+        return token !== null;
+    }
+    /**
+     * Manually clear the token (useful for testing or forcing a refresh).
+     */
+    clearToken() {
+        this.clientToken = null;
+    }
+    /**
+     * Get token info for debugging (without exposing the actual token).
+     */
+    getTokenInfo() {
+        return {
+            hasToken: this.clientToken !== null,
+            expiresAt: this.clientToken?.expires_at || null,
+            isExpiringSoon: this.isTokenExpiringSoon()
+        };
+    }
+}

package/dist/core/SpotifyTypes.d.ts

@@ -0,0 +1,17 @@
+export interface Album {
+    id: string;
+    name: string;
+    market: string;
+    album_type: string;
+    total_tracks: number;
+    available_markets: string[];
+}
+export interface Track {
+}
+export interface Artist {
+}
+export interface ClientToken {
+    access_token: string;
+    token_type: string;
+    expires_at: Date;
+}

package/dist/core/SpotifyTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/core/Task.d.ts

@@ -0,0 +1,13 @@
+import { ISection, ITask } from "./types";
+export declare class Task implements ITask {
+    id?: string | undefined;
+    parentSection?: ISection | undefined;
+    title: string | undefined;
+    completed: boolean;
+    startDate?: Date | undefined;
+    EndDate?: Date | undefined;
+    CompleteConfirmation?: boolean | undefined;
+    markComplete(): void;
+    markIncomplete(): void;
+    create(): void;
+}

package/dist/core/Task.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Task = void 0;
+class Task {
+    constructor() {
+        this.completed = false;
+    }
+    markComplete() {
+        throw new Error("Method not implemented.");
+    }
+    markIncomplete() {
+        throw new Error("Method not implemented.");
+    }
+    create() {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.Task = Task;

package/dist/core/Utils.d.ts

@@ -0,0 +1,3 @@
+export declare class Utils {
+    generateRandomString(length: number): string;
+}

package/dist/core/Utils.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Utils = void 0;
+class Utils {
+    generateRandomString(length) {
+        var text = '';
+        var possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        for (var i = 0; i < length; i++) {
+            text += possible.charAt(Math.floor(Math.random() * possible.length));
+        }
+        return text;
+    }
+}
+exports.Utils = Utils;

package/dist/core/types.d.ts

@@ -0,0 +1,48 @@
+export interface IProject {
+    id: string | undefined;
+    name: string | undefined;
+    description?: string;
+    sections?: ISection[];
+    addSection(section: ISection): void;
+    hasSection(sectionId: string): boolean;
+    removeSection(sectionId: string): void;
+    create(): void;
+}
+export interface ISection {
+    id: string | undefined;
+    projectId: string | undefined;
+    title: string | undefined;
+    content: string | undefined;
+    tasks: ITask[];
+    parentProject?: IProject;
+    addTask(task: ITask): void;
+    hasTask(taskId: string): boolean;
+    removeTask(taskId: string): void;
+    create(): void;
+}
+export interface ITask {
+    id?: string | undefined;
+    parentSection?: ISection;
+    title: string | undefined;
+    completed: boolean;
+    startDate?: Date;
+    EndDate?: Date;
+    CompleteConfirmation?: boolean;
+    markComplete(): void;
+    markIncomplete(): void;
+    create(): void;
+}
+export declare enum MetricDataType {
+    SHOP_HRS = "SHOP_HRS",
+    ENG_HRS = "ENG_HRS",
+    SHOP_HRS_BUDGET = "SHOP_HRS_BUDGET",
+    ENG_HRS_BUDGET = "ENG_HRS_BUDGET",
+    SHOP_HRS_ACTUAL = "SHOP_HRS_ACTUAL",
+    ENG_HRS_ACTUAL = "ENG_HRS_ACTUAL",
+    SSC_HRS = "SSC_HRS",
+    SSC_HRS_BUDGET = "SSC_HRS_BUDGET",
+    SSC_HRS_ACTUAL = "SSC_HRS_ACTUAL",
+    ESC_HRS = "ESC_HRS",
+    ESC_HRS_BUDGET = "ESC_HRS_BUDGET",
+    ESC_HRS_ACTUAL = "ESC_HRS_ACTUAL"
+}

package/dist/core/types.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricDataType = void 0;
+var MetricDataType;
+(function (MetricDataType) {
+    MetricDataType["SHOP_HRS"] = "SHOP_HRS";
+    MetricDataType["ENG_HRS"] = "ENG_HRS";
+    MetricDataType["SHOP_HRS_BUDGET"] = "SHOP_HRS_BUDGET";
+    MetricDataType["ENG_HRS_BUDGET"] = "ENG_HRS_BUDGET";
+    MetricDataType["SHOP_HRS_ACTUAL"] = "SHOP_HRS_ACTUAL";
+    MetricDataType["ENG_HRS_ACTUAL"] = "ENG_HRS_ACTUAL";
+    MetricDataType["SSC_HRS"] = "SSC_HRS";
+    MetricDataType["SSC_HRS_BUDGET"] = "SSC_HRS_BUDGET";
+    MetricDataType["SSC_HRS_ACTUAL"] = "SSC_HRS_ACTUAL";
+    MetricDataType["ESC_HRS"] = "ESC_HRS";
+    MetricDataType["ESC_HRS_BUDGET"] = "ESC_HRS_BUDGET";
+    MetricDataType["ESC_HRS_ACTUAL"] = "ESC_HRS_ACTUAL";
+})(MetricDataType || (exports.MetricDataType = MetricDataType = {}));

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./core/SpotifyTypes.js";
+export { SpotifyHelper } from "./core/SpotifyHelper.js";
+export { SpotifyConfiguration } from "./core/SpotifyConfiguration.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./core/SpotifyTypes.js";
+export { SpotifyHelper } from "./core/SpotifyHelper.js";
+export { SpotifyConfiguration } from "./core/SpotifyConfiguration.js";

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@benliam12/spotify-api-helper",
+  "version": "1.0.0-DEV.3",
+  "description": "A utility package for Node.js",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "lint": "eslint src --ext .ts",
+    "prepare": "npm run build",
+    "semantic-release": "semantic-release"
+  },
+  "keywords": [
+    "utility",
+    "helpers"
+  ],
+  "author": "benliam12",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Benliam12/SpotifyAPIHelper.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Benliam12/SpotifyAPIHelper/issues"
+  },
+  "homepage": "https://github.com/Benliam12/SpotifyAPIHelper#readme",
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.19.3",
+    "@typescript-eslint/eslint-plugin": "^8.50.1",
+    "@typescript-eslint/parser": "^8.50.1",
+    "eslint": "^9.39.2",
+    "jest": "^29.7.0",
+    "semantic-release": "^25.0.2",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.9.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}