diff --git a/.changeset/popular-cherries-float.md b/.changeset/popular-cherries-float.md
new file mode 100644
index 0000000000..f04ab3f3ce
--- /dev/null
+++ b/.changeset/popular-cherries-float.md
@@ -0,0 +1,18 @@
+---
+'@astrojs/sitemap': minor
+---
+
+# Key features
+
+- Split up your large sitemap into multiple sitemaps by custom limit.
+- Ability to add sitemap specific attributes such as `lastmod` etc.
+- Final output customization via JS function.
+- Localization support.
+- Reliability: all config options are validated.
+
+## Important changes
+
+The integration always generates at least two files instead of one:
+
+- `sitemap-index.xml` - index file;
+- `sitemap-{i}.xml` - actual sitemap.
diff --git a/examples/integrations-playground/astro.config.mjs b/examples/integrations-playground/astro.config.mjs
index a7c3d4a0b7..939d228669 100644
--- a/examples/integrations-playground/astro.config.mjs
+++ b/examples/integrations-playground/astro.config.mjs
@@ -9,5 +9,6 @@ import solid from '@astrojs/solid-js';
// https://astro.build/config
export default defineConfig({
+ site: 'https://example.com',
integrations: [lit(), react(), tailwind(), turbolinks(), partytown(), sitemap(), solid()],
});
diff --git a/packages/integrations/sitemap/README.md b/packages/integrations/sitemap/README.md
index 9d84cae195..ab880a075f 100644
--- a/packages/integrations/sitemap/README.md
+++ b/packages/integrations/sitemap/README.md
@@ -64,7 +64,35 @@ export default {
}
```
-Now, [build your site for production](https://docs.astro.build/en/reference/cli-reference/#astro-build) via the `astro build` command. You should find your sitemap under `dist/sitemap.xml`!
+Now, [build your site for production](https://docs.astro.build/en/reference/cli-reference/#astro-build) via the `astro build` command. You should find your _sitemap_ under `dist/sitemap-index.xml` and `dist/sitemap-0.xml`!
+
+Generated sitemap content for two pages website:
+
+**sitemap-index.xml**
+
+```xml
+
+
+
+ https://stargazers.club/sitemap-0.xml
+
+
+```
+
+**sitemap-0.xml**
+
+
+```xml
+
+
+
+ https://stargazers.club/
+
+
+ https://stargazers.club/second-page/
+
+
+```
You can also check our [Astro Integration Documentation][astro-integration] for more on integrations.
@@ -111,5 +139,158 @@ export default {
}
```
+### entryLimit
+
+Non-negative `Number` of entries per sitemap file. Default value is 45000. A sitemap index and multiple sitemaps are created if you have more entries. See explanation on [Google](https://developers.google.com/search/docs/advanced/sitemaps/large-sitemaps).
+
+__astro.config.mjs__
+
+```js
+import sitemap from '@astrojs/sitemap';
+
+export default {
+ site: 'https://stargazers.club',
+ integrations: [
+ sitemap({
+ entryLimit: 10000,
+ }),
+ ],
+}
+```
+
+### changefreq, lastmod, priority
+
+`changefreq` - How frequently the page is likely to change. Available values: `always` \| `hourly` \| `daily` \| `weekly` \| `monthly` \| `yearly` \| `never`.
+
+`priority` - The priority of this URL relative to other URLs on your site. Valid values range from 0.0 to 1.0.
+
+`lastmod` - The date of page last modification.
+
+`changefreq` and `priority` are ignored by Google.
+
+See detailed explanation of sitemap specific options on [sitemap.org](https://www.sitemaps.org/protocol.html).
+
+
+:exclamation: This integration uses 'astro:build:done' hook. The hook exposes generated page paths only. So with present version of Astro the integration has no abilities to analyze a page source, frontmatter etc. The integration can add `changefreq`, `lastmod` and `priority` attributes only in a batch or nothing.
+
+__astro.config.mjs__
+
+```js
+import sitemap from '@astrojs/sitemap';
+
+export default {
+ site: 'https://stargazers.club',
+ integrations: [
+ sitemap({
+ changefreq: 'weekly',
+ priority: 0.7,
+ lastmod: new Date('2022-02-24'),
+ }),
+ ],
+}
+```
+
+### serialize
+
+Async or sync function called for each sitemap entry just before writing to a disk.
+
+It receives as parameter `SitemapItem` object which consists of `url` (required, absolute page URL) and optional `changefreq`, `lastmod`, `priority` and `links` properties.
+
+Optional `links` property contains a `LinkItem` list of alternate pages including a parent page.
+`LinkItem` type has two required fields: `url` (the fully-qualified URL for the version of this page for the specified language) and `hreflang` (a supported language code targeted by this version of the page).
+
+`serialize` function should return `SitemapItem`, touched or not.
+
+The example below shows the ability to add the sitemap specific properties individually.
+
+__astro.config.mjs__
+
+```js
+import sitemap from '@astrojs/sitemap';
+
+export default {
+ site: 'https://stargazers.club',
+ integrations: [
+ sitemap({
+ serialize(item) {
+ if (/your-special-page/.test(item.url)) {
+ item.changefreq = 'daily';
+ item.lastmod = new Date();
+ item.priority = 0.9;
+ }
+ return item;
+ },
+ }),
+ ],
+}
+```
+
+### i18n
+
+To localize a sitemap you should supply the integration config with the `i18n` option. The integration will check generated page paths on presence of locale keys in paths.
+
+`i18n` object has two required properties:
+
+- `defaultLocale`: `String`. Its value must exist as one of `locales` keys.
+- `locales`: `Record`, key/value - pairs. The key is used to look for a locale part in a page path. The value is a language attribute, only English alphabet and hyphen allowed. See more about language attribute on [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/lang).
+
+
+Read more about localization on Google in [Advanced SEO](https://developers.google.com/search/docs/advanced/crawling/localized-versions#all-method-guidelines).
+
+__astro.config.mjs__
+
+```js
+import sitemap from '@astrojs/sitemap';
+
+export default {
+ site: 'https://stargazers.club',
+ integrations: [
+ sitemap({
+ i18n: {
+ defaultLocale: 'en', // All urls that don't contain `es` or `fr` after `https://stargazers.club/` will be treated as default locale, i.e. `en`
+ locales: {
+ en: 'en-US', // The `defaultLocale` value must present in `locales` keys
+ es: 'es-ES',
+ fr: 'fr-CA',
+ },
+ },
+ }),
+ ],
+};
+...
+
+```
+
+The sitemap content will be:
+
+```xml
+...
+
+ https://stargazers.club/
+
+
+
+
+
+ https://stargazers.club/es/
+
+
+
+
+
+ https://stargazers.club/fr/
+
+
+
+
+
+ https://stargazers.club/es/second-page/
+
+
+
+
+...
+```
+
[astro-integration]: https://docs.astro.build/en/guides/integrations-guide/
[astro-ui-frameworks]: https://docs.astro.build/en/core-concepts/framework-components/#using-framework-components
diff --git a/packages/integrations/sitemap/package.json b/packages/integrations/sitemap/package.json
index 3fbfc2b94b..d61c608b3b 100644
--- a/packages/integrations/sitemap/package.json
+++ b/packages/integrations/sitemap/package.json
@@ -13,7 +13,8 @@
},
"keywords": [
"astro-component",
- "seo"
+ "seo",
+ "sitemap"
],
"bugs": "https://github.com/withastro/astro/issues",
"homepage": "https://astro.build",
@@ -21,12 +22,18 @@
".": "./dist/index.js",
"./package.json": "./package.json"
},
+ "files": [
+ "dist"
+ ],
"scripts": {
"build": "astro-scripts build \"src/**/*.ts\" && tsc",
"build:ci": "astro-scripts build \"src/**/*.ts\"",
"dev": "astro-scripts dev \"src/**/*.ts\""
},
- "dependencies": {},
+ "dependencies": {
+ "sitemap": "^7.1.1",
+ "zod": "^3.17.3"
+ },
"devDependencies": {
"astro": "workspace:*",
"astro-scripts": "workspace:*"
diff --git a/packages/integrations/sitemap/src/config-defaults.ts b/packages/integrations/sitemap/src/config-defaults.ts
new file mode 100644
index 0000000000..22288fc119
--- /dev/null
+++ b/packages/integrations/sitemap/src/config-defaults.ts
@@ -0,0 +1,5 @@
+import type { SitemapOptions } from './index';
+
+export const SITEMAP_CONFIG_DEFAULTS: SitemapOptions & any = {
+ entryLimit: 45000,
+};
diff --git a/packages/integrations/sitemap/src/constants.ts b/packages/integrations/sitemap/src/constants.ts
new file mode 100644
index 0000000000..431cc5954e
--- /dev/null
+++ b/packages/integrations/sitemap/src/constants.ts
@@ -0,0 +1,9 @@
+export const changefreqValues = [
+ 'always',
+ 'hourly',
+ 'daily',
+ 'weekly',
+ 'monthly',
+ 'yearly',
+ 'never',
+] as const;
diff --git a/packages/integrations/sitemap/src/generate-sitemap.ts b/packages/integrations/sitemap/src/generate-sitemap.ts
new file mode 100644
index 0000000000..3c39e1f7ec
--- /dev/null
+++ b/packages/integrations/sitemap/src/generate-sitemap.ts
@@ -0,0 +1,55 @@
+import { SitemapItemLoose } from 'sitemap';
+
+import type { SitemapOptions } from './index';
+import { parseUrl } from './utils/parse-url';
+
+const STATUS_CODE_PAGE_REGEXP = /\/[0-9]{3}\/?$/;
+
+/** Construct sitemap.xml given a set of URLs */
+export function generateSitemap(pages: string[], finalSiteUrl: string, opts: SitemapOptions) {
+ const { changefreq, priority: prioritySrc, lastmod: lastmodSrc, i18n } = opts || {};
+ // TODO: find way to respect URLs here
+ const urls = [...pages].filter((url) => !STATUS_CODE_PAGE_REGEXP.test(url));
+ urls.sort((a, b) => a.localeCompare(b, 'en', { numeric: true })); // sort alphabetically so sitemap is same each time
+
+ const lastmod = lastmodSrc?.toISOString();
+ const priority = typeof prioritySrc === 'number' ? prioritySrc : undefined;
+
+ const { locales, defaultLocale } = i18n || {};
+ const localeCodes = Object.keys(locales || {});
+
+ const getPath = (url: string) => {
+ const result = parseUrl(url, i18n?.defaultLocale || '', localeCodes, finalSiteUrl);
+ return result?.path;
+ };
+ const getLocale = (url: string) => {
+ const result = parseUrl(url, i18n?.defaultLocale || '', localeCodes, finalSiteUrl);
+ return result?.locale;
+ };
+
+ const urlData = urls.map((url) => {
+ let links;
+ if (defaultLocale && locales) {
+ const currentPath = getPath(url);
+ if (currentPath) {
+ const filtered = urls.filter((subUrl) => getPath(subUrl) === currentPath);
+ if (filtered.length > 1) {
+ links = filtered.map((subUrl) => ({
+ url: subUrl,
+ lang: locales[getLocale(subUrl)!],
+ }));
+ }
+ }
+ }
+
+ return {
+ url,
+ links,
+ lastmod,
+ priority,
+ changefreq, // : changefreq as EnumChangefreq,
+ } as SitemapItemLoose;
+ });
+
+ return urlData;
+}
diff --git a/packages/integrations/sitemap/src/index.ts b/packages/integrations/sitemap/src/index.ts
index 169eeb7887..700f688769 100644
--- a/packages/integrations/sitemap/src/index.ts
+++ b/packages/integrations/sitemap/src/index.ts
@@ -1,91 +1,138 @@
+import { fileURLToPath } from 'url';
import type { AstroConfig, AstroIntegration } from 'astro';
-import fs from 'node:fs';
-const STATUS_CODE_PAGE_REGEXP = /\/[0-9]{3}\/?$/;
+import { ZodError } from 'zod';
+import { LinkItem as LinkItemBase, SitemapItemLoose, simpleSitemapAndIndex } from 'sitemap';
-type SitemapOptions =
+import { Logger } from './utils/logger';
+import { changefreqValues } from './constants';
+import { validateOptions } from './validate-options';
+import { generateSitemap } from './generate-sitemap';
+
+export type ChangeFreq = typeof changefreqValues[number];
+export type SitemapItem = Pick<
+ SitemapItemLoose,
+ 'url' | 'lastmod' | 'changefreq' | 'priority' | 'links'
+>;
+export type LinkItem = LinkItemBase;
+
+export type SitemapOptions =
| {
- /**
- * All pages are included in your sitemap by default.
- * With this config option, you can filter included pages by URL.
- *
- * The `page` function parameter is the full URL of your rendered page, including your `site` domain.
- * Return `true` to include a page in your sitemap, and `false` to remove it.
- *
- * ```js
- * filter: (page) => page !== 'http://example.com/secret-page'
- * ```
- */
filter?(page: string): boolean;
-
- /**
- * If you have any URL, not rendered by Astro, that you want to include in your sitemap,
- * this config option will help you to include your array of custom pages in your sitemap.
- *
- * ```js
- * customPages: ['http://example.com/custom-page', 'http://example.com/custom-page2']
- * ```
- */
- customPages?: Array;
-
- /**
- * If present, we use the `site` config option as the base for all sitemap URLs
- * Use `canonicalURL` to override this
- */
+ customPages?: string[];
canonicalURL?: string;
+
+ i18n?: {
+ defaultLocale: string;
+ locales: Record;
+ };
+ // number of entries per sitemap file
+ entryLimit?: number;
+
+ // sitemap specific
+ changefreq?: ChangeFreq;
+ lastmod?: Date;
+ priority?: number;
+
+ // called for each sitemap item just before to save them on disk, sync or async
+ serialize?(item: SitemapItemLoose): SitemapItemLoose;
}
| undefined;
-/** Construct sitemap.xml given a set of URLs */
-function generateSitemap(pages: string[]) {
- // TODO: find way to respect URLs here
- const urls = [...pages].filter((url) => !STATUS_CODE_PAGE_REGEXP.test(url));
- urls.sort((a, b) => a.localeCompare(b, 'en', { numeric: true })); // sort alphabetically so sitemap is same each time
- let sitemap = ``;
- for (const url of urls) {
- sitemap += `${url}`;
- }
- sitemap += `\n`;
- return sitemap;
+function formatConfigErrorMessage(err: ZodError) {
+ const errorList = err.issues.map((issue) => ` ${issue.path.join('.')} ${issue.message + '.'}`);
+ return errorList.join('\n');
}
-export default function createPlugin({
- filter,
- customPages,
- canonicalURL,
-}: SitemapOptions = {}): AstroIntegration {
+const PKG_NAME = '@astrojs/sitemap';
+const OUTFILE = 'sitemap-index.xml';
+
+const createPlugin = (options?: SitemapOptions): AstroIntegration => {
let config: AstroConfig;
return {
- name: '@astrojs/sitemap',
+ name: PKG_NAME,
+
hooks: {
- 'astro:config:done': async ({ config: _config }) => {
- config = _config;
+ 'astro:config:done': async ({ config: cfg }) => {
+ config = cfg;
},
- 'astro:build:done': async ({ pages, dir }) => {
- let finalSiteUrl: URL;
- if (canonicalURL) {
- finalSiteUrl = new URL(canonicalURL);
- finalSiteUrl.pathname += finalSiteUrl.pathname.endsWith('/') ? '' : '/'; // normalizes the final url since it's provided by user
- } else if (config.site) {
- finalSiteUrl = new URL(config.base, config.site);
- } else {
- console.warn(
- 'The Sitemap integration requires either the `site` astro.config option or `canonicalURL` integration option. Skipping.'
- );
- return;
+
+ 'astro:build:done': async ({ dir, pages }) => {
+ const logger = new Logger(PKG_NAME);
+
+ try {
+ const opts = validateOptions(config.site, options);
+
+ const { filter, customPages, canonicalURL, serialize, entryLimit } = opts;
+
+ let finalSiteUrl: URL;
+ if (canonicalURL) {
+ finalSiteUrl = new URL(canonicalURL);
+ if (!finalSiteUrl.pathname.endsWith('/')) {
+ finalSiteUrl.pathname += '/'; // normalizes the final url since it's provided by user
+ }
+ } else {
+ // `validateOptions` forces to provide `canonicalURL` or `config.site` at least.
+ // So step to check on empty values of `canonicalURL` and `config.site` is dropped.
+ finalSiteUrl = new URL(config.base, config.site);
+ }
+
+ let pageUrls = pages.map((p) => {
+ const path = finalSiteUrl.pathname + p.pathname;
+ return new URL(path, finalSiteUrl).href;
+ });
+
+ try {
+ if (filter) {
+ pageUrls = pageUrls.filter(filter);
+ }
+ } catch (err) {
+ logger.error(`Error filtering pages\n${(err as any).toString()}`);
+ return;
+ }
+
+ if (customPages) {
+ pageUrls = [...pageUrls, ...customPages];
+ }
+
+ if (pageUrls.length === 0) {
+ logger.warn(`No data for sitemap.\n\`${OUTFILE}\` is not created.`);
+ return;
+ }
+
+ let urlData = generateSitemap(pageUrls, finalSiteUrl.href, opts);
+
+ if (serialize) {
+ try {
+ const serializedUrls: SitemapItemLoose[] = [];
+ for (const item of urlData) {
+ const serialized = await Promise.resolve(serialize(item));
+ serializedUrls.push(serialized);
+ }
+ urlData = serializedUrls;
+ } catch (err) {
+ logger.error(`Error serializing pages\n${(err as any).toString()}`);
+ return;
+ }
+ }
+
+ await simpleSitemapAndIndex({
+ hostname: finalSiteUrl.href,
+ destinationDir: fileURLToPath(dir),
+ sourceData: urlData,
+ limit: entryLimit,
+ gzip: false,
+ });
+ logger.success(`\`${OUTFILE}\` is created.`);
+ } catch (err) {
+ if (err instanceof ZodError) {
+ logger.warn(formatConfigErrorMessage(err));
+ } else {
+ throw err;
+ }
}
- let pageUrls = pages.map((p) => {
- const path = finalSiteUrl.pathname + p.pathname;
- return new URL(path, finalSiteUrl).href;
- });
- if (filter) {
- pageUrls = pageUrls.filter((page: string) => filter(page));
- }
- if (customPages) {
- pageUrls = [...pageUrls, ...customPages];
- }
- const sitemapContent = generateSitemap(pageUrls);
- fs.writeFileSync(new URL('sitemap.xml', dir), sitemapContent);
},
},
};
-}
+};
+
+export default createPlugin;
diff --git a/packages/integrations/sitemap/src/schema.ts b/packages/integrations/sitemap/src/schema.ts
new file mode 100644
index 0000000000..723f9ac584
--- /dev/null
+++ b/packages/integrations/sitemap/src/schema.ts
@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { changefreqValues } from './constants';
+import { SITEMAP_CONFIG_DEFAULTS } from './config-defaults';
+
+const localeKeySchema = () => z.string().min(1);
+
+const isFunction = (fn: any) => fn instanceof Function;
+
+const fnSchema = () =>
+ z
+ .any()
+ .refine((val) => !val || isFunction(val), { message: 'Not a function' })
+ .optional();
+
+export const SitemapOptionsSchema = z
+ .object({
+ filter: fnSchema(),
+ customPages: z.string().url().array().optional(),
+ canonicalURL: z.string().url().optional(),
+
+ i18n: z
+ .object({
+ defaultLocale: localeKeySchema(),
+ locales: z.record(
+ localeKeySchema(),
+ z
+ .string()
+ .min(2)
+ .regex(/^[a-zA-Z\-]+$/gm, {
+ message: 'Only English alphabet symbols and hyphen allowed',
+ })
+ ),
+ })
+ .refine((val) => !val || val.locales[val.defaultLocale], {
+ message: '`defaultLocale` must exists in `locales` keys',
+ })
+ .optional(),
+
+ entryLimit: z.number().nonnegative().default(SITEMAP_CONFIG_DEFAULTS.entryLimit),
+ serialize: fnSchema(),
+
+ changefreq: z.enum(changefreqValues).optional(),
+ lastmod: z.date().optional(),
+ priority: z.number().min(0).max(1).optional(),
+ })
+ .strict()
+ .default(SITEMAP_CONFIG_DEFAULTS);
diff --git a/packages/integrations/sitemap/src/utils/is-object-empty.ts b/packages/integrations/sitemap/src/utils/is-object-empty.ts
new file mode 100644
index 0000000000..0d61810695
--- /dev/null
+++ b/packages/integrations/sitemap/src/utils/is-object-empty.ts
@@ -0,0 +1,10 @@
+// @internal
+export const isObjectEmpty = (o: any) => {
+ if (!o) {
+ return true;
+ }
+ if (Array.isArray(o)) {
+ return o.length === 0;
+ }
+ return Object.keys(o).length === 0 && Object.getPrototypeOf(o) === Object.prototype;
+};
diff --git a/packages/integrations/sitemap/src/utils/is-valid-url.ts b/packages/integrations/sitemap/src/utils/is-valid-url.ts
new file mode 100644
index 0000000000..b140623b09
--- /dev/null
+++ b/packages/integrations/sitemap/src/utils/is-valid-url.ts
@@ -0,0 +1,13 @@
+// @internal
+export const isValidUrl = (s: any) => {
+ if (typeof s !== 'string' || !s) {
+ return false;
+ }
+ try {
+ // eslint-disable-next-line @typescript-eslint/no-unused-vars
+ const dummy = new URL(s);
+ return true;
+ } catch {
+ return false;
+ }
+};
diff --git a/packages/integrations/sitemap/src/utils/logger.ts b/packages/integrations/sitemap/src/utils/logger.ts
new file mode 100644
index 0000000000..203baeaa7a
--- /dev/null
+++ b/packages/integrations/sitemap/src/utils/logger.ts
@@ -0,0 +1,46 @@
+// @internal
+export interface ILogger {
+ info(msg: string): void;
+ success(msg: string): void;
+ warn(msg: string): void;
+ error(msg: string): void;
+}
+
+// @internal
+export class Logger implements ILogger {
+ private colors = {
+ reset: '\x1b[0m',
+ fg: {
+ red: '\x1b[31m',
+ green: '\x1b[32m',
+ yellow: '\x1b[33m',
+ },
+ } as const;
+
+ private packageName: string;
+
+ constructor(packageName: string) {
+ this.packageName = packageName;
+ }
+
+ private log(msg: string, prefix: string = '') {
+ // eslint-disable-next-line no-console
+ console.log(`%s${this.packageName}:%s ${msg}\n`, prefix, prefix ? this.colors.reset : '');
+ }
+
+ info(msg: string) {
+ this.log(msg);
+ }
+
+ success(msg: string) {
+ this.log(msg, this.colors.fg.green);
+ }
+
+ warn(msg: string) {
+ this.log(`Skipped!\n${msg}`, this.colors.fg.yellow);
+ }
+
+ error(msg: string) {
+ this.log(`Failed!\n${msg}`, this.colors.fg.red);
+ }
+}
diff --git a/packages/integrations/sitemap/src/utils/parse-url.ts b/packages/integrations/sitemap/src/utils/parse-url.ts
new file mode 100644
index 0000000000..f9189cf7d6
--- /dev/null
+++ b/packages/integrations/sitemap/src/utils/parse-url.ts
@@ -0,0 +1,39 @@
+export const parseUrl = (
+ url: string,
+ defaultLocale: string,
+ localeCodes: string[],
+ base: string
+) => {
+ if (
+ !url ||
+ !defaultLocale ||
+ localeCodes.length === 0 ||
+ localeCodes.some((key) => !key) ||
+ !base
+ ) {
+ throw new Error('parseUrl: some parameters are empty');
+ }
+ if (url.indexOf(base) !== 0) {
+ return undefined;
+ }
+ let s = url.replace(base, '');
+ if (!s || s === '/') {
+ return { locale: defaultLocale, path: '/' };
+ }
+ if (!s.startsWith('/')) {
+ s = '/' + s;
+ }
+ const a = s.split('/');
+ const locale = a[1];
+ if (localeCodes.some((key) => key === locale)) {
+ let path = a.slice(2).join('/');
+ if (path === '//') {
+ path = '/';
+ }
+ if (path !== '/' && !path.startsWith('/')) {
+ path = '/' + path;
+ }
+ return { locale, path };
+ }
+ return { locale: defaultLocale, path: s };
+};
diff --git a/packages/integrations/sitemap/src/validate-options.ts b/packages/integrations/sitemap/src/validate-options.ts
new file mode 100644
index 0000000000..f89582d827
--- /dev/null
+++ b/packages/integrations/sitemap/src/validate-options.ts
@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import type { SitemapOptions } from './index';
+import { SitemapOptionsSchema } from './schema';
+
+// @internal
+export const validateOptions = (site: string | undefined, opts: SitemapOptions) => {
+ const result = SitemapOptionsSchema.parse(opts);
+
+ z.object({
+ site: z.string().optional(), // Astro takes care of `site`: how to validate, transform and refine
+ canonicalURL: z.string().optional(), // `canonicalURL` is already validated in prev step
+ })
+ .refine(({ site, canonicalURL }) => site || canonicalURL, {
+ message: 'Required `site` astro.config option or `canonicalURL` integration option',
+ })
+ .parse({
+ site,
+ canonicalURL: result.canonicalURL,
+ });
+
+ return result;
+};
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index abb1384cfb..7e862156e4 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -1824,6 +1824,11 @@ importers:
specifiers:
astro: workspace:*
astro-scripts: workspace:*
+ sitemap: ^7.1.1
+ zod: ^3.17.3
+ dependencies:
+ sitemap: 7.1.1
+ zod: 3.17.3
devDependencies:
astro: link:../../astro
astro-scripts: link:../../../scripts
@@ -6852,6 +6857,12 @@ packages:
'@types/node': 17.0.41
dev: false
+ /@types/sax/1.2.4:
+ resolution: {integrity: sha512-pSAff4IAxJjfAXUG6tFkO7dsSbTmf8CtUpfhhZ5VhkRpC4628tJhh3+V6H1E+/Gs9piSzYKT5yzHO5M4GG9jkw==}
+ dependencies:
+ '@types/node': 17.0.41
+ dev: false
+
/@types/scheduler/0.16.2:
resolution: {integrity: sha512-hppQEBDmlwhFAXKJX2KnWLYu5yMfi91yazPb2l+lbJiwW+wdo1gNeRA+3RgNSO39WYX2euey41KEwnqesU2Jew==}
@@ -8164,6 +8175,11 @@ packages:
/debug/3.2.7:
resolution: {integrity: sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==}
+ peerDependencies:
+ supports-color: '*'
+ peerDependenciesMeta:
+ supports-color:
+ optional: true
dependencies:
ms: 2.1.3
dev: false
@@ -11080,6 +11096,8 @@ packages:
debug: 3.2.7
iconv-lite: 0.4.24
sax: 1.2.4
+ transitivePeerDependencies:
+ - supports-color
dev: false
/netmask/2.0.2:
@@ -11163,6 +11181,8 @@ packages:
rimraf: 2.7.1
semver: 5.7.1
tar: 4.4.19
+ transitivePeerDependencies:
+ - supports-color
dev: false
/node-releases/2.0.5:
@@ -12535,6 +12555,17 @@ packages:
resolution: {integrity: sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==}
dev: false
+ /sitemap/7.1.1:
+ resolution: {integrity: sha512-mK3aFtjz4VdJN0igpIJrinf3EO8U8mxOPsTBzSsy06UtjZQJ3YY3o3Xa7zSc5nMqcMrRwlChHZ18Kxg0caiPBg==}
+ engines: {node: '>=12.0.0', npm: '>=5.6.0'}
+ hasBin: true
+ dependencies:
+ '@types/node': 17.0.41
+ '@types/sax': 1.2.4
+ arg: 5.0.2
+ sax: 1.2.4
+ dev: false
+
/slash/2.0.0:
resolution: {integrity: sha512-ZYKh3Wh2z1PpEXWr0MpSBZ0V6mZHAQfYevttO11c51CaWjGTaadiKZ+wVt1PbMlDV5qhMFslpZCemhwOK7C89A==}
engines: {node: '>=6'}