@cwa/nuxt-edge 0.0.0-29696494.72f11a4

package/dist/runtime/resources/resources.js

@@ -0,0 +1,360 @@
+import { computed } from "vue";
+import { CwaResourceApiStatuses, NEW_RESOURCE_IRI } from "../storage/stores/resources/state.js";
+import {
+  CwaResourceTypes,
+  getResourceTypeFromIri
+} from "./resource-utils.js";
+export class Resources {
+  constructor(resourcesStoreDefinition, fetcherStoreDefinition) {
+    this.resourcesStoreDefinition = resourcesStoreDefinition;
+    this.fetcherStoreDefinition = fetcherStoreDefinition;
+    this._resourcesStore = resourcesStoreDefinition.useStore();
+    this._fetcherStore = fetcherStoreDefinition.useStore();
+  }
+  resourcesStoreDefinition;
+  fetcherStoreDefinition;
+  _resourcesStore;
+  _fetcherStore;
+  get currentIds() {
+    return this.resourcesStore.current.currentIds;
+  }
+  isIriPublishableEquivalent(oldIri, newIri) {
+    return this.resourcesStore.isIriPublishableEquivalent(oldIri, newIri);
+  }
+  findAllPublishableIris(iri) {
+    return this.resourcesStore.findAllPublishableIris(iri);
+  }
+  getResource(id) {
+    return computed(() => {
+      return this.resourcesStore.getResource(id);
+    });
+  }
+  getChildIris(iri, addResourceEvent) {
+    return this.resourcesStore.getChildIris(iri, addResourceEvent);
+  }
+  get newResource() {
+    return computed(() => this.resourcesStore.getResource(NEW_RESOURCE_IRI));
+  }
+  getComponentGroupByReference(reference) {
+    const componentGroups = this.resourcesStore.resourcesByType[CwaResourceTypes.COMPONENT_GROUP];
+    return componentGroups.find((componentGroupResource) => {
+      return componentGroupResource.data?.reference === reference;
+    });
+  }
+  get currentResources() {
+    return this.resourcesStore.current.currentIds.reduce((obj, id) => {
+      const idResource = this.getResource(id).value;
+      if (idResource) {
+        obj[id] = idResource;
+      }
+      return obj;
+    }, {});
+  }
+  get displayFetchStatus() {
+    const fetchingToken = this.fetcherStore.primaryFetch.fetchingToken;
+    if (fetchingToken) {
+      const fetchingStatus = this.fetcherStore.fetches[fetchingToken];
+      if (fetchingStatus) {
+        const irisByDepth = fetchingStatus.manifest?.irisByDepth;
+        const pageIri = irisByDepth?.[0] ? this.getPageIriFromDepthGroup(irisByDepth[0]) : this.getPageIriByFetchStatus(fetchingStatus);
+        if (pageIri && this.resourcesStore.current.currentIds.includes(pageIri)) {
+          const pageResource = this.getResource(pageIri).value;
+          if (pageResource?.data && pageResource.apiState.status === CwaResourceApiStatuses.SUCCESS) {
+            const layoutIri = this.getLayoutIriByFetchStatus(fetchingStatus);
+            const layoutReady = !layoutIri || !!this.getResource(layoutIri).value?.data;
+            if (layoutReady) {
+              return fetchingStatus;
+            }
+          }
+        }
+      }
+    }
+    return this.fetcherStore.resolvedSuccessFetchStatus;
+  }
+  get pageLoadResources() {
+    const token = this.fetcherStore.primaryFetch.fetchingToken;
+    if (!token) {
+      return;
+    }
+    const fetchStatus = this.fetcherStore.fetches[token];
+    if (!fetchStatus) {
+      return;
+    }
+    const type = this.getFetchStatusType(fetchStatus);
+    if (!type) {
+      return;
+    }
+    const resources = [
+      this.getLayoutIriByFetchStatus(fetchStatus),
+      this.getPageIriByFetchStatus(fetchStatus)
+    ];
+    if (type === CwaResourceTypes.ROUTE || type === CwaResourceTypes.PAGE_DATA) {
+      resources.push(fetchStatus.path);
+    }
+    if (type === CwaResourceTypes.ROUTE) {
+      const routeResource = this.getResource(fetchStatus.path).value;
+      if (routeResource) {
+        const pageDataIri = routeResource.data?.value?.pageData;
+        if (pageDataIri) {
+          resources.push(pageDataIri);
+        }
+      }
+    }
+    return resources;
+  }
+  get pageLoadProgress() {
+    return computed(() => {
+      const pageLoadResources = this.pageLoadResources;
+      if (!pageLoadResources) {
+        return {
+          resources: [],
+          total: 0,
+          complete: 0,
+          percent: 100
+        };
+      }
+      const total = pageLoadResources.length;
+      let complete = 0;
+      for (const resourceIri of pageLoadResources) {
+        if (!resourceIri) {
+          continue;
+        }
+        const resource = this.getResource(resourceIri).value;
+        if (resource?.apiState.status !== CwaResourceApiStatuses.IN_PROGRESS) {
+          complete++;
+        }
+      }
+      const percent = complete ? Math.round(complete / total * 100) : 0;
+      return {
+        resources: pageLoadResources,
+        total,
+        complete,
+        percent
+      };
+    });
+  }
+  isPageDataResource(iri) {
+    return computed(() => {
+      if (!this.pageData?.value?.data || !iri) {
+        return false;
+      }
+      if (getResourceTypeFromIri(iri) !== CwaResourceTypes.COMPONENT) {
+        return false;
+      }
+      const allIris = this.findAllPublishableIris(iri);
+      for (const iri2 of allIris) {
+        if (Object.values(this.pageData.value.data).includes(iri2)) {
+          return true;
+        }
+      }
+      return false;
+    });
+  }
+  getFetchStatusType(fetchStatus) {
+    if (!fetchStatus) {
+      return;
+    }
+    const type = getResourceTypeFromIri(fetchStatus.path);
+    if (!type) {
+      return;
+    }
+    return type;
+  }
+  getLayoutIriByFetchStatus(fetchStatus) {
+    const irisByDepth = fetchStatus?.manifest?.irisByDepth;
+    const pageIri = irisByDepth?.[0] ? this.getPageIriFromDepthGroup(irisByDepth[0]) : this.getPageIriByFetchStatus(fetchStatus);
+    if (!pageIri) {
+      return;
+    }
+    const pageResource = this.getResource(pageIri).value;
+    return pageResource?.data?.layout;
+  }
+  getPageIriFromDepthGroup(group) {
+    return group.find((iri) => getResourceTypeFromIri(iri) === CwaResourceTypes.PAGE);
+  }
+  getPageDataIriFromDepthGroup(group) {
+    return group.find((iri) => getResourceTypeFromIri(iri) === CwaResourceTypes.PAGE_DATA);
+  }
+  pageIriAtDepth(depth) {
+    return computed(() => {
+      const fetchStatus = this.displayFetchStatus;
+      const irisByDepth = fetchStatus?.manifest?.irisByDepth;
+      if (irisByDepth?.[depth]) {
+        return this.getPageIriFromDepthGroup(irisByDepth[depth]);
+      }
+      if (depth === 0) {
+        return this.getPageIriByFetchStatus(fetchStatus);
+      }
+      return void 0;
+    });
+  }
+  pageDataIriAtDepth(depth) {
+    return computed(() => {
+      const irisByDepth = this.displayFetchStatus?.manifest?.irisByDepth;
+      if (irisByDepth?.[depth]) {
+        return this.getPageDataIriFromDepthGroup(irisByDepth[depth]);
+      }
+      return void 0;
+    });
+  }
+  getPageIriByFetchStatus(fetchStatus) {
+    const type = this.getFetchStatusType(fetchStatus);
+    if (!type) {
+      return;
+    }
+    if (!fetchStatus?.path) {
+      return;
+    }
+    const successResource = this.getResource(fetchStatus.path).value;
+    if (!successResource) {
+      if (type === CwaResourceTypes.PAGE) {
+        return fetchStatus.path;
+      }
+      return;
+    }
+    if (type === CwaResourceTypes.PAGE) {
+      if (!("iri" in successResource.apiState)) {
+        return fetchStatus.path;
+      }
+      return successResource.apiState.responseIri || successResource.apiState.iri || fetchStatus.path;
+    }
+    switch (type) {
+      case CwaResourceTypes.PAGE_DATA: {
+        return successResource.data?.page;
+      }
+      case CwaResourceTypes.ROUTE: {
+        const pageData = successResource.data?.pageData;
+        if (pageData) {
+          const pageDataResource = this.getResource(pageData).value;
+          return pageDataResource?.data?.page;
+        }
+        return successResource.data?.page;
+      }
+    }
+  }
+  get pageDataIri() {
+    return computed(() => {
+      const fetchStatus = this.displayFetchStatus;
+      const type = this.getFetchStatusType(fetchStatus);
+      if (!type) {
+        return;
+      }
+      if (!fetchStatus?.path) {
+        return;
+      }
+      if (type === CwaResourceTypes.PAGE_DATA) {
+        return fetchStatus.path;
+      }
+      const successResource = this.getResource(fetchStatus.path).value;
+      return type === CwaResourceTypes.ROUTE ? successResource?.data?.pageData : void 0;
+    });
+  }
+  get pageData() {
+    if (!this.pageDataIri.value) {
+      return;
+    }
+    return this.getResource(this.pageDataIri.value);
+  }
+  get pageIri() {
+    return computed(() => this.getPageIriByFetchStatus(this.displayFetchStatus));
+  }
+  get page() {
+    if (!this.pageIri.value) {
+      return;
+    }
+    return this.getResource(this.pageIri.value);
+  }
+  get displayPageIri() {
+    return computed(() => {
+      if (this.isDataPage.value) {
+        return this.pageDataIri.value;
+      }
+      return this.pageIri.value;
+    });
+  }
+  get displayPage() {
+    if (!this.displayPageIri.value) {
+      return;
+    }
+    return this.getResource(this.displayPageIri.value);
+  }
+  get layoutIri() {
+    return computed(() => this.getLayoutIriByFetchStatus(this.displayFetchStatus));
+  }
+  get layout() {
+    return computed(() => {
+      const layoutIri = this.layoutIri.value;
+      if (!layoutIri) {
+        return;
+      }
+      return this.getResource(layoutIri).value;
+    });
+  }
+  findPublishedComponentIri(iri) {
+    return computed(() => {
+      return this.resourcesStore.findPublishedComponentIri(iri);
+    });
+  }
+  findDraftComponentIri(iri) {
+    return computed(() => {
+      return this.resourcesStore.findDraftComponentIri(iri);
+    });
+  }
+  get getOrderedPositionsForGroup() {
+    return this.resourcesStore.getOrderedPositionsForGroup;
+  }
+  get getPositionSortDisplayNumber() {
+    return this.resourcesStore.getPositionSortDisplayNumber;
+  }
+  getRefreshEndpointsForDelete(iri) {
+    const refreshEndpoints = [];
+    if (this.pageDataIri.value) {
+      refreshEndpoints.push(this.pageDataIri.value);
+    }
+    const allIris = this.resourcesStore.findAllPublishableIris(iri);
+    for (const checkIri of allIris) {
+      const componentPositions = this.resourcesStore.current.positionsByComponent[checkIri];
+      if (!componentPositions) {
+        continue;
+      }
+      refreshEndpoints.push(...componentPositions);
+      for (const posIri of componentPositions) {
+        const positionResource = this.getResource(posIri).value;
+        if (positionResource?.data?.componentGroup) {
+          refreshEndpoints.push(positionResource.data.componentGroup);
+        }
+      }
+    }
+    return refreshEndpoints;
+  }
+  get isLoading() {
+    return computed(() => {
+      return !this.fetcherStore.fetchesResolved || !!this.resourceLoadStatus.pending;
+    });
+  }
+  get resourceLoadStatus() {
+    return this.resourcesStore.resourceLoadStatus;
+  }
+  get fetcherStore() {
+    return this._fetcherStore;
+  }
+  get resourcesStore() {
+    return this._resourcesStore;
+  }
+  get usesPageTemplate() {
+    return computed(() => !!this.page?.value?.data?.isTemplate);
+  }
+  get isDataPage() {
+    return computed(() => {
+      return this.usesPageTemplate.value && !!this.pageDataIri.value;
+    });
+  }
+  get isDynamicPage() {
+    return computed(() => {
+      return this.usesPageTemplate.value && !this.pageDataIri.value;
+    });
+  }
+  get hasNewResources() {
+    return this.resourcesStore.hasNewResources;
+  }
+}

package/dist/runtime/route-middleware.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").RouteMiddleware;
+export default _default;

package/dist/runtime/route-middleware.js

@@ -0,0 +1,71 @@
+import { v4 as uuidv4 } from "uuid";
+import { consola as logger } from "consola";
+import {
+  abortNavigation,
+  defineNuxtRouteMiddleware,
+  navigateTo,
+  useNuxtApp
+} from "nuxt/app";
+import { useProcess } from "#cwa/composables/process";
+let middlewareToken = "";
+export default defineNuxtRouteMiddleware(async (to, from) => {
+  const { isClient } = useProcess();
+  middlewareToken = uuidv4();
+  const nuxtApp = useNuxtApp();
+  const adminRouteGuard = nuxtApp.$cwa.adminNavigationGuardFn(to);
+  if (adminRouteGuard === false) {
+    return abortNavigation();
+  }
+  const discardAddingSuccess = await nuxtApp.$cwa.resourcesManager.confirmDiscardAddingResource();
+  if (!discardAddingSuccess) {
+    return abortNavigation();
+  }
+  if (adminRouteGuard !== true) {
+    return navigateTo(adminRouteGuard);
+  }
+  if (isClient) {
+    await nuxtApp.$cwa.initClientSide();
+  }
+  if (to.meta.cwa?.disabled === true) {
+    nuxtApp.$cwa.clearPrimaryFetch();
+    return;
+  }
+  const waitForMiddleware = () => {
+    return new Promise((resolve) => {
+      const checkInterval = setInterval(() => {
+        if (nuxtApp._processingMiddleware === void 0) {
+          resolve(true);
+          clearInterval(checkInterval);
+        }
+      }, 10);
+    });
+  };
+  const handleRouteRedirect = async (resource) => {
+    if (resource?.redirectPath) {
+      if (isClient && nuxtApp._processingMiddleware) {
+        await waitForMiddleware();
+      }
+      logger.info(`Handling route redirect to: '${resource.redirectPath}'`);
+      return navigateTo(resource.redirectPath, { redirectCode: 308 });
+    }
+  };
+  if (!isClient) {
+    nuxtApp.$cwa.siteConfig.loadConfig();
+    const resource = await nuxtApp.$cwa.fetchRoute(to);
+    return handleRouteRedirect(resource);
+  }
+  const isFirstClientSideRun = nuxtApp.isHydrating && nuxtApp.payload.serverRendered;
+  if (isFirstClientSideRun && from.fullPath === to.fullPath) {
+    return;
+  }
+  const startedMiddlewareToken = middlewareToken;
+  nuxtApp.$cwa.fetchRoute(to).then(async (resource) => {
+    if (startedMiddlewareToken !== middlewareToken && resource?.redirectPath) {
+      return;
+    }
+    const response = await handleRouteRedirect(resource);
+    if (response) {
+      logger.info("Redirect handler failed", response);
+    }
+  });
+});

package/dist/runtime/server/cwa-custom-sitemap.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string>>;
+export default _default;

package/dist/runtime/server/cwa-custom-sitemap.get.js

@@ -0,0 +1,29 @@
+import { defaultContentType, defineEventHandler } from "h3";
+import { consola } from "consola";
+import useFetcher from "#cwa/server/useFetcher";
+import useCwaSiteConfig from "#cwa/composables/useCwaSiteConfig";
+import { createError } from "#imports";
+export default defineEventHandler(async (event) => {
+  const { fetcher, options } = useFetcher();
+  const { mergeConfig, responseToConfig } = useCwaSiteConfig();
+  try {
+    const data = await fetcher("/_/site_config_parameters", {
+      credentials: "omit"
+    });
+    const resolvedConfig = mergeConfig(options.siteConfig, responseToConfig(data, true));
+    defaultContentType(event, "application/xml");
+    const sitemapXml = resolvedConfig.sitemapXml;
+    if (!sitemapXml || sitemapXml === "") {
+      return `<?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet type="text/xsl" href="/__sitemap__/style.xsl"?>
+<urlset xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:video="http://www.google.com/schemas/sitemap-video/1.1" xmlns:xhtml="http://www.w3.org/1999/xhtml" xmlns:image="http://www.google.com/schemas/sitemap-image/1.1" xmlns:news="http://www.google.com/schemas/sitemap-news/0.9" xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9 http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd http://www.google.com/schemas/sitemap-image/1.1 http://www.google.com/schemas/sitemap-image/1.1/sitemap-image.xsd" xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+</urlset>`;
+    }
+    return sitemapXml;
+  } catch (e) {
+    consola.error(e);
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Server error"
+    });
+  }
+});

package/dist/runtime/server/cwa-healthcheck.get.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, {
+    status: string;
+}>;
+export default _default;

package/dist/runtime/server/cwa-healthcheck.get.js

@@ -0,0 +1,10 @@
+import { defineEventHandler, setResponseHeaders } from "h3";
+export default defineEventHandler((event) => {
+  setResponseHeaders(event, {
+    "cache-control": "no-cache",
+    "x-robots-tag": "noindex, nofollow"
+  });
+  return {
+    status: "OK"
+  };
+});

package/dist/runtime/server/cwa-urls.get.d.ts

@@ -0,0 +1,3 @@
+import type { SitemapUrlInput } from '#sitemap/types';
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, import("h3").EventHandlerResponse<SitemapUrlInput[]>>;
+export default _default;

package/dist/runtime/server/cwa-urls.get.js

@@ -0,0 +1,15 @@
+import { defineSitemapEventHandler } from "#sitemap/server/composables/defineSitemapEventHandler";
+import useFetcher, { resolveConfigEventHandler } from "./useFetcher.js";
+export default defineSitemapEventHandler(async (e) => {
+  const resolvedConfig = await resolveConfigEventHandler(e);
+  if (!resolvedConfig || !resolvedConfig.sitemapEnabled) {
+    return [];
+  }
+  const { fetcher } = useFetcher();
+  const data = await fetcher("/_/routes?pagination=false");
+  return data["member"].map((r) => {
+    return {
+      loc: r.path
+    };
+  });
+});

package/dist/runtime/server/server-middleware.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;
+export default _default;

package/dist/runtime/server/server-middleware.js

@@ -0,0 +1,63 @@
+import { defineEventHandler, parseCookies, getRequestURL, createError } from "h3";
+import { jwtDecode } from "jwt-decode";
+import useCwaSiteConfig from "#cwa/composables/useCwaSiteConfig";
+import { updateSiteConfig } from "#site-config/server/composables";
+import { resolveConfigEventHandler } from "#cwa/server/useFetcher";
+export default defineEventHandler(async (e) => {
+  const skipMaintenanceChecks = () => {
+    if (e.context.skipMaintenanceChecks === true) return true;
+    const allowedPaths = ["/sitemap.xml", "/sitemap_index.xml", "/robots.txt"];
+    if (allowedPaths.includes(e.path)) return true;
+    const allowedRegex = [new RegExp("^/__sitemap__/.+")];
+    for (const re of allowedRegex) {
+      const match = e.path.match(re);
+      if (match) return true;
+    }
+    return false;
+  };
+  const resolvedConfig = await resolveConfigEventHandler(e);
+  if (resolvedConfig) {
+    const { resolvedConfigToSiteConfig } = useCwaSiteConfig();
+    updateSiteConfig(e, resolvedConfigToSiteConfig(resolvedConfig));
+    if (skipMaintenanceChecks()) return;
+    if (resolvedConfig.maintenanceModeEnabled) {
+      const isUserAllowedToBypassMaintenance = () => {
+        const cookies = parseCookies(e);
+        if (cookies.cwa_auth !== "1" || !cookies.api_component) {
+          return false;
+        }
+        try {
+          const decoded = jwtDecode(cookies.api_component);
+          if (!decoded.roles || !Array.isArray(decoded.roles)) {
+            return false;
+          }
+          const includesAny = (arr, values) => values.some((v) => arr.includes(v));
+          if (!includesAny(decoded.roles, ["ROLE_ADMIN", "ROLE_SUPER_ADMIN"])) {
+            return false;
+          }
+          if (!decoded.exp) {
+            return false;
+          }
+          const expiry = new Date(decoded.exp * 1e3);
+          const expired = (/* @__PURE__ */ new Date()).getTime() >= expiry.getTime();
+          return !expired;
+        } catch (e2) {
+          return false;
+        }
+      };
+      if (isUserAllowedToBypassMaintenance()) {
+        return;
+      }
+      const url = getRequestURL(e);
+      const allowedPaths2 = ["/__nuxt_error", "/login"];
+      if (!allowedPaths2.includes(url.pathname) && !url.pathname.startsWith("/_cwa")) {
+        const maintenanceError = createError({
+          statusCode: 503,
+          statusMessage: "Website under maintenance"
+        });
+        maintenanceError.message = "We will be back up and running as soon as possible";
+        throw maintenanceError;
+      }
+    }
+  }
+});

package/dist/runtime/server/server-plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nitropack/types").NitroAppPlugin;
+export default _default;

package/dist/runtime/server/server-plugin.js

@@ -0,0 +1,59 @@
+import { parseRobotsTxt, NonHelpfulBots, AiBots } from "#robots/util";
+import { resolveConfigEventHandler } from "#cwa/server/useFetcher";
+import { defineNitroPlugin } from "nitropack/runtime";
+export default defineNitroPlugin(async (nitroApp) => {
+  nitroApp.hooks.hook("beforeResponse", (event) => {
+    const response = event.node.res;
+    if (!response) return;
+    if (response.hasHeader("set-cookie")) {
+      response.removeHeader("set-cookie");
+    }
+  });
+  nitroApp.hooks.hook("sitemap:index-resolved", async (ctx) => {
+    const resolvedConfig = await resolveConfigEventHandler(ctx.event);
+    if (!resolvedConfig || !resolvedConfig.sitemapXml || resolvedConfig.sitemapXml === "") {
+      return;
+    }
+    ctx.sitemaps.push({
+      _sitemapName: "cwa-custom",
+      sitemap: "/__sitemap__/cwa-custom.xml"
+    });
+  });
+  nitroApp.hooks.hook("robots:config", async (ctx) => {
+    const resolvedConfig = await resolveConfigEventHandler();
+    if (!resolvedConfig) {
+      return;
+    }
+    ctx.groups.push({
+      userAgent: ["*"],
+      comment: ["Block all from operational endpoints"],
+      allow: [],
+      disallow: ["/_cwa/*"]
+      // _api was disallowed but is needed when client only '/_api/*',
+    });
+    if (!resolvedConfig.robotsAllowNonSeoCrawlers) {
+      ctx.groups.push({
+        userAgent: NonHelpfulBots,
+        comment: ["Block non helpful bots"],
+        allow: [],
+        disallow: ["/"]
+      });
+    }
+    if (!resolvedConfig.robotsAllowAiBots) {
+      ctx.groups.push({
+        userAgent: AiBots,
+        comment: ["Block AI crawlers"],
+        allow: [],
+        disallow: ["/"]
+      });
+    }
+    if (resolvedConfig.robotsRemoveSitemap) {
+      ctx.sitemaps = [];
+    }
+    if (resolvedConfig.robotsText && resolvedConfig.robotsText !== "") {
+      const parsedRobotsTxt = parseRobotsTxt(resolvedConfig.robotsText);
+      ctx.groups.push(...parsedRobotsTxt.groups);
+      ctx.sitemaps.push(...parsedRobotsTxt.sitemaps);
+    }
+  });
+});

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json",
+}

package/dist/runtime/server/useFetcher.d.ts

@@ -0,0 +1,7 @@
+import type { H3Event } from 'h3';
+export declare const useFetcher: () => {
+    fetcher: import("ofetch").$Fetch;
+    options: any;
+};
+export declare const resolveConfigEventHandler: (e?: H3Event) => Promise<any>;
+export default useFetcher;