@studiocms/cfetch 0.2.1 → 0.3.0

package/dist/{stub.js → stub.mjs}

@@ -1,19 +1,39 @@
-import { createResolver } from "./utils/integration.js";
+import { createResolver } from "./utils/integration.mjs";
+
+//#region src/stub.ts
+/**
+* This file serves as a stub for TypeScript type definitions related to the cFetch integration.
+* It defines the structure of virtual modules and the types that will be injected into the consuming project.
+* The actual implementation of these types is provided in the corresponding .mjs files, but this stub allows
+* for proper type checking and IntelliSense in development environments.
+*
+* The stub includes module declarations for 'virtual:cfetch/config' and 'c:fetch', defining the expected types
+* and exports that will be available when using the cFetch integration in an Astro project.
+*
+* @remarks
+* - The 'virtual:cfetch/config' module provides access to the cache configuration, which can be customized by users.
+* - The 'c:fetch' module exports various types and functions related to the cached fetch functionality, including error types, parsers, and the main cFetch function.
+*
+* @module
+*/
 const { resolve } = createResolver(import.meta.url);
+/**
+* Stub content for TypeScript type definitions related to the cFetch integration.
+*/
 const stub = `
 declare module 'virtual:cfetch/config' {
-	type CacheConfig = import("${resolve("./types.js")}").CacheConfigLive;
+	type CacheConfig = import("${resolve("./types.mjs")}").CacheConfigLive;
 	const defaultConfig: CacheConfig;
 	export default defaultConfig;
 }
 
 declare module 'c:fetch' {
-	export type CacheConfig = import("${resolve("./types.js")}").CacheConfig;
-	export type CachedResponse<T> = import("${resolve("./wrappers.js")}").CachedResponse<T>;
-	export type CFetchConfig = import("${resolve("./wrappers.js")}").CFetchConfig;
+	export type CacheConfig = import("${resolve("./types.mjs")}").CacheConfig;
+	export type CachedResponse<T> = import("${resolve("./wrappers.mjs")}").CachedResponse<T>;
+	export type CFetchConfig = import("${resolve("./wrappers.mjs")}").CFetchConfig;
+	export type InvalidateCacheOptions = import("${resolve("./wrappers.mjs")}").InvalidateCacheOptions;
 	
-	export const Duration: typeof import("${resolve("./wrappers.js")}").Duration;
-
+	export const Duration: typeof import("${resolve("./wrappers.mjs")}").Duration;
 	declare const FetchError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
 		readonly _tag: "FetchError";
 	} & Readonly<A>;
@@ -34,7 +54,7 @@ declare module 'c:fetch' {
 	 * @param _ - The Response object (ignored)
 	 * @returns A Promise that resolves to undefined
 	 */
-	export const noOpParser: typeof import("${resolve("./wrappers.js")}").noOpParser;
+	export const noOpParser: typeof import("${resolve("./wrappers.mjs")}").noOpParser;
 
 	/**
 	 * Fetches data from a URL with caching capabilities using Effect.
@@ -63,7 +83,26 @@ declare module 'c:fetch' {
 	 * - Cache hits are logged to console for debugging
 	 * - The effect is provided with CacheLive layer automatically
 	 */
-	export const cFetchEffect: typeof import("${resolve("./wrappers.js")}").cFetchEffect;
+	export const cFetchEffect: typeof import("${resolve("./wrappers.mjs")}").cFetchEffect;
+
+	/**
+	 * Invalidates cache entries based on specified keys or tags.
+	 *
+	 * @param opts - An object containing optional keys and tags for cache invalidation
+	 * @param opts.keys - An array of specific cache keys to invalidate
+	 * @param opts.tags - An array of tags; all cache entries associated with these tags will be invalidated
+	 *
+	 * @returns An Effect that performs the cache invalidation when executed
+	 *
+	 * @example
+	 * \`\`\`typescript
+	 * yield* invalidateCacheEffect({
+	 *   tags: ['user'],
+	 *   keys: ['user:123', 'user:456']
+	 * });
+	 * \`\`\`
+	 */
+	export const invalidateCacheEffect: typeof import("${resolve("./wrappers.mjs")}").invalidateCacheEffect;
 
 	/**
 	 * Creates an Effect that fetches JSON data from a URL with caching support.
@@ -77,7 +116,7 @@ declare module 'c:fetch' {
 	 * @param cacheConfig.key - Custom cache key to use instead of the default URL-based key
 	 * @returns An Effect that yields a CachedResponse containing the parsed JSON data, or fails with a FetchError
 	 */
-	export const cFetchEffectJson: typeof import("${resolve("./wrappers.js")}").cFetchEffectJson;
+	export const cFetchEffectJson: typeof import("${resolve("./wrappers.mjs")}").cFetchEffectJson;
 
 
 	/**
@@ -93,7 +132,7 @@ declare module 'c:fetch' {
 	 * @returns An Effect that resolves to a CachedResponse containing the response text,
 	 *          or fails with a FetchError if the request fails.
 	 */
-	export const cFetchEffectText: typeof import("${resolve("./wrappers.js")}").cFetchEffectText;
+	export const cFetchEffectText: typeof import("${resolve("./wrappers.mjs")}").cFetchEffectText;
 
 	/**
 	 * Fetches a resource and returns it as a Blob with caching support.
@@ -107,7 +146,7 @@ declare module 'c:fetch' {
 	 * 
 	 * @returns An Effect that resolves to a CachedResponse containing a Blob, or fails with a FetchError
 	 */
-	export const cFetchEffectBlob: typeof import("${resolve("./wrappers.js")}").cFetchEffectBlob;
+	export const cFetchEffectBlob: typeof import("${resolve("./wrappers.mjs")}").cFetchEffectBlob;
 
 	/**
 	 * Executes a cached fetch request with configurable caching behavior.
@@ -122,7 +161,7 @@ declare module 'c:fetch' {
 	 * @param cacheConfig.key - Custom cache key; if not provided, a key will be generated from the URL and options
 	 * @returns A Promise that resolves to a CachedResponse containing the parsed data
 	 */
-	export const cFetch: typeof import("${resolve("./wrappers.js")}").cFetch;
+	export const cFetch: typeof import("${resolve("./wrappers.mjs")}").cFetch;
 
 	/**
 	 * Fetches and parses JSON data from the specified URL with caching support.
@@ -136,7 +175,7 @@ declare module 'c:fetch' {
 	 * @param cacheConfig.key - Custom cache key to use instead of the default
 	 * @returns A Promise that resolves to a CachedResponse containing the parsed JSON data of type T
 	 */
-	export const cFetchJson: typeof import("${resolve("./wrappers.js")}").cFetchJson;
+	export const cFetchJson: typeof import("${resolve("./wrappers.mjs")}").cFetchJson;
 
 	/**
 	 * Fetches a URL and returns the response as text with caching support.
@@ -149,7 +188,7 @@ declare module 'c:fetch' {
 	 * @param cacheConfig.key - Custom cache key (defaults to URL if not provided)
 	 * @returns A promise that resolves to a CachedResponse containing the response text
 	 */
-	export const cFetchText: typeof import("${resolve("./wrappers.js")}").cFetchText;
+	export const cFetchText: typeof import("${resolve("./wrappers.mjs")}").cFetchText;
 
 	/**
 	 * Fetches a Blob resource from the specified URL with optional caching configuration.
@@ -162,11 +201,30 @@ declare module 'c:fetch' {
 	 * @param cacheConfig.key - Custom cache key for storing the response
 	 * @returns A Promise that resolves to a CachedResponse containing a Blob
 	 */
-	export const cFetchBlob: typeof import("${resolve("./wrappers.js")}").cFetchBlob;
+	export const cFetchBlob: typeof import("${resolve("./wrappers.mjs")}").cFetchBlob;
+
+	/**
+	 * Invalidates cache entries based on specified keys or tags.
+	 *
+	 * @param opts - An object containing optional keys and tags for cache invalidation
+	 * @param opts.keys - An array of specific cache keys to invalidate
+	 * @param opts.tags - An array of tags; all cache entries associated with these tags will be invalidated
+	 *
+	 * @returns A Promise that resolves when the cache invalidation is complete
+	 *
+	 * @example
+	 * \`\`\`typescript
+	 * await invalidateCache({
+	 *   tags: ['user'],
+	 *   keys: ['user:123', 'user:456']
+	 * });
+	 * \`\`\`
+	 */
+	export const invalidateCache: typeof import("${resolve("./wrappers.mjs")}").invalidateCache;
 }
 
 `;
 var stub_default = stub;
-export {
-  stub_default as default
-};
+
+//#endregion
+export { stub_default as default };

package/dist/{types.d.ts → types.d.mts}

@@ -1,4 +1,6 @@
-import type { Duration } from 'effect';
+import { Duration } from "effect";
+
+//#region src/types.d.ts
 /**
  * Configuration options for caching behavior.
  *
@@ -12,8 +14,8 @@ import type { Duration } from 'effect';
  * };
  * ```
  */
-export type CacheConfig = {
-    lifetime: Duration.DurationInput;
+type CacheConfig = {
+  lifetime: Duration.DurationInput;
 };
 /**
  * Configuration options for cache lifetime management.
@@ -29,6 +31,8 @@ export type CacheConfig = {
  * };
  * ```
  */
-export type CacheConfigLive = {
-    lifetime: number;
+type CacheConfigLive = {
+  lifetime: number;
 };
+//#endregion
+export { CacheConfig, CacheConfigLive };

package/dist/types.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/utils/{integration.d.ts → integration.d.mts}

@@ -1,23 +1,21 @@
-/**
- * This module contains Astro Integration Utilities
- * @module
- */
-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;
+import { HookParameters } from "astro";
+import path from "node:path";
+import { PluginOption } from "vite";
+
+//#region src/utils/integration.d.ts
+declare const isAbsolute: typeof path.isAbsolute;
+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 path - The path to normalize.
  * @param allowAboveRoot - Whether to allow the resulting path to be above the root directory.
- * @returns the normalised path string.
+ * @returns the normalized 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>;
+declare function normalizeString(path: string, allowAboveRoot: boolean): string;
+declare function normalizeWindowsPath(input?: string): string;
+declare const resolve: typeof path.resolve;
+type Hooks = Required<Astro.IntegrationHooks>;
 /**
  * Allows resolving paths relatively to the integration folder easily. Call it like this:
  *
@@ -33,15 +31,15 @@ export type Hooks = Required<Astro.IntegrationHooks>;
  *
  * 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;
+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;
+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.
@@ -57,7 +55,7 @@ export type HookUtility<THook extends keyof Hooks, TArgs extends Array<any>, TRe
  * });
  * ```
  */
-export declare const defineUtility: <THook extends keyof Hooks>(_hook: THook) => <TArgs extends Array<any>, T>(fn: HookUtility<THook, TArgs, T>) => HookUtility<THook, TArgs, T>;
+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.
  *
@@ -74,8 +72,8 @@ export declare const defineUtility: <THook extends keyof Hooks>(_hook: THook) =>
  * })
  * ```
  */
-export declare const hasVitePlugin: HookUtility<"astro:config:setup", [{
-    plugin: string | PluginOption;
+declare const hasVitePlugin: HookUtility<"astro:config:setup", [{
+  plugin: string | PluginOption;
 }], boolean>;
 /**
  * Adds a [vite plugin](https://vitejs.dev/guide/using-plugins) to the
@@ -96,14 +94,14 @@ export declare const hasVitePlugin: HookUtility<"astro:config:setup", [{
  * })
  * ```
  */
-export declare const addVitePlugin: HookUtility<"astro:config:setup", [{
-    plugin: PluginOption;
-    warnDuplicated?: boolean;
+declare const addVitePlugin: HookUtility<"astro:config:setup", [{
+  plugin: PluginOption;
+  warnDuplicated?: boolean;
 }], void>;
 type VirtualImport = {
-    id: string;
-    content: string;
-    context?: 'server' | 'client' | undefined;
+  id: string;
+  content: string;
+  context?: 'server' | 'client' | undefined;
 };
 type Imports = Record<string, string> | Array<VirtualImport>;
 /**
@@ -139,9 +137,10 @@ type Imports = Record<string, string> | Array<VirtualImport>;
  * console.log(config.foo) // "bar"
  * ```
  */
-export declare const addVirtualImports: HookUtility<"astro:config:setup", [{
-    name: string;
-    imports: Imports;
-    __enableCorePowerDoNotUseOrYouWillBeFired?: boolean;
+declare const addVirtualImports: HookUtility<"astro:config:setup", [{
+  name: string;
+  imports: Imports;
+  __enableCorePowerDoNotUseOrYouWillBeFired?: boolean;
 }], void>;
-export {};
+//#endregion
+export { HookUtility, Hooks, addVirtualImports, addVitePlugin, createResolver, defineUtility, dirname, hasVitePlugin, isAbsolute, normalizeString, normalizeWindowsPath, resolve };

package/dist/utils/integration.mjs

@@ -0,0 +1,276 @@
+import { fileURLToPath } from "node:url";
+
+//#region src/utils/integration.ts
+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 "/";
+}
+/**
+* Resolves a string path, resolving '.' and '.' segments and allowing paths above the root.
+*
+* @param path - The path to normalize.
+* @param allowAboveRoot - Whether to allow the resulting path to be above the root directory.
+* @returns the normalized path string.
+*/
+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 : ".";
+};
+/**
+* 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`.
+*/
+const createResolver = (_base) => {
+	let base = _base;
+	if (base.startsWith("file://")) base = dirname(fileURLToPath(base));
+	return { resolve: (...path) => resolve(base, ...path) };
+};
+/**
+* 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";
+* });
+* ```
+*/
+const defineUtility = (_hook) => (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;
+}
+/**
+* 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",
+* })
+* ```
+*/
+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));
+});
+/**
+* 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,
+* })
+* ```
+*/
+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 Error(`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 Error(`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);
+		},
+		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;
+			}
+		}
+	};
+};
+/**
+* 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"
+* ```
+*/
+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)
+	});
+});
+
+//#endregion
+export { addVirtualImports, addVitePlugin, createResolver, defineUtility, dirname, hasVitePlugin, isAbsolute, normalizeString, normalizeWindowsPath, resolve };