@studiocms/cfetch 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 StudioCMS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,92 @@
+# `@studiocms/cfetch`
+
+This is an [Astro integration](https://docs.astro.build/en/guides/integrations-guide/) that provides a cacheable fetch function for Astro SSR
+
+## Usage
+
+### Prerequisites
+
+- Using with an Astro SSR project, While you could import and use this in an Astro SSG (static) project, it would have no benefit as Astro Static pages are pre-rendered.
+
+### Installation
+
+Install the integration **automatically** using the Astro CLI:
+
+```bash
+pnpm astro add @studiocms/cfetch
+```
+
+```bash
+npx astro add @studiocms/cfetch
+```
+
+```bash
+yarn astro add @studiocms/cfetch
+```
+
+Or install it **manually**:
+
+1. Install the required dependencies
+
+```bash
+pnpm add @studiocms/cfetch
+```
+
+```bash
+npm install @studiocms/cfetch
+```
+
+```bash
+yarn add @studiocms/cfetch
+```
+
+2. Add the integration to your astro config
+
+```diff
++import cFetch from "@studiocms/cfetch";
+
+export default defineConfig({
+  integrations: [
++    cFetch(),
+  ],
+});
+```
+
+### Usage
+
+You can import the cachedFetch function anywhere you would use a normal `fetch` call. `cfetch` adapts the same default options as fetch,
+
+```astro
+---
+import { cFetch } from 'cached:fetch';
+
+const response = await cFetch(
+    'https://example.com', // string | URL | Request
+    { /* Normal fetch init optional options here, method, mode, etc. */ },
+    { lifetime: "1h" } // Optional, allows changing the default lifetime of the cache
+    );
+
+const html = await response.text();
+---
+```
+
+If you are also wanting the other available metadata (such as `lastChecked` value which is the last time the cache was updated) then you can add the following prop to cached fetch, changing the shape of the data output to the following:
+
+```astro
+---
+import { cFetch } from 'cached:fetch';
+
+const { lastCheck, data: response } = await cFetch(
+    'https://example.com', // string | URL | Request
+    { /* Normal fetch init optional options here, method, mode, etc. */ },
+    { lifetime: "1h" }, // Optional, allows changing the default lifetime of the cache
+    true
+    );
+
+const html = await response.text();
+---
+```
+
+## Licensing
+
+[MIT Licensed](https://github.com/withstudiocms/cfetch/blob/main/LICENSE).

package/dist/cache.d.ts

@@ -0,0 +1,82 @@
+declare module 'virtual:cfetch/config' {
+	/**
+	 * Default configuration for the cache passed from the user.
+	 *
+	 * @property lifetime - Specifies the duration for which the cache is valid.
+	 *                       The format should be a template literal string representing
+	 *                       either minutes (`<number>m`) or hours (`<number>h`).
+	 *                       For example: "5m" for 5 minutes or "2h" for 2 hours.
+	 */
+	const defaultConfig: import('./types').CacheConfig;
+	export default defaultConfig;
+}
+
+declare module 'c:fetch' {
+	/**
+	 * Represents the type of the global `fetch` function.
+	 *
+	 * This type is derived from the built-in `fetch` function, allowing you to
+	 * use it as a reference for type-safe operations involving `fetch`.
+	 */
+	type FetchType = typeof fetch;
+	/**
+	 * Represents the input parameter type for the `FetchType` function.
+	 * This type is derived from the first parameter of the `FetchType` function.
+	 */
+	type Input = Parameters<FetchType>[0];
+	/**
+	 * Represents the `init` parameter of the `fetch` function, which is the second parameter
+	 * in the `FetchType` function signature. This type is used to configure the request,
+	 * including options such as method, headers, body, and other settings.
+	 */
+	type Init = Parameters<FetchType>[1];
+	/**
+	 * Represents the structure of cached data.
+	 *
+	 * @property lastCheck - The date and time when the cache was last checked.
+	 * @property data - The cached response data.
+	 */
+	type CacheDataValue = { lastCheck: Date; data: Response };
+	/**
+	 * Represents the configuration for caching.
+	 *
+	 * @property lifetime - Specifies the duration for which the cache is valid.
+	 *                       The format should be a template literal string representing
+	 *                       either minutes (`<number>m`) or hours (`<number>h`).
+	 *                       For example: "5m" for 5 minutes or "2h" for 2 hours.
+	 */
+	export interface CacheConfig {
+		/**
+		 * Specifies the duration for which the cache is valid.
+		 *     The format should be a template literal string representing
+		 *     either minutes (`<number>m`) or hours (`<number>h`).
+		 *     For example: "5m" for 5 minutes or "2h" for 2 hours.
+		 */
+		lifetime: `${number}m` | `${number}h`;
+	}
+	/**
+	 * Fetches data with caching capabilities. If the data is not present in the cache
+	 * or the cached data is older than the specified lifetime, it fetches new data
+	 * and updates the cache. Otherwise, it returns the cached data.
+	 *
+	 * @param input - The input to the fetch function, typically a URL or Request object.
+	 * @param init - An optional configuration object for the fetch request.
+	 * @param cacheConfig - Partial configuration for the cache behavior. Defaults to `defaultConfig`.
+	 * @param metadata - A boolean indicating whether to return the full cached object (including metadata)
+	 *               or just the data. Defaults to `false`.
+	 * @returns The fetched or cached data. If `full` is `true`, returns an object containing
+	 *          both the data and metadata (e.g., `lastCheck`).
+	 * @throws An error if fetching new data fails and no cached data is available.
+	 */
+	export function cFetch(
+		input: Input,
+		init?: Init,
+		cacheConfig?: Partial<CacheConfig>
+	): Promise<Response>;
+	export function cFetch(
+		input: Input,
+		init?: Init,
+		cacheConfig?: Partial<CacheConfig>,
+		metadata?: boolean
+	): Promise<CacheDataValue>;
+}

package/dist/consts.d.ts

@@ -0,0 +1,8 @@
+import type { CacheConfig } from './types.js';
+/**
+ * Default cache configuration object.
+ *
+ * @property {string} lifetime - The duration for which the cache is valid.
+ *                               Accepts a string representation of time, e.g., '1h' for 1 hour.
+ */
+export declare const defaultConfig: CacheConfig;

package/dist/consts.js

@@ -0,0 +1,6 @@
+const defaultConfig = {
+  lifetime: "1h"
+};
+export {
+  defaultConfig
+};

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="./cache.d.ts" preserve="true" />
+import type { AstroIntegration } from 'astro';
+import type { CacheConfig } from './types.js';
+/**
+ * Astro integration that allows you to have a cached fetch function in your Astro SSR project.
+ *
+ * This integration will add a virtual import for `cached:fetch` that you can use in your components.
+ *
+ * @returns {AstroIntegration} The integration object for Astro
+ * @see {@link https://github.com/withstudiocms/cfetch} for more details
+ * @example
+ * ```typescript
+ * import { defineConfig } from 'astro/config';
+ * import cFetch from '@studiocms/cfetch';
+ *
+ * export default defineConfig({
+ *   integrations: [
+ *     cFetch({
+ * 	     lifetime: '1h', // OPTIONAL Cache lifetime, can be '<number>m' or '<number>h'
+ *     })
+ *   ],
+ * });
+ * ```
+ *
+ * then in your components you can use:
+ *
+ * ```typescript
+ * import { cFetch } from 'c:fetch';
+ *
+ * const response = await cFetch('https://example.com/api/data');
+ * const data = await response.json();
+ * // Use the data in your component
+ * ```
+ */
+export declare function astroCache(opts?: CacheConfig): AstroIntegration;
+export default astroCache;

package/dist/index.js

@@ -0,0 +1,29 @@
+import { addVirtualImports, createResolver } from "./utils/integration.js";
+import { defaultConfig } from "./consts.js";
+function astroCache(opts) {
+  const name = "@studiocms/cfetch";
+  const { resolve } = createResolver(import.meta.url);
+  const options = {
+    ...defaultConfig,
+    ...opts
+  };
+  return {
+    name,
+    hooks: {
+      "astro:config:setup": (params) => {
+        addVirtualImports(params, {
+          name,
+          imports: {
+            "virtual:cfetch/config": `export default ${JSON.stringify(options)}`,
+            "c:fetch": `export * from '${resolve("./wrappers.js")}';`
+          }
+        });
+      }
+    }
+  };
+}
+var index_default = astroCache;
+export {
+  astroCache,
+  index_default as default
+};

package/dist/types.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Represents the type of the global `fetch` function.
+ *
+ * This type is derived from the built-in `fetch` function, allowing you to
+ * use it as a reference for type-safe operations involving `fetch`.
+ */
+export type FetchType = typeof fetch;
+/**
+ * Represents the input parameter type for the `FetchType` function.
+ * This type is derived from the first parameter of the `FetchType` function.
+ */
+export type Input = Parameters<FetchType>[0];
+/**
+ * Represents the `init` parameter of the `fetch` function, which is the second parameter
+ * in the `FetchType` function signature. This type is used to configure the request,
+ * including options such as method, headers, body, and other settings.
+ */
+export type Init = Parameters<FetchType>[1];
+/**
+ * Represents the structure of cached data.
+ *
+ * @property lastCheck - The date and time when the cache was last checked.
+ * @property data - The cached response data.
+ */
+export type CacheDataValue = {
+    lastCheck: Date;
+    data: Response;
+};
+/**
+ * Represents the configuration for caching.
+ *
+ * @property lifetime - Specifies the duration for which the cache is valid.
+ *                       The format should be a template literal string representing
+ *                       either minutes (`<number>m`) or hours (`<number>h`).
+ *                       For example: "5m" for 5 minutes or "2h" for 2 hours.
+ */
+export interface CacheConfig {
+    /**
+     * Specifies the duration for which the cache is valid.
+     *     The format should be a template literal string representing
+     *     either minutes (`<number>m`) or hours (`<number>h`).
+     *     For example: "5m" for 5 minutes or "2h" for 2 hours.
+     */
+    lifetime: `${number}m` | `${number}h`;
+}

package/dist/utils/integration.d.ts

@@ -0,0 +1,143 @@
+import type path from 'node:path';
+import type { HookParameters } from 'astro';
+import type { PluginOption } from 'vite';
+export declare const isAbsolute: typeof path.isAbsolute;
+export declare const dirname: typeof path.dirname;
+/**
+ * Resolves a string path, resolving '.' and '.' segments and allowing paths above the root.
+ *
+ * @param path - The path to normalise.
+ * @param allowAboveRoot - Whether to allow the resulting path to be above the root directory.
+ * @returns the normalised path string.
+ */
+export declare function normalizeString(path: string, allowAboveRoot: boolean): string;
+export declare function normalizeWindowsPath(input?: string): string;
+export declare const resolve: typeof path.resolve;
+export type Hooks = Required<Astro.IntegrationHooks>;
+/**
+ * Allows resolving paths relatively to the integration folder easily. Call it like this:
+ *
+ * @param {string} _base - The location you want to create relative references from. `import.meta.url` is usually what you'll want.
+ *
+ * @see https://astro-integration-kit.netlify.app/core/create-resolver/
+ *
+ * @example
+ * ```ts
+ * const { resolve } = createResolver(import.meta.url);
+ * const pluginPath = resolve("./plugin.ts");
+ * ```
+ *
+ * This way, you do not have to add your plugin to your package.json `exports`.
+ */
+export declare const createResolver: (_base: string) => {
+    resolve: (...path: Array<string>) => string;
+};
+/**
+ * A utility to be used on an Astro hook.
+ *
+ * @see defineUtility
+ */
+export type HookUtility<THook extends keyof Hooks, TArgs extends Array<any>, TReturn> = (params: HookParameters<THook>, ...args: TArgs) => TReturn;
+/**
+ * Allows defining a type-safe function requiring all the params of a given hook.
+ * It uses currying to make TypeScript happy.
+ *
+ * @param {string} _hook
+ *
+ * @see https://astro-integration-kit.netlify.app/core/define-utility/
+ *
+ * @example
+ * ```ts
+ * const test = defineUtility("astro:config:setup")((params, foo: boolean) => {
+ *  return "bar";
+ * });
+ * ```
+ */
+export declare const defineUtility: <THook extends keyof Hooks>(_hook: THook) => <TArgs extends Array<any>, T>(fn: HookUtility<THook, TArgs, T>) => HookUtility<THook, TArgs, T>;
+/**
+ * Checks for the existence of a Vite plugin inside the Astro config.
+ *
+ * @param {import("astro").HookParameters<"astro:config:setup">} params
+ * @param {Params} options
+ * @param {string | import("vite").PluginOption} options.plugin
+ *
+ * @see https://astro-integration-kit.netlify.app/utilities/has-vite-plugin/
+ *
+ * @example
+ * ```ts
+ * hasVitePlugin(params, {
+ * 		plugin: "vite-plugin-my-integration",
+ * })
+ * ```
+ */
+export declare const hasVitePlugin: HookUtility<"astro:config:setup", [{
+    plugin: string | PluginOption;
+}], boolean>;
+/**
+ * Adds a [vite plugin](https://vitejs.dev/guide/using-plugins) to the
+ * Astro config.
+ *
+ * @param {import("astro").HookParameters<"astro:config:setup">} params
+ * @param {object} options
+ * @param {import("vite").PluginOption} options.plugin
+ * @param {boolean} [options.warnDuplicated=true]
+ *
+ * @see https://astro-integration-kit.netlify.app/utilities/add-vite-plugin/
+ *
+ * @example
+ * ```ts
+ * addVitePlugin(params, {
+ * 		plugin,
+ * 		warnDuplicated: true,
+ * })
+ * ```
+ */
+export declare const addVitePlugin: HookUtility<"astro:config:setup", [{
+    plugin: PluginOption;
+    warnDuplicated?: boolean;
+}], void>;
+type VirtualImport = {
+    id: string;
+    content: string;
+    context?: 'server' | 'client' | undefined;
+};
+type Imports = Record<string, string> | Array<VirtualImport>;
+/**
+ * Creates a Vite virtual module and updates the Astro config.
+ * Virtual imports are useful for passing things like config options, or data computed within the integration.
+ *
+ * @param {import("astro").HookParameters<"astro:config:setup">} params
+ * @param {object} options
+ * @param {string} options.name
+ * @param {Imports} options.imports
+ *
+ * @see https://astro-integration-kit.netlify.app/utilities/add-virtual-imports/
+ *
+ * @example
+ * ```ts
+ * // my-integration/index.ts
+ * import { addVirtualImports } from "astro-integration-kit";
+ *
+ * addVirtualImports(params, {
+ * 		name: 'my-integration',
+ * 		imports: {
+ * 			'virtual:my-integration/config': `export default ${ JSON.stringify({foo: "bar"}) }`,
+ * 		},
+ *	});
+ * ```
+ *
+ * This is then readable anywhere else in your integration:
+ *
+ * ```ts
+ * // myIntegration/src/component/layout.astro
+ * import config from "virtual:my-integration/config";
+ *
+ * console.log(config.foo) // "bar"
+ * ```
+ */
+export declare const addVirtualImports: HookUtility<"astro:config:setup", [{
+    name: string;
+    imports: Imports;
+    __enableCorePowerDoNotUseOrYouWillBeFired?: boolean;
+}], void>;
+export {};

package/dist/utils/integration.js

@@ -0,0 +1,267 @@
+import { fileURLToPath } from "node:url";
+import { AstroError } from "astro/errors";
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+const isAbsolute = (p) => _IS_ABSOLUTE_RE.test(p);
+const dirname = (p) => {
+  const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+  if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) {
+    segments[0] += "/";
+  }
+  return segments.join("/") || (isAbsolute(p) ? "/" : ".");
+};
+function cwd() {
+  if (typeof process !== "undefined" && typeof process.cwd === "function") {
+    return process.cwd().replace(/\\/g, "/");
+  }
+  return "/";
+}
+function normalizeString(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path.length; ++index) {
+    if (index < path.length) {
+      char = path[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) {
+      } else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+          if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+function normalizeWindowsPath(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const resolve = (...arguments_) => {
+  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+    const path = index >= 0 ? arguments_[index] : cwd();
+    if (!path || path.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+const createResolver = (_base) => {
+  let base = _base;
+  if (base.startsWith("file://")) {
+    base = dirname(fileURLToPath(base));
+  }
+  return {
+    resolve: (...path) => resolve(base, ...path)
+  };
+};
+const defineUtility = (_hook) => (
+  /**
+   * The function itself
+   * @param {Function} fn;
+   */
+  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+  (fn) => fn
+);
+function getPluginNames(plugins) {
+  const names = [];
+  if (plugins) {
+    for (const plugin of plugins) {
+      if (!plugin) continue;
+      if (Array.isArray(plugin)) {
+        names.push(...getPluginNames(plugin));
+        continue;
+      }
+      if (plugin instanceof Promise) {
+        continue;
+      }
+      names.push(plugin.name);
+    }
+  }
+  return names;
+}
+const hasVitePlugin = defineUtility("astro:config:setup")(
+  ({ config }, {
+    plugin
+  }) => {
+    if (!plugin || plugin instanceof Promise) return false;
+    const currentPlugins = new Set(getPluginNames(config?.vite?.plugins));
+    const plugins = /* @__PURE__ */ new Set();
+    if (typeof plugin === "string") {
+      plugins.add(plugin);
+    }
+    if (typeof plugin === "object") {
+      if (Array.isArray(plugin)) {
+        const names = new Set(
+          getPluginNames(plugin)
+        );
+        for (const name of names) plugins.add(name);
+      } else {
+        plugins.add(plugin.name);
+      }
+    }
+    return [...plugins].some((name) => currentPlugins.has(name));
+  }
+);
+const addVitePlugin = defineUtility("astro:config:setup")(
+  (params, {
+    plugin,
+    warnDuplicated = true
+  }) => {
+    const { updateConfig, logger } = params;
+    if (warnDuplicated && hasVitePlugin(params, { plugin })) {
+      logger.warn(
+        `The Vite plugin "${plugin.name}" is already present in your Vite configuration, this plugin may not behave correctly.`
+      );
+    }
+    updateConfig({
+      vite: {
+        plugins: [plugin]
+      }
+    });
+  }
+);
+const incrementPluginName = (name) => {
+  let count = 1;
+  return `${name.replace(/-(\d+)$/, (_, c) => {
+    count = Number.parseInt(c) + 1;
+    return "";
+  })}-${count}`;
+};
+const resolveVirtualModuleId = (id) => {
+  return `\0${id}`;
+};
+const createVirtualModule = (name, _imports, bypassCoreValidation) => {
+  const imports = Array.isArray(_imports) ? _imports : Object.entries(_imports).map(([id, content]) => ({
+    id,
+    content,
+    context: void 0
+  }));
+  const duplicatedImports = {};
+  for (const { id, context } of imports) {
+    duplicatedImports[id] ??= [];
+    duplicatedImports[id]?.push(...context === void 0 ? ["server", "client"] : [context]);
+  }
+  for (const [id, contexts] of Object.entries(duplicatedImports)) {
+    if (contexts.length !== [...new Set(contexts)].length) {
+      throw new AstroError(
+        `Virtual import with id "${id}" has been registered several times with conflicting contexts.`
+      );
+    }
+  }
+  const resolutionMap = Object.fromEntries(
+    imports.map(({ id }) => {
+      if (!bypassCoreValidation && id.startsWith("astro:")) {
+        throw new AstroError(
+          `Virtual import name prefix can't be "astro:" (for "${id}") because it's reserved for Astro core.`
+        );
+      }
+      return [resolveVirtualModuleId(id), id];
+    })
+  );
+  return {
+    name,
+    resolveId(id) {
+      if (imports.find((_import) => _import.id === id)) {
+        return resolveVirtualModuleId(id);
+      }
+      return;
+    },
+    load(id, options) {
+      const resolution = resolutionMap[id];
+      if (resolution) {
+        const context = options?.ssr ? "server" : "client";
+        const data = imports.find(
+          (_import) => _import.id === resolution && (_import.context === void 0 || _import.context === context)
+        );
+        if (data) {
+          return data.content;
+        }
+      }
+      return;
+    }
+  };
+};
+const addVirtualImports = defineUtility("astro:config:setup")(
+  (params, {
+    name,
+    imports,
+    __enableCorePowerDoNotUseOrYouWillBeFired = false
+  }) => {
+    let pluginName = `vite-plugin-${name}`;
+    while (hasVitePlugin(params, { plugin: pluginName }))
+      pluginName = incrementPluginName(pluginName);
+    addVitePlugin(params, {
+      warnDuplicated: false,
+      plugin: createVirtualModule(pluginName, imports, __enableCorePowerDoNotUseOrYouWillBeFired)
+    });
+  }
+);
+export {
+  addVirtualImports,
+  addVitePlugin,
+  createResolver,
+  defineUtility,
+  dirname,
+  hasVitePlugin,
+  isAbsolute,
+  normalizeString,
+  normalizeWindowsPath,
+  resolve
+};

package/dist/utils/isOlderThan.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Determines whether a given date is older than a specified lifetime.
+ *
+ * @param date - The date to compare against the current time.
+ * @param lifetime - The lifetime duration in the format of `${number}m` for minutes
+ *                   or `${number}h` for hours (e.g., "30m" or "2h").
+ * @returns `true` if the given date is older than the specified lifetime, otherwise `false`.
+ */
+export default function isOlderThan(date: Date, lifetime: `${number}m` | `${number}h`): boolean;

package/dist/utils/isOlderThan.js

@@ -0,0 +1,13 @@
+function isOlderThan(date, lifetime) {
+  const now = /* @__PURE__ */ new Date();
+  let milliseconds = 0;
+  if (lifetime.endsWith("m")) {
+    milliseconds = Number.parseInt(lifetime) * 60 * 1e3;
+  } else if (lifetime.endsWith("h")) {
+    milliseconds = Number.parseInt(lifetime) * 60 * 60 * 1e3;
+  }
+  return date < new Date(now.getTime() - milliseconds);
+}
+export {
+  isOlderThan as default
+};

package/dist/wrappers.d.ts

@@ -0,0 +1,8 @@
+import type { CacheConfig, CacheDataValue, Init, Input } from './types.js';
+export type { CacheConfig };
+/**
+ * Exported for tests
+ */
+export declare const cachedData: Map<string, CacheDataValue>;
+export declare function cFetch(input: Input, init?: Init, cacheConfig?: Partial<CacheConfig>): Promise<Response>;
+export declare function cFetch(input: Input, init?: Init, cacheConfig?: Partial<CacheConfig>, metadata?: boolean): Promise<CacheDataValue>;

package/dist/wrappers.js

@@ -0,0 +1,39 @@
+import isOlderThan from "./utils/isOlderThan.js";
+import { defaultConfig as _config } from "./consts.js";
+const defaultConfig = await import("virtual:cfetch/config").then((mod) => {
+  return mod.default;
+}).catch(() => {
+  return _config;
+});
+const cachedData = /* @__PURE__ */ new Map();
+async function cFetch(input, init = void 0, cacheConfig = defaultConfig, metadata = false) {
+  if (init?.method && init.method !== "GET") {
+    console.warn(
+      "Warning: cFetch is designed for GET requests. Using it with other methods will not cache the response."
+    );
+    const newResponse = fetch(input, init);
+    return metadata ? { lastCheck: /* @__PURE__ */ new Date(), data: newResponse } : newResponse;
+  }
+  const { lifetime } = {
+    ...defaultConfig,
+    ...cacheConfig
+  };
+  const storedData = cachedData.get(input.toString());
+  if (!storedData || isOlderThan(storedData.lastCheck, lifetime)) {
+    const newResponse = await fetch(input, init);
+    if (!newResponse.ok) {
+      if (!storedData) {
+        throw new Error("Failed to retrieve cached data, and failed to fetch new data");
+      }
+      return metadata ? storedData : storedData.data;
+    }
+    const newCachedData = { lastCheck: /* @__PURE__ */ new Date(), data: newResponse };
+    cachedData.set(input.toString(), newCachedData);
+    return metadata ? newCachedData : newResponse;
+  }
+  return metadata ? storedData : storedData.data;
+}
+export {
+  cFetch,
+  cachedData
+};

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@studiocms/cfetch",
+  "version": "0.0.1",
+  "description": "Astro integration that allows you to have a cached fetch function in your Astro SSR project.",
+  "license": "MIT",
+  "homepage": "https://studiocms.dev",
+  "sideEffects": false,
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/withstudiocms/cfetch.git",
+    "directory": "packages/cfetch"
+  },
+  "author": {
+    "name": "Adam Matthiesen | Jacob Jenkins | Paul Valladares",
+    "url": "https://studiocms.dev"
+  },
+  "contributors": [
+    "Adammatthiesen",
+    "jdtjenkins",
+    "dreyfus92",
+    "code.spirit"
+  ],
+  "keywords": [
+    "astro",
+    "astrocms",
+    "astrodb",
+    "astrostudio",
+    "astro-integration",
+    "astro-studio",
+    "astro-studiocms",
+    "studiocms",
+    "withastro"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "default": "./dist/types.js"
+    },
+    "./v/types": "./dist/cache.d.ts"
+  },
+  "devDependencies": {
+    "@inox-tools/astro-tests": "^0.5.1",
+    "@types/node": "^22.0.0",
+    "jest-extended": "^4.0.2"
+  },
+  "peerDependencies": {
+    "astro": "^5.5",
+    "vite": "^6.2.0"
+  },
+  "scripts": {
+    "build": "buildkit build 'src/**/*.{ts,astro,css,js}'",
+    "dev": "buildkit dev 'src/**/*.{ts,astro,css,js}'"
+  }
+}