@sitecore-content-sdk/content 2.2.1 → 2.2.2-canary.20260727010537

package/dist/cjs/site/index.js

@@ -1,4 +1,18 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SiteResolver = exports.getHostnameFromHostHeader = exports.SITE_KEY = exports.SITE_PREFIX = exports.normalizeSiteRewrite = exports.getSiteRewriteData = exports.getSiteRewrite = exports.SitePathService = exports.SiteInfoService = exports.ErrorPagesService = exports.SitemapXmlService = exports.RedirectsService = exports.REDIRECT_TYPE_SERVER_TRANSFER = exports.REDIRECT_TYPE_302 = exports.REDIRECT_TYPE_301 = exports.RobotsService = void 0;
 var robots_service_1 = require("./robots-service");
@@ -23,5 +37,6 @@ Object.defineProperty(exports, "normalizeSiteRewrite", { enumerable: true, get:
 Object.defineProperty(exports, "SITE_PREFIX", { enumerable: true, get: function () { return utils_1.SITE_PREFIX; } });
 Object.defineProperty(exports, "SITE_KEY", { enumerable: true, get: function () { return utils_1.SITE_KEY; } });
 Object.defineProperty(exports, "getHostnameFromHostHeader", { enumerable: true, get: function () { return utils_1.getHostnameFromHostHeader; } });
+__exportStar(require("./redirect-utils"), exports);
 var site_resolver_1 = require("./site-resolver");
 Object.defineProperty(exports, "SiteResolver", { enumerable: true, get: function () { return site_resolver_1.SiteResolver; } });

package/dist/cjs/site/redirect-utils.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processRelativeUrlTarget = exports.processAbsoluteUrlTarget = exports.resolveRedirectTarget = exports.isAbsoluteTarget = exports.safeCompileRedirectPattern = exports.matchRedirectItemRedirect = exports.matchFromRedirectMapRedirect = exports.breakDownPath = void 0;
+const tools_1 = require("@sitecore-content-sdk/core/tools");
+const REGEXP_CONTEXT_SITE_LANG = /\$siteLang/i;
+const REGEXP_ABSOLUTE_URL = /^(?:[a-z]+:)?\/\//i;
+/**
+ * Splits a URL path into its (optional) leading locale segment, the remaining
+ * locale-less path, and the query string. Locales are compared case-insensitively.
+ * A leading slash is always ensured on `nonLocalePath`; any trailing slash is preserved
+ * so slash-sensitive regex redirect rules can still be matched downstream.
+ * @param {string[]} configuredLocales configured site locales
+ * @param {string} urlPath path (optionally including a `?query`)
+ * @returns {ProcessedPath} broken-down path parts
+ * @internal
+ */
+const breakDownPath = (configuredLocales, urlPath) => {
+    const urlArray = urlPath.split('?');
+    const urlQs = urlArray[1];
+    // collapse duplicate slashes so degenerate inputs (`//`, `///`) reduce to `/`,
+    // while a single meaningful trailing slash is preserved
+    const nonQsPath = urlArray[0].replace(/\/{2,}/g, '/');
+    const pathArray = nonQsPath.startsWith('/')
+        ? nonQsPath.slice(1).split('/')
+        : nonQsPath.split('/');
+    const [maybeLocale, maybeNonLocale] = [pathArray[0], pathArray.slice(1).join('/')];
+    const lowerCaseMaybeLocale = maybeLocale.toLowerCase();
+    // locales must be compared case insensitively, variations are abundant and typos can be there
+    return configuredLocales.find((configuredLocale) => configuredLocale.toLowerCase() === lowerCaseMaybeLocale)
+        ? {
+            nonLocalePath: `/${maybeNonLocale}`,
+            queryString: urlQs,
+            locale: maybeLocale,
+        }
+        : {
+            nonLocalePath: nonQsPath.startsWith('/') ? nonQsPath : `/${nonQsPath}`,
+            queryString: urlQs,
+        };
+};
+exports.breakDownPath = breakDownPath;
+/**
+ * Matches redirect-map rules (rules without a `locale` field) against the incoming request.
+ * The incoming path is provided pre-split as {@link ProcessedPath}, so matching starts from the
+ * guaranteed locale-less `nonLocalePath` and rebuilds the locale-prefixed variant from it. This
+ * avoids the ambiguity of a raw pathname that may or may not already carry a locale segment.
+ * @param {RedirectResult[]} redirects All redirects from the service (locale-scoped entries are filtered out).
+ * @param {string} requestLocale locale of the current request
+ * @param {ProcessedPath} incomingPathData broken-down incoming path (locale-less path and query)
+ * @returns {RedirectResult | undefined} First matching redirect or undefined.
+ * @internal
+ */
+const matchFromRedirectMapRedirect = (redirects, requestLocale, incomingPathData) => {
+    const redirectMapRedirects = redirects.filter((redirect) => !redirect.locale);
+    // start from the locale-less path and rebuild the locale-prefixed variant from it
+    // (keep root as `/` so anchored `^/...` patterns still match). Trailing slashes are preserved.
+    const nonLocalePath = incomingPathData.nonLocalePath.toLowerCase() || '/';
+    const localePath = `/${requestLocale.toLowerCase()}${nonLocalePath}`;
+    const incomingQS = incomingPathData.queryString || '';
+    // regex rules are matched against the raw candidates (trailing slash preserved so slash-sensitive
+    // patterns still match); static rules ignore trailing slashes, so they use trimmed candidates
+    const pathCandidates = [nonLocalePath, localePath];
+    const staticCandidates = pathCandidates.map((path) => path.replace(/\/+$/g, '') || '/');
+    return redirectMapRedirects.find((redirect) => {
+        // process static URL (non-regex) rules
+        if ((0, tools_1.isRegexOrUrl)(redirect.pattern) === 'url') {
+            const [rawPatternPath, patternQS] = (redirect.pattern.endsWith('/') ? redirect.pattern.slice(0, -1) : redirect.pattern).split('?');
+            // candidates are already lowercased; lowercase the pattern path to keep locale (and route)
+            // comparison case-insensitive
+            const patternPath = rawPatternPath.toLowerCase();
+            return (staticCandidates.includes(patternPath) &&
+                (!patternQS ||
+                    (0, tools_1.areURLSearchParamsEqual)(new URLSearchParams(patternQS), new URLSearchParams(incomingQS))));
+        }
+        // process regex rules
+        const regex = (0, exports.safeCompileRedirectPattern)(redirect.pattern);
+        if (!regex) {
+            return false;
+        }
+        const testRegex = (value) => {
+            regex.lastIndex = 0;
+            return regex.test(value);
+        };
+        // remove duplicates
+        const regexCandidates = [...pathCandidates, ...staticCandidates].filter((candidate, index, array) => array.indexOf(candidate) === index);
+        const matchedPath = regexCandidates.find((candidate) => testRegex(candidate));
+        const matchedPathWithQuery = incomingQS
+            ? regexCandidates.find((candidate) => testRegex(`${candidate}?${incomingQS}`))
+            : undefined;
+        // Save the matched path/query (if found) into the redirect object
+        redirect.matchedQueryString = matchedPathWithQuery ? `?${incomingQS}` : '';
+        redirect.matchedPath = matchedPath || matchedPathWithQuery || '';
+        return !!(matchedPath || matchedPathWithQuery);
+    });
+};
+exports.matchFromRedirectMapRedirect = matchFromRedirectMapRedirect;
+/**
+ * Processes redirect rules from redirect items (language-versioned)
+ * @param {RedirectResult[]} redirects redirect entries from Edge
+ * @param {string} locale current request locale
+ * @param {string} nonLocalePath current request path with locale prefix stripped
+ * @returns {RedirectResult | undefined} matched redirect item redirect result or undefined
+ * @internal
+ */
+const matchRedirectItemRedirect = (redirects, locale, nonLocalePath) => {
+    return redirects.find((redirect) => {
+        const patternPath = redirect.pattern.replace(/\/+$/g, '').toLowerCase();
+        // locale rules are easy and nice
+        return redirect.locale === locale && patternPath === nonLocalePath;
+    });
+};
+exports.matchRedirectItemRedirect = matchRedirectItemRedirect;
+/**
+ * Compiles a redirect pattern to RegExp; returns null if Sitecore produced a malformed rule
+ * so one bad entry does not fail the entire redirect chain.
+ * Supports both JS literal form (`/pattern/i`) and plain regex source (`^/path$`).
+ * @param {string} pattern redirect pattern from redirect map
+ * @returns {RegExp | null} normalized regex instance, or null when invalid
+ * @internal
+ */
+const safeCompileRedirectPattern = (pattern) => {
+    try {
+        const normalizedPattern = (0, tools_1.escapeNonSpecialQuestionMarks)(pattern);
+        const literalMatch = normalizedPattern.match(/^\/(.+)\/([a-z]*)$/i);
+        if (literalMatch) {
+            const [, source, flags] = literalMatch;
+            const safeFlags = flags || 'i';
+            return new RegExp(source, safeFlags);
+        }
+        return new RegExp(normalizedPattern, 'i');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`[RedirectsProxy] Invalid redirect regex; skipping rule. pattern=${pattern} (${message})`);
+        return null;
+    }
+};
+exports.safeCompileRedirectPattern = safeCompileRedirectPattern;
+/**
+ * Detects absolute (external or protocol-relative) target URLs.
+ * @param {string} target redirect target
+ * @returns {boolean} true when the target is an absolute URL
+ * @internal
+ */
+const isAbsoluteTarget = (target) => REGEXP_ABSOLUTE_URL.test(target);
+exports.isAbsoluteTarget = isAbsoluteTarget;
+/**
+ * Resolves the redirect target string: replaces the `$siteLang` token and applies
+ * regex capture-group substitutions (`$1`, `$2`, …) when the rule pattern is a regex.
+ * @param {RedirectResult} existsRedirect matched redirect
+ * @param {string} siteLanguage site language used for the `$siteLang` token
+ * @param {string} requestPath incoming request path, used when the rule stored no matched path
+ * @returns {string} resolved target
+ * @internal
+ */
+const resolveRedirectTarget = (existsRedirect, siteLanguage, requestPath) => {
+    let target = existsRedirect.target.replace(REGEXP_CONTEXT_SITE_LANG, siteLanguage);
+    // Apply regex replacements to the target URL if the pattern is a regex
+    if ((0, tools_1.isRegexOrUrl)(existsRedirect.pattern) === 'regex') {
+        const sourcePath = existsRedirect.matchedPath || requestPath;
+        const pathForCaptureMatch = sourcePath.replace(/\/+$/g, '') || '/';
+        const redirectRegex = (0, exports.safeCompileRedirectPattern)(existsRedirect.pattern);
+        const matched = redirectRegex ? pathForCaptureMatch.match(redirectRegex) : null;
+        if (matched) {
+            target = target.replace(/\$(\d+)/g, (_, index) => matched[parseInt(index, 10)] || '');
+        }
+    }
+    return target;
+};
+exports.resolveRedirectTarget = resolveRedirectTarget;
+/**
+ * Resolves the absolute redirect target (external redirects), optionally preseriving query string
+ * @param {ProcessedPath} incomingPathData non locale path, locale prefix and query string (if present)
+ * @param {RedirectResult} existsRedirect matched redirect to resolve final result from
+ * @returns {string} URL to redirect to
+ * @internal
+ */
+const processAbsoluteUrlTarget = (incomingPathData, existsRedirect) => {
+    if (!incomingPathData.queryString || !existsRedirect.isQueryStringPreserved) {
+        return existsRedirect.target;
+    }
+    const [targetMainUrl, targetQS] = existsRedirect.target.split('?');
+    const mergedQueryString = (0, tools_1.mergeURLSearchParams)(new URLSearchParams(incomingPathData.queryString), new URLSearchParams(targetQS || ''));
+    return `${targetMainUrl}?${mergedQueryString}`;
+};
+exports.processAbsoluteUrlTarget = processAbsoluteUrlTarget;
+/**
+ * Resolves the locale-less path and target locale for a relative redirect URL.
+ * The framework layer is responsible for placing the locale (pathname vs. locale property).
+ * @param {ProcessedPath} incomingPathData broken-down incoming request path
+ * @param {RedirectResult} existsRedirect matched redirect
+ * @param {string[]} configuredLocales configured site locales
+ * @param {string} reqLocale current request locale (used when `isLanguagePreserved`)
+ * @returns {{ targetLocale: string; targetPath: string }} resolved locale and locale-less path (with query)
+ * @internal
+ */
+const processRelativeUrlTarget = (incomingPathData, existsRedirect, configuredLocales, reqLocale) => {
+    const { locale, nonLocalePath, queryString } = (0, exports.breakDownPath)(configuredLocales, existsRedirect.target);
+    // preserve the request locale when the target has no locale prefix and the rule opts in
+    const targetLocale = locale || (existsRedirect.isLanguagePreserved ? reqLocale : '');
+    const targetQS = incomingPathData.queryString && existsRedirect.isQueryStringPreserved
+        ? (0, tools_1.mergeURLSearchParams)(new URLSearchParams(incomingPathData.queryString), new URLSearchParams(queryString || ''))
+        : queryString || '';
+    return {
+        targetLocale,
+        targetPath: `${nonLocalePath}${targetQS ? '?' + targetQS : ''}`,
+    };
+};
+exports.processRelativeUrlTarget = processRelativeUrlTarget;

package/dist/esm/site/index.js

@@ -5,4 +5,5 @@ export { ErrorPagesService } from './error-pages-service';
 export { SiteInfoService } from './siteinfo-service';
 export { SitePathService } from './sitepath-service';
 export { getSiteRewrite, getSiteRewriteData, normalizeSiteRewrite, SITE_PREFIX, SITE_KEY, getHostnameFromHostHeader, } from './utils';
+export * from './redirect-utils';
 export { SiteResolver } from './site-resolver';

package/dist/esm/site/redirect-utils.js

@@ -0,0 +1,197 @@
+import { areURLSearchParamsEqual, escapeNonSpecialQuestionMarks, isRegexOrUrl, mergeURLSearchParams, } from '@sitecore-content-sdk/core/tools';
+const REGEXP_CONTEXT_SITE_LANG = /\$siteLang/i;
+const REGEXP_ABSOLUTE_URL = /^(?:[a-z]+:)?\/\//i;
+/**
+ * Splits a URL path into its (optional) leading locale segment, the remaining
+ * locale-less path, and the query string. Locales are compared case-insensitively.
+ * A leading slash is always ensured on `nonLocalePath`; any trailing slash is preserved
+ * so slash-sensitive regex redirect rules can still be matched downstream.
+ * @param {string[]} configuredLocales configured site locales
+ * @param {string} urlPath path (optionally including a `?query`)
+ * @returns {ProcessedPath} broken-down path parts
+ * @internal
+ */
+export const breakDownPath = (configuredLocales, urlPath) => {
+    const urlArray = urlPath.split('?');
+    const urlQs = urlArray[1];
+    // collapse duplicate slashes so degenerate inputs (`//`, `///`) reduce to `/`,
+    // while a single meaningful trailing slash is preserved
+    const nonQsPath = urlArray[0].replace(/\/{2,}/g, '/');
+    const pathArray = nonQsPath.startsWith('/')
+        ? nonQsPath.slice(1).split('/')
+        : nonQsPath.split('/');
+    const [maybeLocale, maybeNonLocale] = [pathArray[0], pathArray.slice(1).join('/')];
+    const lowerCaseMaybeLocale = maybeLocale.toLowerCase();
+    // locales must be compared case insensitively, variations are abundant and typos can be there
+    return configuredLocales.find((configuredLocale) => configuredLocale.toLowerCase() === lowerCaseMaybeLocale)
+        ? {
+            nonLocalePath: `/${maybeNonLocale}`,
+            queryString: urlQs,
+            locale: maybeLocale,
+        }
+        : {
+            nonLocalePath: nonQsPath.startsWith('/') ? nonQsPath : `/${nonQsPath}`,
+            queryString: urlQs,
+        };
+};
+/**
+ * Matches redirect-map rules (rules without a `locale` field) against the incoming request.
+ * The incoming path is provided pre-split as {@link ProcessedPath}, so matching starts from the
+ * guaranteed locale-less `nonLocalePath` and rebuilds the locale-prefixed variant from it. This
+ * avoids the ambiguity of a raw pathname that may or may not already carry a locale segment.
+ * @param {RedirectResult[]} redirects All redirects from the service (locale-scoped entries are filtered out).
+ * @param {string} requestLocale locale of the current request
+ * @param {ProcessedPath} incomingPathData broken-down incoming path (locale-less path and query)
+ * @returns {RedirectResult | undefined} First matching redirect or undefined.
+ * @internal
+ */
+export const matchFromRedirectMapRedirect = (redirects, requestLocale, incomingPathData) => {
+    const redirectMapRedirects = redirects.filter((redirect) => !redirect.locale);
+    // start from the locale-less path and rebuild the locale-prefixed variant from it
+    // (keep root as `/` so anchored `^/...` patterns still match). Trailing slashes are preserved.
+    const nonLocalePath = incomingPathData.nonLocalePath.toLowerCase() || '/';
+    const localePath = `/${requestLocale.toLowerCase()}${nonLocalePath}`;
+    const incomingQS = incomingPathData.queryString || '';
+    // regex rules are matched against the raw candidates (trailing slash preserved so slash-sensitive
+    // patterns still match); static rules ignore trailing slashes, so they use trimmed candidates
+    const pathCandidates = [nonLocalePath, localePath];
+    const staticCandidates = pathCandidates.map((path) => path.replace(/\/+$/g, '') || '/');
+    return redirectMapRedirects.find((redirect) => {
+        // process static URL (non-regex) rules
+        if (isRegexOrUrl(redirect.pattern) === 'url') {
+            const [rawPatternPath, patternQS] = (redirect.pattern.endsWith('/') ? redirect.pattern.slice(0, -1) : redirect.pattern).split('?');
+            // candidates are already lowercased; lowercase the pattern path to keep locale (and route)
+            // comparison case-insensitive
+            const patternPath = rawPatternPath.toLowerCase();
+            return (staticCandidates.includes(patternPath) &&
+                (!patternQS ||
+                    areURLSearchParamsEqual(new URLSearchParams(patternQS), new URLSearchParams(incomingQS))));
+        }
+        // process regex rules
+        const regex = safeCompileRedirectPattern(redirect.pattern);
+        if (!regex) {
+            return false;
+        }
+        const testRegex = (value) => {
+            regex.lastIndex = 0;
+            return regex.test(value);
+        };
+        // remove duplicates
+        const regexCandidates = [...pathCandidates, ...staticCandidates].filter((candidate, index, array) => array.indexOf(candidate) === index);
+        const matchedPath = regexCandidates.find((candidate) => testRegex(candidate));
+        const matchedPathWithQuery = incomingQS
+            ? regexCandidates.find((candidate) => testRegex(`${candidate}?${incomingQS}`))
+            : undefined;
+        // Save the matched path/query (if found) into the redirect object
+        redirect.matchedQueryString = matchedPathWithQuery ? `?${incomingQS}` : '';
+        redirect.matchedPath = matchedPath || matchedPathWithQuery || '';
+        return !!(matchedPath || matchedPathWithQuery);
+    });
+};
+/**
+ * Processes redirect rules from redirect items (language-versioned)
+ * @param {RedirectResult[]} redirects redirect entries from Edge
+ * @param {string} locale current request locale
+ * @param {string} nonLocalePath current request path with locale prefix stripped
+ * @returns {RedirectResult | undefined} matched redirect item redirect result or undefined
+ * @internal
+ */
+export const matchRedirectItemRedirect = (redirects, locale, nonLocalePath) => {
+    return redirects.find((redirect) => {
+        const patternPath = redirect.pattern.replace(/\/+$/g, '').toLowerCase();
+        // locale rules are easy and nice
+        return redirect.locale === locale && patternPath === nonLocalePath;
+    });
+};
+/**
+ * Compiles a redirect pattern to RegExp; returns null if Sitecore produced a malformed rule
+ * so one bad entry does not fail the entire redirect chain.
+ * Supports both JS literal form (`/pattern/i`) and plain regex source (`^/path$`).
+ * @param {string} pattern redirect pattern from redirect map
+ * @returns {RegExp | null} normalized regex instance, or null when invalid
+ * @internal
+ */
+export const safeCompileRedirectPattern = (pattern) => {
+    try {
+        const normalizedPattern = escapeNonSpecialQuestionMarks(pattern);
+        const literalMatch = normalizedPattern.match(/^\/(.+)\/([a-z]*)$/i);
+        if (literalMatch) {
+            const [, source, flags] = literalMatch;
+            const safeFlags = flags || 'i';
+            return new RegExp(source, safeFlags);
+        }
+        return new RegExp(normalizedPattern, 'i');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`[RedirectsProxy] Invalid redirect regex; skipping rule. pattern=${pattern} (${message})`);
+        return null;
+    }
+};
+/**
+ * Detects absolute (external or protocol-relative) target URLs.
+ * @param {string} target redirect target
+ * @returns {boolean} true when the target is an absolute URL
+ * @internal
+ */
+export const isAbsoluteTarget = (target) => REGEXP_ABSOLUTE_URL.test(target);
+/**
+ * Resolves the redirect target string: replaces the `$siteLang` token and applies
+ * regex capture-group substitutions (`$1`, `$2`, …) when the rule pattern is a regex.
+ * @param {RedirectResult} existsRedirect matched redirect
+ * @param {string} siteLanguage site language used for the `$siteLang` token
+ * @param {string} requestPath incoming request path, used when the rule stored no matched path
+ * @returns {string} resolved target
+ * @internal
+ */
+export const resolveRedirectTarget = (existsRedirect, siteLanguage, requestPath) => {
+    let target = existsRedirect.target.replace(REGEXP_CONTEXT_SITE_LANG, siteLanguage);
+    // Apply regex replacements to the target URL if the pattern is a regex
+    if (isRegexOrUrl(existsRedirect.pattern) === 'regex') {
+        const sourcePath = existsRedirect.matchedPath || requestPath;
+        const pathForCaptureMatch = sourcePath.replace(/\/+$/g, '') || '/';
+        const redirectRegex = safeCompileRedirectPattern(existsRedirect.pattern);
+        const matched = redirectRegex ? pathForCaptureMatch.match(redirectRegex) : null;
+        if (matched) {
+            target = target.replace(/\$(\d+)/g, (_, index) => matched[parseInt(index, 10)] || '');
+        }
+    }
+    return target;
+};
+/**
+ * Resolves the absolute redirect target (external redirects), optionally preseriving query string
+ * @param {ProcessedPath} incomingPathData non locale path, locale prefix and query string (if present)
+ * @param {RedirectResult} existsRedirect matched redirect to resolve final result from
+ * @returns {string} URL to redirect to
+ * @internal
+ */
+export const processAbsoluteUrlTarget = (incomingPathData, existsRedirect) => {
+    if (!incomingPathData.queryString || !existsRedirect.isQueryStringPreserved) {
+        return existsRedirect.target;
+    }
+    const [targetMainUrl, targetQS] = existsRedirect.target.split('?');
+    const mergedQueryString = mergeURLSearchParams(new URLSearchParams(incomingPathData.queryString), new URLSearchParams(targetQS || ''));
+    return `${targetMainUrl}?${mergedQueryString}`;
+};
+/**
+ * Resolves the locale-less path and target locale for a relative redirect URL.
+ * The framework layer is responsible for placing the locale (pathname vs. locale property).
+ * @param {ProcessedPath} incomingPathData broken-down incoming request path
+ * @param {RedirectResult} existsRedirect matched redirect
+ * @param {string[]} configuredLocales configured site locales
+ * @param {string} reqLocale current request locale (used when `isLanguagePreserved`)
+ * @returns {{ targetLocale: string; targetPath: string }} resolved locale and locale-less path (with query)
+ * @internal
+ */
+export const processRelativeUrlTarget = (incomingPathData, existsRedirect, configuredLocales, reqLocale) => {
+    const { locale, nonLocalePath, queryString } = breakDownPath(configuredLocales, existsRedirect.target);
+    // preserve the request locale when the target has no locale prefix and the rule opts in
+    const targetLocale = locale || (existsRedirect.isLanguagePreserved ? reqLocale : '');
+    const targetQS = incomingPathData.queryString && existsRedirect.isQueryStringPreserved
+        ? mergeURLSearchParams(new URLSearchParams(incomingPathData.queryString), new URLSearchParams(queryString || ''))
+        : queryString || '';
+    return {
+        targetLocale,
+        targetPath: `${nonLocalePath}${targetQS ? '?' + targetQS : ''}`,
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sitecore-content-sdk/content",
-  "version": "2.2.1",
+  "version": "2.2.2-canary.20260727010537",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "sideEffects": false,

package/types/site/index.d.ts

@@ -6,5 +6,6 @@ export { SiteInfoService, SiteInfoServiceConfig } from './siteinfo-service';
 export { SitePathService, SitePathServiceConfig } from './sitepath-service';
 export { SiteInfo } from './models';
 export { getSiteRewrite, getSiteRewriteData, normalizeSiteRewrite, SiteRewriteData, SITE_PREFIX, SITE_KEY, getHostnameFromHostHeader, } from './utils';
+export * from './redirect-utils';
 export { SiteResolver } from './site-resolver';
 //# sourceMappingURL=index.d.ts.map

package/types/site/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/site/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACzF,OAAO,EACL,YAAY,EACZ,oBAAoB,EACpB,iBAAiB,EACjB,iBAAiB,EACjB,6BAA6B,EAC7B,gBAAgB,EAChB,sBAAsB,GACvB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,uBAAuB,GACxB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAE/F,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAC5E,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAE5E,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,oBAAoB,EACpB,eAAe,EACf,WAAW,EACX,QAAQ,EACR,yBAAyB,GAC1B,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/site/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACzF,OAAO,EACL,YAAY,EACZ,oBAAoB,EACpB,iBAAiB,EACjB,iBAAiB,EACjB,6BAA6B,EAC7B,gBAAgB,EAChB,sBAAsB,GACvB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,uBAAuB,GACxB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAE/F,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAC5E,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAE5E,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,oBAAoB,EACpB,eAAe,EACf,WAAW,EACX,QAAQ,EACR,yBAAyB,GAC1B,MAAM,SAAS,CAAC;AACjB,cAAc,kBAAkB,CAAC;AACjC,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC"}

package/types/site/redirect-utils.d.ts

@@ -0,0 +1,99 @@
+import { RedirectInfo } from '../site';
+/**
+ * Expanded redirect info to contain matchers for regexp match
+ * @internal
+ */
+export type RedirectResult = RedirectInfo & {
+    matchedQueryString?: string;
+    matchedPath?: string;
+};
+/**
+ * Broken down path with all parts needed to make a match for a redirect rule
+ * @internal
+ */
+export type ProcessedPath = {
+    nonLocalePath: string;
+    locale?: string;
+    queryString?: string;
+};
+/**
+ * Splits a URL path into its (optional) leading locale segment, the remaining
+ * locale-less path, and the query string. Locales are compared case-insensitively.
+ * A leading slash is always ensured on `nonLocalePath`; any trailing slash is preserved
+ * so slash-sensitive regex redirect rules can still be matched downstream.
+ * @param {string[]} configuredLocales configured site locales
+ * @param {string} urlPath path (optionally including a `?query`)
+ * @returns {ProcessedPath} broken-down path parts
+ * @internal
+ */
+export declare const breakDownPath: (configuredLocales: string[], urlPath: string) => ProcessedPath;
+/**
+ * Matches redirect-map rules (rules without a `locale` field) against the incoming request.
+ * The incoming path is provided pre-split as {@link ProcessedPath}, so matching starts from the
+ * guaranteed locale-less `nonLocalePath` and rebuilds the locale-prefixed variant from it. This
+ * avoids the ambiguity of a raw pathname that may or may not already carry a locale segment.
+ * @param {RedirectResult[]} redirects All redirects from the service (locale-scoped entries are filtered out).
+ * @param {string} requestLocale locale of the current request
+ * @param {ProcessedPath} incomingPathData broken-down incoming path (locale-less path and query)
+ * @returns {RedirectResult | undefined} First matching redirect or undefined.
+ * @internal
+ */
+export declare const matchFromRedirectMapRedirect: (redirects: RedirectResult[], requestLocale: string, incomingPathData: ProcessedPath) => RedirectResult | undefined;
+/**
+ * Processes redirect rules from redirect items (language-versioned)
+ * @param {RedirectResult[]} redirects redirect entries from Edge
+ * @param {string} locale current request locale
+ * @param {string} nonLocalePath current request path with locale prefix stripped
+ * @returns {RedirectResult | undefined} matched redirect item redirect result or undefined
+ * @internal
+ */
+export declare const matchRedirectItemRedirect: (redirects: RedirectResult[], locale: string, nonLocalePath: string) => RedirectResult | undefined;
+/**
+ * Compiles a redirect pattern to RegExp; returns null if Sitecore produced a malformed rule
+ * so one bad entry does not fail the entire redirect chain.
+ * Supports both JS literal form (`/pattern/i`) and plain regex source (`^/path$`).
+ * @param {string} pattern redirect pattern from redirect map
+ * @returns {RegExp | null} normalized regex instance, or null when invalid
+ * @internal
+ */
+export declare const safeCompileRedirectPattern: (pattern: string) => RegExp | null;
+/**
+ * Detects absolute (external or protocol-relative) target URLs.
+ * @param {string} target redirect target
+ * @returns {boolean} true when the target is an absolute URL
+ * @internal
+ */
+export declare const isAbsoluteTarget: (target: string) => boolean;
+/**
+ * Resolves the redirect target string: replaces the `$siteLang` token and applies
+ * regex capture-group substitutions (`$1`, `$2`, …) when the rule pattern is a regex.
+ * @param {RedirectResult} existsRedirect matched redirect
+ * @param {string} siteLanguage site language used for the `$siteLang` token
+ * @param {string} requestPath incoming request path, used when the rule stored no matched path
+ * @returns {string} resolved target
+ * @internal
+ */
+export declare const resolveRedirectTarget: (existsRedirect: RedirectResult, siteLanguage: string, requestPath: string) => string;
+/**
+ * Resolves the absolute redirect target (external redirects), optionally preseriving query string
+ * @param {ProcessedPath} incomingPathData non locale path, locale prefix and query string (if present)
+ * @param {RedirectResult} existsRedirect matched redirect to resolve final result from
+ * @returns {string} URL to redirect to
+ * @internal
+ */
+export declare const processAbsoluteUrlTarget: (incomingPathData: ProcessedPath, existsRedirect: RedirectResult) => string;
+/**
+ * Resolves the locale-less path and target locale for a relative redirect URL.
+ * The framework layer is responsible for placing the locale (pathname vs. locale property).
+ * @param {ProcessedPath} incomingPathData broken-down incoming request path
+ * @param {RedirectResult} existsRedirect matched redirect
+ * @param {string[]} configuredLocales configured site locales
+ * @param {string} reqLocale current request locale (used when `isLanguagePreserved`)
+ * @returns {{ targetLocale: string; targetPath: string }} resolved locale and locale-less path (with query)
+ * @internal
+ */
+export declare const processRelativeUrlTarget: (incomingPathData: ProcessedPath, existsRedirect: RedirectResult, configuredLocales: string[], reqLocale: string) => {
+    targetLocale: string;
+    targetPath: string;
+};
+//# sourceMappingURL=redirect-utils.d.ts.map

package/types/site/redirect-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redirect-utils.d.ts","sourceRoot":"","sources":["../../src/site/redirect-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAWvC;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,YAAY,GAAG;IAC1C,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,GAAI,mBAAmB,MAAM,EAAE,EAAE,SAAS,MAAM,KAAG,aAwB5E,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,4BAA4B,GACvC,WAAW,cAAc,EAAE,EAC3B,eAAe,MAAM,EACrB,kBAAkB,aAAa,KAC9B,cAAc,GAAG,SAqDnB,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,GACpC,WAAW,cAAc,EAAE,EAC3B,QAAQ,MAAM,EACd,eAAe,MAAM,KACpB,cAAc,GAAG,SAMnB,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B,GAAI,SAAS,MAAM,KAAG,MAAM,GAAG,IAiBrE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,QAAQ,MAAM,KAAG,OAA2C,CAAC;AAE9F;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,GAChC,gBAAgB,cAAc,EAC9B,cAAc,MAAM,EACpB,aAAa,MAAM,KAClB,MAkBF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,GACnC,kBAAkB,aAAa,EAC/B,gBAAgB,cAAc,KAC7B,MAUF,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,GACnC,kBAAkB,aAAa,EAC/B,gBAAgB,cAAc,EAC9B,mBAAmB,MAAM,EAAE,EAC3B,WAAW,MAAM,KAChB;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAoB5C,CAAC"}