gscdump 0.0.1 → 0.1.1

package/dist/index.mjs

@@ -17,134 +17,6 @@ function createSorter(getValue, defaultMetric, defaultOrder = "desc") {
 	};
 }
 
-//#endregion
-//#region src/analysis/striking-distance.ts
-const sortResults$4 = createSorter((item, metric) => item[metric], "potentialClicks");
-/**
-* Finds striking distance keywords - high impressions, low CTR, position 4-20.
-* These are "quick wins" that could gain significant traffic with small ranking improvements.
-*/
-function analyzeStrikingDistance(keywords, options = {}) {
-	const { minPosition = 4, maxPosition = 20, minImpressions = 100, maxCtr = .05, sortBy = "potentialClicks", sortOrder = "desc" } = options;
-	const results = [];
-	for (const row of keywords) {
-		const position = num(row.position);
-		const impressions = num(row.impressions);
-		const ctr = num(row.ctr);
-		const clicks = num(row.clicks);
-		if (position < minPosition || position > maxPosition) continue;
-		if (impressions < minImpressions) continue;
-		if (ctr > maxCtr) continue;
-		const potentialClicks = Math.round(impressions * .15);
-		results.push({
-			keyword: row.keyword,
-			page: row.page ?? null,
-			clicks,
-			impressions,
-			ctr,
-			position,
-			potentialClicks
-		});
-	}
-	return sortResults$4(results, sortBy, sortOrder);
-}
-
-//#endregion
-//#region src/analysis/opportunity.ts
-const EXPECTED_CTR_BY_POSITION = {
-	1: .3,
-	2: .15,
-	3: .1,
-	4: .07,
-	5: .05,
-	6: .04,
-	7: .03,
-	8: .025,
-	9: .02,
-	10: .015
-};
-function getExpectedCtr(position) {
-	return EXPECTED_CTR_BY_POSITION[Math.round(Math.max(1, Math.min(position, 10)))] || .01;
-}
-/**
-* Position score: higher for positions 4-20 (improvable range).
-* Peak opportunity at positions 8-15.
-*/
-function calculatePositionScore(position) {
-	if (position <= 3) return .2;
-	if (position > 50) return .1;
-	const distance = Math.abs(position - 11);
-	return Math.max(0, 1 - distance / 15);
-}
-/**
-* Impression score using log scale.
-* Higher impressions = more traffic potential.
-*/
-function calculateImpressionScore(impressions) {
-	if (impressions <= 0) return 0;
-	return Math.min(Math.log10(impressions) / 5, 1);
-}
-/**
-* CTR gap score: difference between actual and expected CTR.
-* Higher gap = more opportunity for improvement.
-*/
-function calculateCtrGapScore(actualCtr, position) {
-	const expectedCtr = getExpectedCtr(position);
-	if (actualCtr >= expectedCtr) return 0;
-	const gap = expectedCtr - actualCtr;
-	return Math.min(gap / expectedCtr, 1);
-}
-const SORT_ORDER$1 = {
-	opportunityScore: "desc",
-	potentialClicks: "desc",
-	impressions: "desc",
-	position: "asc"
-};
-const sortResults$3 = createSorter((item, metric) => item[metric], "opportunityScore");
-/**
-* Scores keywords by optimization opportunity.
-* Composite score combining position, impressions, and CTR gap factors.
-*/
-function analyzeOpportunity(keywords, options = {}) {
-	const { minImpressions = 100, weights = {}, sortBy = "opportunityScore" } = options;
-	const positionWeight = weights.position ?? 1;
-	const impressionsWeight = weights.impressions ?? 1;
-	const ctrGapWeight = weights.ctrGap ?? 1;
-	const results = [];
-	for (const row of keywords) {
-		const impressions = num(row.impressions);
-		const position = num(row.position);
-		const ctr = num(row.ctr);
-		const clicks = num(row.clicks);
-		if (impressions < minImpressions) continue;
-		const positionScore = calculatePositionScore(position);
-		const impressionScore = calculateImpressionScore(impressions);
-		const ctrGapScore = calculateCtrGapScore(ctr, position);
-		const weightedProduct = positionScore ** positionWeight * impressionScore ** impressionsWeight * ctrGapScore ** ctrGapWeight;
-		const totalWeight = positionWeight + impressionsWeight + ctrGapWeight;
-		const geometricMean = Math.pow(weightedProduct, 1 / totalWeight);
-		const opportunityScore = Math.round(geometricMean * 100);
-		const targetCtr = getExpectedCtr(Math.min(3, position));
-		const potentialClicks = Math.round(impressions * targetCtr);
-		results.push({
-			keyword: row.keyword,
-			page: row.page ?? null,
-			clicks,
-			impressions,
-			ctr,
-			position,
-			opportunityScore,
-			potentialClicks,
-			factors: {
-				positionScore,
-				impressionScore,
-				ctrGapScore
-			}
-		});
-	}
-	return sortResults$3(results, sortBy, SORT_ORDER$1[sortBy]);
-}
-
 //#endregion
 //#region src/analysis/brand.ts
 /**
@@ -177,6 +49,153 @@ function analyzeBrandSegmentation(keywords, options) {
 	};
 }
 
+//#endregion
+//#region src/analysis/cannibalization.ts
+const sortResults$4 = createSorter((item, metric) => {
+	switch (metric) {
+		case "clicks": return item.totalClicks;
+		case "impressions": return item.totalImpressions;
+		case "positionSpread": return item.positionSpread;
+		case "pageCount": return item.pages.length;
+	}
+}, "clicks");
+/**
+* Detects keyword cannibalization - queries ranking for multiple pages.
+* Returns queries where multiple pages compete for the same search term.
+*
+* @param rows Query+page data rows
+* @param options Filtering and sorting options
+*/
+function analyzeCannibalization(rows, options = {}) {
+	const { minImpressions = 10, maxPositionSpread = 10, minPages = 2, sortBy = "clicks", sortOrder = "desc" } = options;
+	const queryMap = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		if (row.impressions < minImpressions) continue;
+		const pages = queryMap.get(row.query) || [];
+		pages.push({
+			page: row.page,
+			clicks: row.clicks,
+			impressions: row.impressions,
+			ctr: row.ctr,
+			position: row.position
+		});
+		queryMap.set(row.query, pages);
+	}
+	const results = [];
+	for (const [query$1, pages] of queryMap) {
+		if (pages.length < minPages) continue;
+		pages.sort((a, b) => b.clicks - a.clicks);
+		const positions = pages.map((p) => p.position);
+		const positionSpread = Math.max(...positions) - Math.min(...positions);
+		if (positionSpread > maxPositionSpread) continue;
+		results.push({
+			query: query$1,
+			pages,
+			totalClicks: pages.reduce((sum, p) => sum + p.clicks, 0),
+			totalImpressions: pages.reduce((sum, p) => sum + p.impressions, 0),
+			positionSpread
+		});
+	}
+	return sortResults$4(results, sortBy, sortOrder);
+}
+
+//#endregion
+//#region src/analysis/clustering.ts
+const INTENT_PREFIXES = [
+	"how to",
+	"what is",
+	"what are",
+	"why is",
+	"why do",
+	"where to",
+	"when to",
+	"best",
+	"top",
+	"vs",
+	"versus",
+	"compare",
+	"review",
+	"buy",
+	"cheap",
+	"free",
+	"near me"
+];
+function extractIntentPrefix(keyword) {
+	const lower = keyword.toLowerCase();
+	for (const prefix of INTENT_PREFIXES) if (lower.startsWith(`${prefix} `) || lower.startsWith(prefix)) return prefix;
+	return null;
+}
+function extractWordPrefix(keyword, wordCount = 2) {
+	const words = keyword.toLowerCase().split(/\s+/).filter(Boolean);
+	if (words.length < wordCount + 1) return null;
+	return words.slice(0, wordCount).join(" ");
+}
+/**
+* Clusters keywords by intent prefix or common word prefix.
+* Simple regex/prefix approach - no external NLP dependencies.
+*
+* @param keywords Array of keyword data
+* @param options Clustering options
+*/
+function analyzeClustering(keywords, options = {}) {
+	const { minClusterSize = 2, minImpressions = 10, clusterBy = "both" } = options;
+	const filtered = keywords.filter((k) => num(k.impressions) >= minImpressions);
+	const clusterMap = /* @__PURE__ */ new Map();
+	const clusteredKeywords = /* @__PURE__ */ new Set();
+	if (clusterBy === "intent" || clusterBy === "both") for (const kw of filtered) {
+		const intent = extractIntentPrefix(kw.keyword);
+		if (intent) {
+			const existing = clusterMap.get(intent);
+			if (existing) existing.keywords.push(kw);
+			else clusterMap.set(intent, {
+				type: "intent",
+				keywords: [kw]
+			});
+			clusteredKeywords.add(kw.keyword);
+		}
+	}
+	if (clusterBy === "prefix" || clusterBy === "both") {
+		const unclustered = filtered.filter((kw) => !clusteredKeywords.has(kw.keyword));
+		const prefixMap = /* @__PURE__ */ new Map();
+		for (const kw of unclustered) {
+			const prefix = extractWordPrefix(kw.keyword);
+			if (prefix) {
+				const existing = prefixMap.get(prefix);
+				if (existing) existing.push(kw);
+				else prefixMap.set(prefix, [kw]);
+			}
+		}
+		for (const [prefix, kws] of prefixMap) if (kws.length >= minClusterSize) {
+			clusterMap.set(prefix, {
+				type: "prefix",
+				keywords: kws
+			});
+			kws.forEach((kw) => clusteredKeywords.add(kw.keyword));
+		}
+	}
+	const clusters = [];
+	for (const [name, data] of clusterMap) {
+		if (data.keywords.length < minClusterSize) continue;
+		const totalClicks = data.keywords.reduce((sum, k) => sum + num(k.clicks), 0);
+		const totalImpressions = data.keywords.reduce((sum, k) => sum + num(k.impressions), 0);
+		const avgPosition = data.keywords.reduce((sum, k) => sum + num(k.position), 0) / data.keywords.length;
+		clusters.push({
+			clusterName: name,
+			clusterType: data.type,
+			keywords: data.keywords,
+			totalClicks,
+			totalImpressions,
+			avgPosition,
+			keywordCount: data.keywords.length
+		});
+	}
+	clusters.sort((a, b) => b.totalClicks - a.totalClicks);
+	return {
+		clusters,
+		unclustered: filtered.filter((kw) => !clusteredKeywords.has(kw.keyword))
+	};
+}
+
 //#endregion
 //#region src/analysis/concentration.ts
 /**
@@ -270,12 +289,12 @@ function analyzeKeywordConcentration(keywords, options) {
 
 //#endregion
 //#region src/analysis/decay.ts
-const SORT_ORDER = {
+const SORT_ORDER$1 = {
 	lostClicks: "desc",
 	declinePercent: "desc",
 	currentClicks: "asc"
 };
-const sortResults$2 = createSorter((item, metric) => item[metric], "lostClicks");
+const sortResults$3 = createSorter((item, metric) => item[metric], "lostClicks");
 /**
 * Identifies "decaying" content - pages that have lost significant traffic.
 * Useful for finding old content that needs updating.
@@ -317,7 +336,7 @@ function analyzeDecay(input, options = {}) {
 			positionDrop: curr.position - prev.position
 		});
 	}
-	return sortResults$2(results, sortBy, SORT_ORDER[sortBy]);
+	return sortResults$3(results, sortBy, SORT_ORDER$1[sortBy]);
 }
 
 //#endregion
@@ -402,84 +421,97 @@ function analyzeMovers(input, options = {}) {
 }
 
 //#endregion
-//#region src/analysis/cannibalization.ts
-const sortResults$1 = createSorter((item, metric) => {
-	switch (metric) {
-		case "clicks": return item.totalClicks;
-		case "impressions": return item.totalImpressions;
-		case "positionSpread": return item.positionSpread;
-		case "pageCount": return item.pages.length;
-	}
-}, "clicks");
+//#region src/analysis/opportunity.ts
+const EXPECTED_CTR_BY_POSITION = {
+	1: .3,
+	2: .15,
+	3: .1,
+	4: .07,
+	5: .05,
+	6: .04,
+	7: .03,
+	8: .025,
+	9: .02,
+	10: .015
+};
+function getExpectedCtr(position) {
+	return EXPECTED_CTR_BY_POSITION[Math.round(Math.max(1, Math.min(position, 10)))] || .01;
+}
 /**
-* Detects keyword cannibalization - queries ranking for multiple pages.
-* Returns queries where multiple pages compete for the same search term.
-*
-* @param rows Query+page data rows
-* @param options Filtering and sorting options
+* Position score: higher for positions 4-20 (improvable range).
+* Peak opportunity at positions 8-15.
 */
-function analyzeCannibalization(rows, options = {}) {
-	const { minImpressions = 10, maxPositionSpread = 10, minPages = 2, sortBy = "clicks", sortOrder = "desc" } = options;
-	const queryMap = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		if (row.impressions < minImpressions) continue;
-		const pages = queryMap.get(row.query) || [];
-		pages.push({
-			page: row.page,
-			clicks: row.clicks,
-			impressions: row.impressions,
-			ctr: row.ctr,
-			position: row.position
-		});
-		queryMap.set(row.query, pages);
-	}
-	const results = [];
-	for (const [query$1, pages] of queryMap) {
-		if (pages.length < minPages) continue;
-		pages.sort((a, b) => b.clicks - a.clicks);
-		const positions = pages.map((p) => p.position);
-		const positionSpread = Math.max(...positions) - Math.min(...positions);
-		if (positionSpread > maxPositionSpread) continue;
-		results.push({
-			query: query$1,
-			pages,
-			totalClicks: pages.reduce((sum, p) => sum + p.clicks, 0),
-			totalImpressions: pages.reduce((sum, p) => sum + p.impressions, 0),
-			positionSpread
-		});
-	}
-	return sortResults$1(results, sortBy, sortOrder);
+function calculatePositionScore(position) {
+	if (position <= 3) return .2;
+	if (position > 50) return .1;
+	const distance = Math.abs(position - 11);
+	return Math.max(0, 1 - distance / 15);
 }
-
-//#endregion
-//#region src/analysis/zero-click.ts
-const sortResults = createSorter((item) => item.impressions, "impressions");
 /**
-* Identifies potential "Zero-Click" queries.
-* These are high-volume queries where you rank well but get few clicks,
-* often due to SERP features (Answer Boxes, Knowledge Panels, AI Overviews).
-*
-* @param rows Query+page data rows
-* @param options Filtering options
+* Impression score using log scale.
+* Higher impressions = more traffic potential.
 */
-function analyzeZeroClick(rows, options = {}) {
-	const { minImpressions = 1e3, maxCtr = .03, maxPosition = 10 } = options;
-	const queryMap = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		if (row.impressions < minImpressions) continue;
-		if (row.position > maxPosition) continue;
-		if (row.ctr > maxCtr) continue;
-		const existing = queryMap.get(row.query);
-		if (!existing || row.position < existing.position) queryMap.set(row.query, {
-			query: row.query,
-			page: row.page,
-			clicks: row.clicks,
-			impressions: row.impressions,
-			ctr: row.ctr,
-			position: row.position
+function calculateImpressionScore(impressions) {
+	if (impressions <= 0) return 0;
+	return Math.min(Math.log10(impressions) / 5, 1);
+}
+/**
+* CTR gap score: difference between actual and expected CTR.
+* Higher gap = more opportunity for improvement.
+*/
+function calculateCtrGapScore(actualCtr, position) {
+	const expectedCtr = getExpectedCtr(position);
+	if (actualCtr >= expectedCtr) return 0;
+	const gap = expectedCtr - actualCtr;
+	return Math.min(gap / expectedCtr, 1);
+}
+const SORT_ORDER = {
+	opportunityScore: "desc",
+	potentialClicks: "desc",
+	impressions: "desc",
+	position: "asc"
+};
+const sortResults$2 = createSorter((item, metric) => item[metric], "opportunityScore");
+/**
+* Scores keywords by optimization opportunity.
+* Composite score combining position, impressions, and CTR gap factors.
+*/
+function analyzeOpportunity(keywords, options = {}) {
+	const { minImpressions = 100, weights = {}, sortBy = "opportunityScore" } = options;
+	const positionWeight = weights.position ?? 1;
+	const impressionsWeight = weights.impressions ?? 1;
+	const ctrGapWeight = weights.ctrGap ?? 1;
+	const results = [];
+	for (const row of keywords) {
+		const impressions = num(row.impressions);
+		const position = num(row.position);
+		const ctr = num(row.ctr);
+		const clicks = num(row.clicks);
+		if (impressions < minImpressions) continue;
+		const positionScore = calculatePositionScore(position);
+		const impressionScore = calculateImpressionScore(impressions);
+		const ctrGapScore = calculateCtrGapScore(ctr, position);
+		const geometricMean = (positionScore ** positionWeight * impressionScore ** impressionsWeight * ctrGapScore ** ctrGapWeight) ** (1 / (positionWeight + impressionsWeight + ctrGapWeight));
+		const opportunityScore = Math.round(geometricMean * 100);
+		const targetCtr = getExpectedCtr(Math.min(3, position));
+		const potentialClicks = Math.round(impressions * targetCtr);
+		results.push({
+			keyword: row.keyword,
+			page: row.page ?? null,
+			clicks,
+			impressions,
+			ctr,
+			position,
+			opportunityScore,
+			potentialClicks,
+			factors: {
+				positionScore,
+				impressionScore,
+				ctrGapScore
+			}
 		});
 	}
-	return sortResults(Array.from(queryMap.values()), "impressions", "desc");
+	return sortResults$2(results, sortBy, SORT_ORDER[sortBy]);
 }
 
 //#endregion
@@ -549,100 +581,66 @@ function analyzeSeasonality(dates, options = {}) {
 }
 
 //#endregion
-//#region src/analysis/clustering.ts
-const INTENT_PREFIXES = [
-	"how to",
-	"what is",
-	"what are",
-	"why is",
-	"why do",
-	"where to",
-	"when to",
-	"best",
-	"top",
-	"vs",
-	"versus",
-	"compare",
-	"review",
-	"buy",
-	"cheap",
-	"free",
-	"near me"
-];
-function extractIntentPrefix(keyword) {
-	const lower = keyword.toLowerCase();
-	for (const prefix of INTENT_PREFIXES) if (lower.startsWith(prefix + " ") || lower.startsWith(prefix)) return prefix;
-	return null;
-}
-function extractWordPrefix(keyword, wordCount = 2) {
-	const words = keyword.toLowerCase().split(/\s+/).filter(Boolean);
-	if (words.length < wordCount + 1) return null;
-	return words.slice(0, wordCount).join(" ");
-}
+//#region src/analysis/striking-distance.ts
+const sortResults$1 = createSorter((item, metric) => item[metric], "potentialClicks");
+/**
+* Finds striking distance keywords - high impressions, low CTR, position 4-20.
+* These are "quick wins" that could gain significant traffic with small ranking improvements.
+*/
+function analyzeStrikingDistance(keywords, options = {}) {
+	const { minPosition = 4, maxPosition = 20, minImpressions = 100, maxCtr = .05, sortBy = "potentialClicks", sortOrder = "desc" } = options;
+	const results = [];
+	for (const row of keywords) {
+		const position = num(row.position);
+		const impressions = num(row.impressions);
+		const ctr = num(row.ctr);
+		const clicks = num(row.clicks);
+		if (position < minPosition || position > maxPosition) continue;
+		if (impressions < minImpressions) continue;
+		if (ctr > maxCtr) continue;
+		const potentialClicks = Math.round(impressions * .15);
+		results.push({
+			keyword: row.keyword,
+			page: row.page ?? null,
+			clicks,
+			impressions,
+			ctr,
+			position,
+			potentialClicks
+		});
+	}
+	return sortResults$1(results, sortBy, sortOrder);
+}
+
+//#endregion
+//#region src/analysis/zero-click.ts
+const sortResults = createSorter((item) => item.impressions, "impressions");
 /**
-* Clusters keywords by intent prefix or common word prefix.
-* Simple regex/prefix approach - no external NLP dependencies.
+* Identifies potential "Zero-Click" queries.
+* These are high-volume queries where you rank well but get few clicks,
+* often due to SERP features (Answer Boxes, Knowledge Panels, AI Overviews).
 *
-* @param keywords Array of keyword data
-* @param options Clustering options
+* @param rows Query+page data rows
+* @param options Filtering options
 */
-function analyzeClustering(keywords, options = {}) {
-	const { minClusterSize = 2, minImpressions = 10, clusterBy = "both" } = options;
-	const filtered = keywords.filter((k) => num(k.impressions) >= minImpressions);
-	const clusterMap = /* @__PURE__ */ new Map();
-	const clusteredKeywords = /* @__PURE__ */ new Set();
-	if (clusterBy === "intent" || clusterBy === "both") for (const kw of filtered) {
-		const intent = extractIntentPrefix(kw.keyword);
-		if (intent) {
-			const existing = clusterMap.get(intent);
-			if (existing) existing.keywords.push(kw);
-			else clusterMap.set(intent, {
-				type: "intent",
-				keywords: [kw]
-			});
-			clusteredKeywords.add(kw.keyword);
-		}
-	}
-	if (clusterBy === "prefix" || clusterBy === "both") {
-		const unclustered = filtered.filter((kw) => !clusteredKeywords.has(kw.keyword));
-		const prefixMap = /* @__PURE__ */ new Map();
-		for (const kw of unclustered) {
-			const prefix = extractWordPrefix(kw.keyword);
-			if (prefix) {
-				const existing = prefixMap.get(prefix);
-				if (existing) existing.push(kw);
-				else prefixMap.set(prefix, [kw]);
-			}
-		}
-		for (const [prefix, kws] of prefixMap) if (kws.length >= minClusterSize) {
-			clusterMap.set(prefix, {
-				type: "prefix",
-				keywords: kws
-			});
-			kws.forEach((kw) => clusteredKeywords.add(kw.keyword));
-		}
-	}
-	const clusters = [];
-	for (const [name, data] of clusterMap) {
-		if (data.keywords.length < minClusterSize) continue;
-		const totalClicks = data.keywords.reduce((sum, k) => sum + num(k.clicks), 0);
-		const totalImpressions = data.keywords.reduce((sum, k) => sum + num(k.impressions), 0);
-		const avgPosition = data.keywords.reduce((sum, k) => sum + num(k.position), 0) / data.keywords.length;
-		clusters.push({
-			clusterName: name,
-			clusterType: data.type,
-			keywords: data.keywords,
-			totalClicks,
-			totalImpressions,
-			avgPosition,
-			keywordCount: data.keywords.length
+function analyzeZeroClick(rows, options = {}) {
+	const { minImpressions = 1e3, maxCtr = .03, maxPosition = 10 } = options;
+	const queryMap = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		if (row.impressions < minImpressions) continue;
+		if (row.position > maxPosition) continue;
+		if (row.ctr > maxCtr) continue;
+		const existing = queryMap.get(row.query);
+		if (!existing || row.position < existing.position) queryMap.set(row.query, {
+			query: row.query,
+			page: row.page,
+			clicks: row.clicks,
+			impressions: row.impressions,
+			ctr: row.ctr,
+			position: row.position
 		});
 	}
-	clusters.sort((a, b) => b.totalClicks - a.totalClicks);
-	return {
-		clusters,
-		unclustered: filtered.filter((kw) => !clusteredKeywords.has(kw.keyword))
-	};
+	return sortResults(Array.from(queryMap.values()), "impressions", "desc");
 }
 
 //#endregion
@@ -721,52 +719,6 @@ async function batchInspectUrls(client, siteUrl, urls, options = {}) {
 	return results;
 }
 
-//#endregion
-//#region src/api/sites.ts
-/**
-* Fetches all sites the authenticated user has access to in Google Search Console.
-*/
-async function fetchSites(client) {
-	return client.sites.list().then((res) => res?.siteEntry || []);
-}
-/**
-* Fetches sitemaps for a site.
-*/
-async function fetchSitemaps(client, siteUrl) {
-	return client.sitemaps.list(siteUrl).then((res) => res.sitemap || []);
-}
-/**
-* Gets details for a specific sitemap.
-*/
-async function fetchSitemap(client, siteUrl, feedpath) {
-	return client.sitemaps.get(siteUrl, feedpath);
-}
-/**
-* Submits a sitemap to Google Search Console.
-*/
-async function submitSitemap(client, siteUrl, feedpath) {
-	return client.sitemaps.submit(siteUrl, feedpath);
-}
-/**
-* Deletes a sitemap from Google Search Console.
-*/
-async function deleteSitemap(client, siteUrl, feedpath) {
-	return client.sitemaps.delete(siteUrl, feedpath);
-}
-/**
-* Fetches all verified sites with their sitemaps from Google Search Console.
-*/
-async function fetchSitesWithSitemaps(client) {
-	const sites = (await client.sites.list().then((res) => res.siteEntry || [])).filter((s) => !!s.siteUrl && s.permissionLevel !== "siteUnverifiedUser");
-	return Promise.all(sites.map(async (site) => {
-		const sitemaps = site.permissionLevel === "siteOwner" ? await client.sitemaps.list(site.siteUrl).then((res) => res.sitemap || []) : [];
-		return {
-			...site,
-			sitemaps
-		};
-	}));
-}
-
 //#endregion
 //#region src/utils/dayjs.ts
 _dayjs.extend(utc);
@@ -774,6 +726,12 @@ _dayjs.extend(timezone);
 function dayjs(date$1) {
 	return _dayjs(date$1);
 }
+function currentPstDate() {
+	return dayjs().tz("America/Los_Angeles").hour(12).minute(0).second(0).format("YYYY-MM-DD");
+}
+function dayjsPst() {
+	return dayjs().tz("America/Los_Angeles").hour(12).minute(0).second(0);
+}
 
 //#endregion
 //#region src/utils/format.ts
@@ -798,59 +756,6 @@ function percentDifference(a, b) {
 	if (!b || !a) return 0;
 	return (a - b) / ((a + b) / 2) * 100;
 }
-/**
-* Resolves a period string or object into start/end dates for current and previous periods.
-* @param periodRange - Period string (e.g., '30d', '3mo', 'all') or Period object with start/end dates
-* @returns Resolved period ranges with timestamps and formatted dates for both current and previous periods
-*/
-function userPeriodRange(periodRange = "30d") {
-	let startPeriod;
-	let endPeriod;
-	let startPrevPeriod;
-	let endPrevPeriod;
-	if (typeof periodRange === "string") {
-		endPeriod = dayjs();
-		if (periodRange === "all") {
-			startPeriod = dayjs().subtract(100, "year");
-			startPrevPeriod = dayjs().subtract(200, "year");
-			endPrevPeriod = dayjs().subtract(100, "year").subtract(1, "day");
-		} else if (periodRange === "max") {
-			const maxDays = 480;
-			startPeriod = endPeriod.clone().subtract(maxDays, "day");
-			startPrevPeriod = endPeriod.clone().subtract(maxDays * 2, "day");
-			endPrevPeriod = endPeriod.clone().subtract(maxDays + 1, "day");
-		} else {
-			const periodDays = periodRange.includes("d") ? Number.parseInt(periodRange.replace("d", "")) : Number.parseInt(periodRange.replace("mo", "")) * 30;
-			startPeriod = endPeriod.clone().subtract(periodDays, "day");
-			startPrevPeriod = endPeriod.clone().subtract(periodDays * 2, "day");
-			endPrevPeriod = endPeriod.clone().subtract(periodDays + 1, "day");
-		}
-	} else {
-		startPeriod = dayjs(periodRange.start);
-		endPeriod = dayjs(periodRange.end);
-		const dayDiff = endPeriod.diff(startPeriod, "day");
-		startPrevPeriod = dayjs(periodRange.start).subtract(dayDiff, "day");
-		endPrevPeriod = dayjs(periodRange.end).subtract(dayDiff, "day");
-	}
-	return {
-		period: {
-			startTimestamp: startPeriod.valueOf(),
-			start: startPeriod.toDate(),
-			startDateTime: startPeriod.format("YYYY-MM-DD HH:mm:ss"),
-			startDate: startPeriod.format("YYYY-MM-DD"),
-			end: endPeriod.toDate(),
-			endDate: endPeriod.format("YYYY-MM-DD"),
-			endTimestamp: endPeriod.valueOf(),
-			endDateTime: endPeriod.format("YYYY-MM-DD HH:mm:ss")
-		},
-		prevPeriod: {
-			start: startPrevPeriod.toDate(),
-			startDate: startPrevPeriod.format("YYYY-MM-DD"),
-			end: endPrevPeriod.toDate(),
-			endDate: endPrevPeriod.format("YYYY-MM-DD")
-		}
-	};
-}
 
 //#endregion
 //#region src/api/search-analytics/query.ts
@@ -3209,6 +3114,52 @@ async function collectStream(gen) {
 	return all;
 }
 
+//#endregion
+//#region src/api/sites.ts
+/**
+* Fetches all sites the authenticated user has access to in Google Search Console.
+*/
+async function fetchSites(client) {
+	return client.sites.list().then((res) => res?.siteEntry || []);
+}
+/**
+* Fetches sitemaps for a site.
+*/
+async function fetchSitemaps(client, siteUrl) {
+	return client.sitemaps.list(siteUrl).then((res) => res.sitemap || []);
+}
+/**
+* Gets details for a specific sitemap.
+*/
+async function fetchSitemap(client, siteUrl, feedpath) {
+	return client.sitemaps.get(siteUrl, feedpath);
+}
+/**
+* Submits a sitemap to Google Search Console.
+*/
+async function submitSitemap(client, siteUrl, feedpath) {
+	return client.sitemaps.submit(siteUrl, feedpath);
+}
+/**
+* Deletes a sitemap from Google Search Console.
+*/
+async function deleteSitemap(client, siteUrl, feedpath) {
+	return client.sitemaps.delete(siteUrl, feedpath);
+}
+/**
+* Fetches all verified sites with their sitemaps from Google Search Console.
+*/
+async function fetchSitesWithSitemaps(client) {
+	const sites = (await client.sites.list().then((res) => res.siteEntry || [])).filter((s) => !!s.siteUrl && s.permissionLevel !== "siteUnverifiedUser");
+	return Promise.all(sites.map(async (site) => {
+		const sitemaps = site.permissionLevel === "siteOwner" ? await client.sitemaps.list(site.siteUrl).then((res) => res.sitemap || []) : [];
+		return {
+			...site,
+			sitemaps
+		};
+	}));
+}
+
 //#endregion
 //#region src/core/client.ts
 const GSC_API = "https://searchconsole.googleapis.com";
@@ -3645,6 +3596,15 @@ const country = createColumn("country");
 const searchAppearance = createColumn("searchAppearance");
 const date = createColumn("date");
 
+//#endregion
+//#region src/query/constants.ts
+const Device = {
+	MOBILE: "MOBILE",
+	DESKTOP: "DESKTOP",
+	TABLET: "TABLET"
+};
+const Country = Object.fromEntries(countries_default.map((c) => [c["alpha-3"], c["alpha-3"].toLowerCase()]));
+
 //#endregion
 //#region src/query/operators.ts
 function eq(column, value) {
@@ -3811,13 +3771,4 @@ function between(column, start, end) {
 }
 
 //#endregion
-//#region src/query/constants.ts
-const Device = {
-	MOBILE: "MOBILE",
-	DESKTOP: "DESKTOP",
-	TABLET: "TABLET"
-};
-const Country = Object.fromEntries(countries_default.map((c) => [c["alpha-3"], c["alpha-3"].toLowerCase()]));
-
-//#endregion
-export { Country, Device, GSC_QUOTAS, analyzeBrandSegmentation, analyzeCannibalization, analyzeClustering, analyzeConcentration, analyzeDecay, analyzeError, analyzeKeywordConcentration, analyzeMovers, analyzeOpportunity, analyzePageConcentration, analyzeSeasonality, analyzeStrikingDistance, analyzeZeroClick, and, batchInspectUrls, batchRequestIndexing, between, collectStream, contains, countries_default as countries, country, createAuth, createFetch, createQueryBody, createSorter, date, dayjs, deleteSitemap, device, eq, extractDateRange, fetchAnalyticsWithComparison, fetchCountries, fetchCountriesWithComparison, fetchDates, fetchDatesWithComparison, fetchDevices, fetchDevicesWithComparison, fetchKeyword, fetchKeywords, fetchKeywordsWithComparison, fetchPage, fetchPages, fetchPagesWithComparison, fetchSearchAppearance, fetchSearchAppearanceWithComparison, fetchSitemap, fetchSitemaps, fetchSites, fetchSitesWithSitemaps, fetchYoYComparison, formatDateGsc, formatErrorForCli, getErrorCode, getErrorMessage, getIndexingMetadata, getRetryAfter, googleSearchConsole, gsc, gt, gte, inArray, inspectUrl, isAuthError, isQuotaError, isRateLimitError, like, lt, lte, ne, not, notRegex, num, or, page, percentDifference, query, queryRecursive, queryRecursiveStream, regex, requestIndexing, searchAppearance, submitSitemap, userPeriodRange, withDataType, withFinalData, withFreshData, withPropertyAggregation, withSearchAppearance };
+export { Country, Device, GSC_QUOTAS, analyzeBrandSegmentation, analyzeCannibalization, analyzeClustering, analyzeConcentration, analyzeDecay, analyzeError, analyzeKeywordConcentration, analyzeMovers, analyzeOpportunity, analyzePageConcentration, analyzeSeasonality, analyzeStrikingDistance, analyzeZeroClick, and, batchInspectUrls, batchRequestIndexing, between, collectStream, contains, countries_default as countries, country, createAuth, createFetch, createQueryBody, createSorter, currentPstDate, date, dayjs, dayjsPst, deleteSitemap, device, eq, extractDateRange, fetchAnalyticsWithComparison, fetchCountries, fetchCountriesWithComparison, fetchDates, fetchDatesWithComparison, fetchDevices, fetchDevicesWithComparison, fetchKeyword, fetchKeywords, fetchKeywordsWithComparison, fetchPage, fetchPages, fetchPagesWithComparison, fetchSearchAppearance, fetchSearchAppearanceWithComparison, fetchSitemap, fetchSitemaps, fetchSites, fetchSitesWithSitemaps, fetchYoYComparison, formatDateGsc, formatErrorForCli, getErrorCode, getErrorMessage, getIndexingMetadata, getRetryAfter, googleSearchConsole, gsc, gt, gte, inArray, inspectUrl, isAuthError, isQuotaError, isRateLimitError, like, lt, lte, ne, not, notRegex, num, or, page, percentDifference, query, queryRecursive, queryRecursiveStream, regex, requestIndexing, searchAppearance, submitSitemap, withDataType, withFinalData, withFreshData, withPropertyAggregation, withSearchAppearance };