🎉 initiate project *astro_rewrite*

node_modules/@astrojs/sitemap/dist/config-defaults.d.ts

@@ -0,0 +1,3 @@
+export declare const SITEMAP_CONFIG_DEFAULTS: {
+    entryLimit: number;
+};

node_modules/@astrojs/sitemap/dist/config-defaults.js

@@ -0,0 +1,6 @@
+const SITEMAP_CONFIG_DEFAULTS = {
+  entryLimit: 45e3
+};
+export {
+  SITEMAP_CONFIG_DEFAULTS
+};

node_modules/@astrojs/sitemap/dist/generate-sitemap.d.ts

@@ -0,0 +1,3 @@
+import type { SitemapItem, SitemapOptions } from './index.js';
+/** Construct sitemap.xml given a set of URLs */
+export declare function generateSitemap(pages: string[], finalSiteUrl: string, opts: SitemapOptions): SitemapItem[];

node_modules/@astrojs/sitemap/dist/generate-sitemap.js

@@ -0,0 +1,43 @@
+import { parseUrl } from "./utils/parse-url.js";
+function generateSitemap(pages, finalSiteUrl, opts) {
+  const { changefreq, priority, lastmod: lastmodSrc, i18n } = opts;
+  const urls = [...pages];
+  urls.sort((a, b) => a.localeCompare(b, "en", { numeric: true }));
+  const lastmod = lastmodSrc == null ? void 0 : lastmodSrc.toISOString();
+  const { locales, defaultLocale } = i18n || {};
+  const localeCodes = Object.keys(locales || {});
+  const getPath = (url) => {
+    const result = parseUrl(url, (i18n == null ? void 0 : i18n.defaultLocale) || "", localeCodes, finalSiteUrl);
+    return result == null ? void 0 : result.path;
+  };
+  const getLocale = (url) => {
+    const result = parseUrl(url, (i18n == null ? void 0 : i18n.defaultLocale) || "", localeCodes, finalSiteUrl);
+    return result == null ? void 0 : 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
+    };
+  });
+  return urlData;
+}
+export {
+  generateSitemap
+};

node_modules/@astrojs/sitemap/dist/index.d.ts

@@ -0,0 +1,21 @@
+import type { AstroIntegration } from 'astro';
+import { EnumChangefreq, type LinkItem as LinkItemBase, type SitemapItemLoose } from 'sitemap';
+export { EnumChangefreq as ChangeFreqEnum } from 'sitemap';
+export type ChangeFreq = `${EnumChangefreq}`;
+export type SitemapItem = Pick<SitemapItemLoose, 'url' | 'lastmod' | 'changefreq' | 'priority' | 'links'>;
+export type LinkItem = LinkItemBase;
+export type SitemapOptions = {
+    filter?(page: string): boolean;
+    customPages?: string[];
+    i18n?: {
+        defaultLocale: string;
+        locales: Record<string, string>;
+    };
+    entryLimit?: number;
+    changefreq?: ChangeFreq;
+    lastmod?: Date;
+    priority?: number;
+    serialize?(item: SitemapItem): SitemapItem | Promise<SitemapItem | undefined> | undefined;
+} | undefined;
+declare const createPlugin: (options?: SitemapOptions) => AstroIntegration;
+export default createPlugin;

node_modules/@astrojs/sitemap/dist/index.js

@@ -0,0 +1,128 @@
+import { fileURLToPath } from "node:url";
+import {
+  simpleSitemapAndIndex
+} from "sitemap";
+import { ZodError } from "zod";
+import { generateSitemap } from "./generate-sitemap.js";
+import { Logger } from "./utils/logger.js";
+import { validateOptions } from "./validate-options.js";
+import { EnumChangefreq as EnumChangefreq2 } from "sitemap";
+function formatConfigErrorMessage(err) {
+  const errorList = err.issues.map((issue) => ` ${issue.path.join(".")}  ${issue.message + "."}`);
+  return errorList.join("\n");
+}
+const PKG_NAME = "@astrojs/sitemap";
+const OUTFILE = "sitemap-index.xml";
+const STATUS_CODE_PAGES = /* @__PURE__ */ new Set(["/404", "/500"]);
+const createPlugin = (options) => {
+  let config;
+  const logger = new Logger(PKG_NAME);
+  return {
+    name: PKG_NAME,
+    hooks: {
+      "astro:config:done": async ({ config: cfg }) => {
+        config = cfg;
+      },
+      "astro:build:done": async ({ dir, routes, pages }) => {
+        try {
+          if (!config.site) {
+            logger.warn(
+              "The Sitemap integration requires the `site` astro.config option. Skipping."
+            );
+            return;
+          }
+          const opts = validateOptions(config.site, options);
+          const { filter, customPages, serialize, entryLimit } = opts;
+          let finalSiteUrl;
+          if (config.site) {
+            finalSiteUrl = new URL(config.base, config.site);
+          } else {
+            console.warn(
+              "The Sitemap integration requires the `site` astro.config option. Skipping."
+            );
+            return;
+          }
+          let pageUrls = pages.filter((p) => !STATUS_CODE_PAGES.has("/" + p.pathname.slice(0, -1))).map((p) => {
+            if (p.pathname !== "" && !finalSiteUrl.pathname.endsWith("/"))
+              finalSiteUrl.pathname += "/";
+            const path = finalSiteUrl.pathname + p.pathname;
+            return new URL(path, finalSiteUrl).href;
+          });
+          let routeUrls = routes.reduce((urls, r) => {
+            if (r.type !== "page")
+              return urls;
+            if (r.pathname) {
+              if (STATUS_CODE_PAGES.has(r.pathname))
+                return urls;
+              const path = finalSiteUrl.pathname + r.generate(r.pathname).substring(1);
+              let newUrl = new URL(path, finalSiteUrl).href;
+              if (config.trailingSlash === "never") {
+                urls.push(newUrl);
+              } else if (config.build.format === "directory" && !newUrl.endsWith("/")) {
+                urls.push(newUrl + "/");
+              } else {
+                urls.push(newUrl);
+              }
+            }
+            return urls;
+          }, []);
+          pageUrls = Array.from(/* @__PURE__ */ new Set([...pageUrls, ...routeUrls, ...customPages ?? []]));
+          try {
+            if (filter) {
+              pageUrls = pageUrls.filter(filter);
+            }
+          } catch (err) {
+            logger.error(`Error filtering pages
+${err.toString()}`);
+            return;
+          }
+          if (pageUrls.length === 0) {
+            logger.warn(`No pages found!
+\`${OUTFILE}\` not created.`);
+            return;
+          }
+          let urlData = generateSitemap(pageUrls, finalSiteUrl.href, opts);
+          if (serialize) {
+            try {
+              const serializedUrls = [];
+              for (const item of urlData) {
+                const serialized = await Promise.resolve(serialize(item));
+                if (serialized) {
+                  serializedUrls.push(serialized);
+                }
+              }
+              if (serializedUrls.length === 0) {
+                logger.warn("No pages found!");
+                return;
+              }
+              urlData = serializedUrls;
+            } catch (err) {
+              logger.error(`Error serializing pages
+${err.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;
+          }
+        }
+      }
+    }
+  };
+};
+var src_default = createPlugin;
+export {
+  EnumChangefreq2 as ChangeFreqEnum,
+  src_default as default
+};

node_modules/@astrojs/sitemap/dist/schema.d.ts

@@ -0,0 +1,54 @@
+import { EnumChangefreq as ChangeFreq } from 'sitemap';
+import { z } from 'zod';
+export declare const SitemapOptionsSchema: z.ZodDefault<z.ZodObject<{
+    filter: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodString], z.ZodUnknown>, z.ZodBoolean>>;
+    customPages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    canonicalURL: z.ZodOptional<z.ZodString>;
+    i18n: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+        defaultLocale: z.ZodString;
+        locales: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        locales: Record<string, string>;
+        defaultLocale: string;
+    }, {
+        locales: Record<string, string>;
+        defaultLocale: string;
+    }>, {
+        locales: Record<string, string>;
+        defaultLocale: string;
+    }, {
+        locales: Record<string, string>;
+        defaultLocale: string;
+    }>>;
+    entryLimit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    serialize: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodAny>>;
+    changefreq: z.ZodOptional<z.ZodNativeEnum<typeof ChangeFreq>>;
+    lastmod: z.ZodOptional<z.ZodDate>;
+    priority: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    changefreq?: ChangeFreq | undefined;
+    priority?: number | undefined;
+    lastmod?: Date | undefined;
+    i18n?: {
+        locales: Record<string, string>;
+        defaultLocale: string;
+    } | undefined;
+    filter?: ((args_0: string, ...args_1: unknown[]) => boolean) | undefined;
+    customPages?: string[] | undefined;
+    canonicalURL?: string | undefined;
+    serialize?: ((args_0: any, ...args_1: unknown[]) => any) | undefined;
+    entryLimit: number;
+}, {
+    changefreq?: ChangeFreq | undefined;
+    priority?: number | undefined;
+    lastmod?: Date | undefined;
+    i18n?: {
+        locales: Record<string, string>;
+        defaultLocale: string;
+    } | undefined;
+    filter?: ((args_0: string, ...args_1: unknown[]) => boolean) | undefined;
+    customPages?: string[] | undefined;
+    canonicalURL?: string | undefined;
+    entryLimit?: number | undefined;
+    serialize?: ((args_0: any, ...args_1: unknown[]) => any) | undefined;
+}>>;

node_modules/@astrojs/sitemap/dist/schema.js

@@ -0,0 +1,28 @@
+import { EnumChangefreq as ChangeFreq } from "sitemap";
+import { z } from "zod";
+import { SITEMAP_CONFIG_DEFAULTS } from "./config-defaults.js";
+const localeKeySchema = z.string().min(1);
+const SitemapOptionsSchema = z.object({
+  filter: z.function().args(z.string()).returns(z.boolean()).optional(),
+  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 exist in `locales` keys"
+  }).optional(),
+  entryLimit: z.number().nonnegative().optional().default(SITEMAP_CONFIG_DEFAULTS.entryLimit),
+  serialize: z.function().args(z.any()).returns(z.any()).optional(),
+  changefreq: z.nativeEnum(ChangeFreq).optional(),
+  lastmod: z.date().optional(),
+  priority: z.number().min(0).max(1).optional()
+}).strict().default(SITEMAP_CONFIG_DEFAULTS);
+export {
+  SitemapOptionsSchema
+};

node_modules/@astrojs/sitemap/dist/utils/is-object-empty.d.ts

@@ -0,0 +1 @@
+export declare const isObjectEmpty: (o: any) => boolean;

node_modules/@astrojs/sitemap/dist/utils/is-object-empty.js

@@ -0,0 +1,12 @@
+const isObjectEmpty = (o) => {
+  if (!o) {
+    return true;
+  }
+  if (Array.isArray(o)) {
+    return o.length === 0;
+  }
+  return Object.keys(o).length === 0 && Object.getPrototypeOf(o) === Object.prototype;
+};
+export {
+  isObjectEmpty
+};

node_modules/@astrojs/sitemap/dist/utils/is-valid-url.d.ts

@@ -0,0 +1 @@
+export declare const isValidUrl: (s: any) => boolean;

node_modules/@astrojs/sitemap/dist/utils/is-valid-url.js

@@ -0,0 +1,14 @@
+const isValidUrl = (s) => {
+  if (typeof s !== "string" || !s) {
+    return false;
+  }
+  try {
+    const dummy = new URL(s);
+    return true;
+  } catch {
+    return false;
+  }
+};
+export {
+  isValidUrl
+};

node_modules/@astrojs/sitemap/dist/utils/logger.d.ts

@@ -0,0 +1,16 @@
+export interface ILogger {
+    info(msg: string): void;
+    success(msg: string): void;
+    warn(msg: string): void;
+    error(msg: string): void;
+}
+export declare class Logger implements ILogger {
+    private colors;
+    private packageName;
+    constructor(packageName: string);
+    private log;
+    info(msg: string): void;
+    success(msg: string): void;
+    warn(msg: string): void;
+    error(msg: string): void;
+}

node_modules/@astrojs/sitemap/dist/utils/logger.js

@@ -0,0 +1,34 @@
+class Logger {
+  constructor(packageName) {
+    this.colors = {
+      reset: "\x1B[0m",
+      fg: {
+        red: "\x1B[31m",
+        green: "\x1B[32m",
+        yellow: "\x1B[33m"
+      }
+    };
+    this.packageName = packageName;
+  }
+  log(msg, prefix = "") {
+    console.log(`%s${this.packageName}:%s ${msg}
+`, prefix, prefix ? this.colors.reset : "");
+  }
+  info(msg) {
+    this.log(msg);
+  }
+  success(msg) {
+    this.log(msg, this.colors.fg.green);
+  }
+  warn(msg) {
+    this.log(`Skipped!
+${msg}`, this.colors.fg.yellow);
+  }
+  error(msg) {
+    this.log(`Failed!
+${msg}`, this.colors.fg.red);
+  }
+}
+export {
+  Logger
+};

node_modules/@astrojs/sitemap/dist/utils/parse-url.d.ts

@@ -0,0 +1,4 @@
+export declare const parseUrl: (url: string, defaultLocale: string, localeCodes: string[], base: string) => {
+    locale: string;
+    path: string;
+} | undefined;

node_modules/@astrojs/sitemap/dist/utils/parse-url.js

@@ -0,0 +1,31 @@
+const parseUrl = (url, defaultLocale, localeCodes, base) => {
+  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 void 0;
+  }
+  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 };
+};
+export {
+  parseUrl
+};

node_modules/@astrojs/sitemap/dist/validate-options.d.ts

@@ -0,0 +1,15 @@
+import type { SitemapOptions } from './index.js';
+export declare const validateOptions: (site: string | undefined, opts: SitemapOptions) => {
+    changefreq?: import("sitemap/dist/lib/types.js").EnumChangefreq | undefined;
+    priority?: number | undefined;
+    lastmod?: Date | undefined;
+    i18n?: {
+        locales: Record<string, string>;
+        defaultLocale: string;
+    } | undefined;
+    filter?: ((args_0: string, ...args_1: unknown[]) => boolean) | undefined;
+    customPages?: string[] | undefined;
+    canonicalURL?: string | undefined;
+    serialize?: ((args_0: any, ...args_1: unknown[]) => any) | undefined;
+    entryLimit: number;
+};

node_modules/@astrojs/sitemap/dist/validate-options.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { SitemapOptionsSchema } from "./schema.js";
+const validateOptions = (site, opts) => {
+  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((options) => options.site || options.canonicalURL, {
+    message: "Required `site` astro.config option or `canonicalURL` integration option"
+  }).parse({
+    site,
+    canonicalURL: result.canonicalURL
+  });
+  return result;
+};
+export {
+  validateOptions
+};