@megabudino/stack-utils 1.4.1 → 1.5.0

package/README.md

@@ -49,8 +49,7 @@ Proxy config:
 | --- | --- | --- | --- |
 | `originUrl` | `string` | required | Origin server URL |
 | `siteUrl` | `string` | required | Public site URL |
-| `sitemaps` | `string[]` | `[]` | SvelteKit sitemap URLs to inject into sitemap indexes |
-| `sitemapCacheSeconds` | `number` | `3600` | Cache max-age for sitemap responses |
+| `sitemap` | `SitemapConfig` | `{}` | Sitemap index injection and origin URL filtering |
 | `proxyAssets` | `boolean` | `false` | Rewrite origin asset URLs to relative paths |
 | `additionalOrigins` | `string[]` | `[]` | Additional absolute origins to rewrite like `originUrl` |
 | `domActions` | `DomAction[]` | `[]` | Declarative DOM transformations for proxied HTML |
@@ -61,7 +60,7 @@ What it does:
 - lets SvelteKit routes resolve normally when a route exists
 - proxies unmatched requests to the configured origin
 - rewrites redirects back to the public domain
-- rewrites HTML, applies optional DOM actions, and injects extra sitemap entries when configured
+- rewrites HTML, applies optional DOM actions, and rewrites sitemap XML when configured
 
 ### `images`
 

package/dist/proxy/handle.js

@@ -1,5 +1,5 @@
 import { applyDomActions } from './dom-actions.js';
-import { injectIntoSitemapIndex, rewriteHtml } from './rewrite.js';
+import { injectIntoSitemapIndex, normalizeSitemapPath, removeExcludedUrlsFromSitemap, rewriteHtml } from './rewrite.js';
 /**
  * Create a SvelteKit `Handle` hook that reverse-proxies requests to an origin.
  *
@@ -7,9 +7,13 @@ import { injectIntoSitemapIndex, rewriteHtml } from './rewrite.js';
  * everything else is forwarded to the origin.
  */
 export function createProxyHandle(config) {
+    assertNoDeprecatedSitemapConfig(config);
     const { originUrl, siteUrl } = config;
-    const sitemaps = config.sitemaps ?? [];
-    const sitemapCache = `public, max-age=${config.sitemapCacheSeconds ?? 3600}`;
+    const sitemap = config.sitemap ?? {};
+    const sitemapIndexPath = sitemap.indexPath ? normalizeSitemapPath(sitemap.indexPath) : undefined;
+    const sitemapIncludeFiles = sitemap.includeFiles ?? [];
+    const sitemapExcludePaths = sitemap.excludePaths ?? [];
+    const sitemapCache = `public, max-age=${sitemap.cacheSeconds ?? 3600}`;
     const proxyAssets = config.proxyAssets ?? false;
     const additionalOrigins = config.additionalOrigins ?? [];
     const maxRedirects = config.maxInternalRedirects ?? 5;
@@ -72,8 +76,14 @@ export function createProxyHandle(config) {
             if (contentType.includes('text/xml') || contentType.includes('application/xml')) {
                 let xml = await upstreamResponse.text();
                 xml = xml.replace(/<\?xml-stylesheet[^?]*\?>\s*/g, '');
-                if (sitemaps.length > 0 && xml.includes('</sitemapindex>')) {
-                    xml = injectIntoSitemapIndex(xml, siteUrl, sitemaps);
+                const isConfiguredSitemapIndex = sitemapIndexPath !== undefined && normalizeSitemapPath(pathname) === sitemapIndexPath;
+                if (isConfiguredSitemapIndex &&
+                    sitemapIncludeFiles.length > 0 &&
+                    xml.includes('</sitemapindex>')) {
+                    xml = injectIntoSitemapIndex(xml, siteUrl, sitemapIncludeFiles);
+                }
+                else if (sitemapExcludePaths.length > 0 && xml.includes('</urlset>')) {
+                    xml = removeExcludedUrlsFromSitemap(xml, sitemapExcludePaths);
                 }
                 cleanHeaders.set('cache-control', sitemapCache);
                 return new Response(xml, {
@@ -103,3 +113,11 @@ export function createProxyHandle(config) {
         }
     };
 }
+function assertNoDeprecatedSitemapConfig(config) {
+    if ('sitemaps' in config) {
+        throw new Error('`sitemaps` is deprecated and no longer supported. Use `sitemap.includeFiles` with `sitemap.indexPath` instead.');
+    }
+    if ('sitemapCacheSeconds' in config) {
+        throw new Error('`sitemapCacheSeconds` is deprecated and no longer supported. Use `sitemap.cacheSeconds` instead.');
+    }
+}

package/dist/proxy/index.d.ts

@@ -1,2 +1,2 @@
 export { createProxyHandle } from './handle.js';
-export type { DomAction, ProxyConfig } from './types.js';
+export type { DomAction, ProxyConfig, SitemapConfig } from './types.js';

package/dist/proxy/rewrite.d.ts

@@ -9,5 +9,9 @@
  * - When `proxyAssets` is false, absolute origin URLs are left as-is.
  */
 export declare function rewriteHtml(html: string, originUrl: string, siteUrl: string, proxyAssets?: boolean, additionalOrigins?: string[]): string;
-/** Inject SvelteKit sitemap references into a `<sitemapindex>`. */
-export declare function injectIntoSitemapIndex(xml: string, siteUrl: string, sitemaps: string[]): string;
+/** Normalize URL-like values to comparable sitemap pathnames. */
+export declare function normalizeSitemapPath(value: string): string;
+/** Inject local sitemap references into a configured `<sitemapindex>`. */
+export declare function injectIntoSitemapIndex(xml: string, siteUrl: string, includeFiles: string[]): string;
+/** Remove `<url>` entries whose `<loc>` pathname is listed in `excludePaths`. */
+export declare function removeExcludedUrlsFromSitemap(xml: string, excludePaths: string[]): string;

package/dist/proxy/rewrite.js

@@ -41,10 +41,44 @@ export function rewriteHtml(html, originUrl, siteUrl, proxyAssets = false, addit
     }
     return html;
 }
-/** Inject SvelteKit sitemap references into a `<sitemapindex>`. */
-export function injectIntoSitemapIndex(xml, siteUrl, sitemaps) {
-    const entries = sitemaps
+/** Normalize URL-like values to comparable sitemap pathnames. */
+export function normalizeSitemapPath(value) {
+    let pathname = value.trim();
+    try {
+        pathname = new URL(pathname, 'https://stack-utils.local').pathname;
+    }
+    catch {
+        // Fall back to the raw value below; invalid URL-like values should not crash rewriting.
+    }
+    if (!pathname.startsWith('/')) {
+        pathname = `/${pathname}`;
+    }
+    if (pathname === '/') {
+        return pathname;
+    }
+    return pathname.replace(/\/+$/g, '') || '/';
+}
+/** Inject local sitemap references into a configured `<sitemapindex>`. */
+export function injectIntoSitemapIndex(xml, siteUrl, includeFiles) {
+    if (includeFiles.length === 0) {
+        return xml;
+    }
+    const entries = includeFiles
         .map((url) => `\t<sitemap>\n\t\t<loc>${siteUrl}${url}</loc>\n\t</sitemap>`)
         .join('\n');
     return xml.replace('</sitemapindex>', `${entries}\n</sitemapindex>`);
 }
+/** Remove `<url>` entries whose `<loc>` pathname is listed in `excludePaths`. */
+export function removeExcludedUrlsFromSitemap(xml, excludePaths) {
+    if (excludePaths.length === 0) {
+        return xml;
+    }
+    const excluded = new Set(excludePaths.map(normalizeSitemapPath));
+    return xml.replace(/<url\b[\s\S]*?<\/url>/g, (entry) => {
+        const loc = entry.match(/<loc\b[^>]*>\s*([\s\S]*?)\s*<\/loc>/i)?.[1];
+        if (!loc) {
+            return entry;
+        }
+        return excluded.has(normalizeSitemapPath(loc)) ? '' : entry;
+    });
+}

package/dist/proxy/types.d.ts

@@ -34,22 +34,44 @@ export interface DomAction {
      */
     remove?: boolean;
 }
-/** Configuration for the reverse proxy. */
-export interface ProxyConfig {
-    /** The origin URL (not publicly exposed). */
-    originUrl: string;
-    /** The public site URL (used in sitemaps and link rewriting). */
-    siteUrl: string;
+type DeprecatedProxyOption<Message extends string> = {
+    readonly __deprecatedProxyOption: Message;
+};
+/** Sitemap rewriting configuration for proxied XML responses. */
+export interface SitemapConfig {
+    /**
+     * Origin sitemap index path that can receive `includeFiles`.
+     * Example: `/sitemap_index.xml`.
+     */
+    indexPath?: string;
     /**
-     * SvelteKit sitemap URLs to inject into the origin's sitemap index.
-     * Defaults to `[]`.
+     * Local sitemap files to add to the configured sitemap index.
+     * Example: [`/sveltekit-sitemap.xml`].
      */
-    sitemaps?: string[];
+    includeFiles?: string[];
+    /**
+     * URL paths to remove from origin `<urlset>` sitemap responses.
+     * Matching compares normalized pathnames only.
+     */
+    excludePaths?: string[];
     /**
      * Cache-Control max-age (in seconds) for sitemap responses.
      * Defaults to 3600 (1 hour).
      */
-    sitemapCacheSeconds?: number;
+    cacheSeconds?: number;
+}
+/** Configuration for the reverse proxy. */
+export interface ProxyConfig {
+    /** The origin URL (not publicly exposed). */
+    originUrl: string;
+    /** The public site URL (used in sitemaps and link rewriting). */
+    siteUrl: string;
+    /** Explicit sitemap rewriting configuration for proxied XML responses. */
+    sitemap?: SitemapConfig;
+    /** @deprecated Use `sitemap.includeFiles` with `sitemap.indexPath` instead. */
+    sitemaps?: DeprecatedProxyOption<'`sitemaps` is deprecated. Use `sitemap.includeFiles` with `sitemap.indexPath` instead.'>;
+    /** @deprecated Use `sitemap.cacheSeconds` instead. */
+    sitemapCacheSeconds?: DeprecatedProxyOption<'`sitemapCacheSeconds` is deprecated. Use `sitemap.cacheSeconds` instead.'>;
     /**
      * If true, absolute origin URLs in HTML are rewritten to relative paths
      * so assets are served through the SvelteKit proxy and the origin is never exposed.
@@ -79,3 +101,4 @@ export interface ProxyConfig {
      */
     domActions?: DomAction[];
 }
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@megabudino/stack-utils",
-	"version": "1.4.1",
+	"version": "1.5.0",
 	"description": "Reusable utilities for a SvelteKit stack, including a reverse proxy and static image pipeline",
 	"type": "module",
 	"exports": {