@uptrademedia/site-kit 1.0.1 → 1.0.4

package/dist/routing-CgmRi9tD.d.mts

@@ -0,0 +1,105 @@
+import { l as GetRedirectOptions, R as RedirectResult, p as GetRobotsOptions, o as RobotsDirective, r as GetSitemapEntriesOptions, q as SitemapEntry } from './types-BmzutFwy.mjs';
+
+/**
+ * Get redirect for a path if one exists
+ *
+ * Use in Next.js middleware to handle managed redirects
+ *
+ * @example
+ * ```tsx
+ * // middleware.ts
+ * import { getRedirect } from '@uptrade/seo'
+ *
+ * export async function middleware(request) {
+ *   const redirect = await getRedirect({
+ *     projectId: process.env.UPTRADE_PROJECT_ID!,
+ *     path: request.nextUrl.pathname
+ *   })
+ *
+ *   if (redirect) {
+ *     return NextResponse.redirect(redirect.destination, redirect.statusCode)
+ *   }
+ * }
+ * ```
+ */
+declare function getRedirect(options: GetRedirectOptions): Promise<RedirectResult | null>;
+/**
+ * Get robots directive for a page
+ *
+ * @example
+ * ```tsx
+ * const robots = await getRobotsDirective({
+ *   projectId: process.env.UPTRADE_PROJECT_ID!,
+ *   path: '/private-page'
+ * })
+ *
+ * if (!robots.index) {
+ *   // Page should not be indexed
+ * }
+ * ```
+ */
+declare function getRobotsDirective(options: GetRobotsOptions): Promise<RobotsDirective>;
+/**
+ * Get sitemap entries for a project
+ *
+ * Use in sitemap.ts to generate dynamic sitemap
+ *
+ * @example
+ * ```tsx
+ * // app/sitemap.ts
+ * import { generateSitemap } from '@uptrade/seo'
+ *
+ * export default async function sitemap() {
+ *   return generateSitemap({
+ *     projectId: process.env.UPTRADE_PROJECT_ID!,
+ *     baseUrl: 'https://example.com',
+ *     publishedOnly: true
+ *   })
+ * }
+ * ```
+ */
+declare function generateSitemap(options: GetSitemapEntriesOptions): Promise<SitemapEntry[]>;
+/**
+ * Register local sitemap entries with Uptrade Portal
+ *
+ * Call this at build time to sync your local routes to seo_pages.
+ * This ensures analytics only tracks real pages.
+ *
+ * @example
+ * ```ts
+ * // scripts/register-sitemap.ts
+ * import { registerLocalSitemap } from '@uptrade/seo'
+ *
+ * // Option 1: Provide entries directly
+ * await registerLocalSitemap({
+ *   entries: [
+ *     { path: '/', title: 'Home', priority: 1.0 },
+ *     { path: '/about', title: 'About Us', priority: 0.8 },
+ *   ]
+ * })
+ *
+ * // Option 2: Auto-discover from Next.js app directory
+ * await registerLocalSitemap({ autoDiscover: true })
+ * ```
+ */
+declare function registerLocalSitemap(options: {
+    entries?: Array<{
+        path: string;
+        title?: string;
+        priority?: number;
+        changefreq?: 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
+    }>;
+    autoDiscover?: boolean;
+}): Promise<{
+    success: boolean;
+    created: number;
+    updated: number;
+}>;
+/**
+ * Check if a path should be indexed
+ *
+ * Quick helper to check indexability without full directive parsing
+ */
+declare function isIndexable(projectId: string, path: string): Promise<boolean>;
+
+export { getRedirect as a, getRobotsDirective as b, generateSitemap as g, isIndexable as i, registerLocalSitemap as r };

package/dist/{scanner-MF7P3CDE 2.mjs → scanner-AZV5I6US.mjs}

@@ -13976,7 +13976,8 @@ async function scanCodebase(rootDir) {
   const results = {
     forms: [],
     metadata: [],
-    widgets: []
+    widgets: [],
+    sitemaps: []
   };
   const files = await findSourceFiles(rootDir);
   for (const file of files) {
@@ -13993,10 +13994,14 @@ async function scanCodebase(rootDir) {
       results.metadata.push(...metadata);
       const widgets = scanForWidgets(ast, content, relPath);
       results.widgets.push(...widgets);
+      const sitemaps = scanForSitemaps(content, relPath);
+      results.sitemaps.push(...sitemaps);
     } catch (error) {
       continue;
     }
   }
+  const sitemapFiles = await scanForSitemapFiles(rootDir);
+  results.sitemaps.push(...sitemapFiles);
   return results;
 }
 async function findSourceFiles(dir, files = []) {
@@ -14380,7 +14385,121 @@ function scanForWidgets(ast, content, filePath) {
   }
   return widgets;
 }
+function scanForSitemaps(content, filePath) {
+  const sitemaps = [];
+  if (content.includes("next-sitemap") && !content.includes("@uptrade/site-kit")) {
+    sitemaps.push({
+      filePath,
+      type: "next-sitemap",
+      generator: "next-sitemap",
+      startLine: findLineNumber(content, "next-sitemap"),
+      endLine: findLineNumber(content, "next-sitemap") + 10
+    });
+  }
+  if ((filePath.endsWith("sitemap.ts") || filePath.endsWith("sitemap.js")) && !content.includes("@uptrade/site-kit")) {
+    const isNextPattern = content.includes("MetadataRoute.Sitemap") || content.includes("export default") || content.includes("export async function");
+    if (isNextPattern) {
+      sitemaps.push({
+        filePath,
+        type: "custom-sitemap",
+        generator: "custom",
+        startLine: 1,
+        endLine: content.split("\n").length,
+        details: {
+          hasAsyncFunction: content.includes("async"),
+          hasDatabaseQuery: content.includes("supabase") || content.includes("prisma") || content.includes("sql")
+        }
+      });
+    }
+  }
+  if (content.includes("@uptrade/site-kit/sitemap") || content.includes("createSitemap")) {
+    sitemaps.push({
+      filePath,
+      type: "custom-sitemap",
+      generator: "site-kit",
+      startLine: findLineNumber(content, "createSitemap"),
+      endLine: findLineNumber(content, "createSitemap") + 10
+    });
+  }
+  return sitemaps;
+}
+function findLineNumber(content, search) {
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes(search)) {
+      return i + 1;
+    }
+  }
+  return 1;
+}
+async function scanForSitemapFiles(rootDir) {
+  const sitemaps = [];
+  const configPaths = [
+    "next-sitemap.config.js",
+    "next-sitemap.config.mjs",
+    "next-sitemap.config.ts"
+  ];
+  for (const configPath of configPaths) {
+    const fullPath = path.join(rootDir, configPath);
+    try {
+      await fs.access(fullPath);
+      const content = await fs.readFile(fullPath, "utf-8");
+      sitemaps.push({
+        filePath: configPath,
+        type: "next-sitemap-config",
+        generator: "next-sitemap",
+        startLine: 1,
+        endLine: content.split("\n").length,
+        details: {
+          hasRobotsTxt: content.includes("generateRobotsTxt"),
+          excludePaths: extractExcludePaths(content)
+        }
+      });
+    } catch {
+    }
+  }
+  const staticSitemapPath = path.join(rootDir, "public", "sitemap.xml");
+  try {
+    await fs.access(staticSitemapPath);
+    const content = await fs.readFile(staticSitemapPath, "utf-8");
+    const urlCount = (content.match(/<url>/g) || []).length;
+    sitemaps.push({
+      filePath: "public/sitemap.xml",
+      type: "static-xml",
+      generator: "static",
+      startLine: 1,
+      endLine: content.split("\n").length,
+      details: {
+        urlCount,
+        isIndex: content.includes("<sitemapindex")
+      }
+    });
+  } catch {
+  }
+  const generatedPaths = [
+    ".next/server/app/sitemap.xml",
+    "out/sitemap.xml"
+  ];
+  for (const genPath of generatedPaths) {
+    const fullPath = path.join(rootDir, genPath);
+    try {
+      await fs.access(fullPath);
+    } catch {
+    }
+  }
+  return sitemaps;
+}
+function extractExcludePaths(content) {
+  const excludeMatch = content.match(/exclude:\s*\[([\s\S]*?)\]/);
+  if (!excludeMatch) return [];
+  const paths = [];
+  const matches = excludeMatch[1].matchAll(/['"]([^'"]+)['"]/g);
+  for (const match of matches) {
+    paths.push(match[1]);
+  }
+  return paths;
+}
 
-export { scanCodebase, scanForForms, scanForMetadata, scanForWidgets };
-//# sourceMappingURL=scanner-MF7P3CDE.mjs.map
-//# sourceMappingURL=scanner-MF7P3CDE.mjs.map
+export { scanCodebase, scanForForms, scanForMetadata, scanForSitemapFiles, scanForSitemaps, scanForWidgets };
+//# sourceMappingURL=scanner-AZV5I6US.mjs.map
+//# sourceMappingURL=scanner-AZV5I6US.mjs.map