comclib
c02029a5f3
- Spring Boot 后端服务 (hss-home-service) - delivery-miniapp 配送小程序 - website 官网 (Nuxt) - docs 架构设计文档 - Docker 容器化部署配置 Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
1670 lines
59 KiB
JavaScript
1670 lines
59 KiB
JavaScript
import { shallowReactive, reactive, effectScope, getCurrentScope, hasInjectionContext, getCurrentInstance, inject, toRef, shallowRef, isReadonly, isRef, isShallow, isReactive, toRaw, defineComponent, h, resolveComponent, computed, unref, ref, mergeProps, withCtx, createVNode, createTextVNode, toDisplayString, useSSRContext, provide, Suspense, Fragment, defineAsyncComponent, onErrorCaptured, onServerPrefetch, resolveDynamicComponent, createApp } from "vue";
|
||
import { $fetch as $fetch$1 } from "/home/akoo/居家服务/hss-home-service/website/node_modules/ofetch/dist/node.mjs";
|
||
import { baseURL } from "#internal/nuxt/paths";
|
||
import { createHooks } from "/home/akoo/居家服务/hss-home-service/website/node_modules/hookable/dist/index.mjs";
|
||
import { getContext, executeAsync } from "/home/akoo/居家服务/hss-home-service/website/node_modules/unctx/dist/index.mjs";
|
||
import { sanitizeStatusCode, createError as createError$1, appendHeader } from "/home/akoo/居家服务/hss-home-service/website/node_modules/h3/dist/index.mjs";
|
||
import { START_LOCATION, createMemoryHistory, createRouter, RouterView } from "vue-router";
|
||
import { defu } from "/home/akoo/居家服务/hss-home-service/website/node_modules/defu/dist/defu.mjs";
|
||
import { hasProtocol, joinURL, parseURL, encodePath, decodePath, withQuery, isScriptProtocol, parseQuery, withTrailingSlash, withoutTrailingSlash } from "/home/akoo/居家服务/hss-home-service/website/node_modules/ufo/dist/index.mjs";
|
||
import { ssrRenderAttrs, ssrRenderComponent, ssrInterpolate, ssrRenderList, ssrRenderAttr, ssrRenderSuspense, ssrRenderVNode } from "vue/server-renderer";
|
||
if (!globalThis.$fetch) {
|
||
globalThis.$fetch = $fetch$1.create({
|
||
baseURL: baseURL()
|
||
});
|
||
}
|
||
if (!("global" in globalThis)) {
|
||
globalThis.global = globalThis;
|
||
}
|
||
const nuxtLinkDefaults = { "componentName": "NuxtLink" };
|
||
const appId = "nuxt-app";
|
||
const crawlLinks = true;
|
||
function getNuxtAppCtx(id = appId) {
|
||
return getContext(id, {
|
||
asyncContext: false
|
||
});
|
||
}
|
||
const NuxtPluginIndicator = "__nuxt_plugin";
|
||
function createNuxtApp(options) {
|
||
let hydratingCount = 0;
|
||
const nuxtApp = {
|
||
_id: options.id || appId || "nuxt-app",
|
||
_scope: effectScope(),
|
||
provide: void 0,
|
||
globalName: "nuxt",
|
||
versions: {
|
||
get nuxt() {
|
||
return "3.21.5";
|
||
},
|
||
get vue() {
|
||
return nuxtApp.vueApp.version;
|
||
}
|
||
},
|
||
payload: shallowReactive({
|
||
...options.ssrContext?.payload || {},
|
||
data: shallowReactive({}),
|
||
state: reactive({}),
|
||
once: /* @__PURE__ */ new Set(),
|
||
_errors: shallowReactive({})
|
||
}),
|
||
static: {
|
||
data: {}
|
||
},
|
||
runWithContext(fn) {
|
||
if (nuxtApp._scope.active && !getCurrentScope()) {
|
||
return nuxtApp._scope.run(() => callWithNuxt(nuxtApp, fn));
|
||
}
|
||
return callWithNuxt(nuxtApp, fn);
|
||
},
|
||
isHydrating: false,
|
||
deferHydration() {
|
||
if (!nuxtApp.isHydrating) {
|
||
return () => {
|
||
};
|
||
}
|
||
hydratingCount++;
|
||
let called = false;
|
||
return () => {
|
||
if (called) {
|
||
return;
|
||
}
|
||
called = true;
|
||
hydratingCount--;
|
||
if (hydratingCount === 0) {
|
||
nuxtApp.isHydrating = false;
|
||
return nuxtApp.callHook("app:suspense:resolve");
|
||
}
|
||
};
|
||
},
|
||
_asyncDataPromises: {},
|
||
_asyncData: shallowReactive({}),
|
||
_payloadRevivers: {},
|
||
...options
|
||
};
|
||
{
|
||
nuxtApp.payload.serverRendered = true;
|
||
}
|
||
if (nuxtApp.ssrContext) {
|
||
nuxtApp.payload.path = nuxtApp.ssrContext.url;
|
||
nuxtApp.ssrContext.nuxt = nuxtApp;
|
||
nuxtApp.ssrContext.payload = nuxtApp.payload;
|
||
nuxtApp.ssrContext.config = {
|
||
public: nuxtApp.ssrContext.runtimeConfig.public,
|
||
app: nuxtApp.ssrContext.runtimeConfig.app
|
||
};
|
||
}
|
||
nuxtApp.hooks = createHooks();
|
||
nuxtApp.hook = nuxtApp.hooks.hook;
|
||
{
|
||
const contextCaller = async function(hooks, args) {
|
||
for (const hook of hooks) {
|
||
await nuxtApp.runWithContext(() => hook(...args));
|
||
}
|
||
};
|
||
nuxtApp.hooks.callHook = (name, ...args) => nuxtApp.hooks.callHookWith(contextCaller, name, ...args);
|
||
}
|
||
nuxtApp.callHook = nuxtApp.hooks.callHook;
|
||
nuxtApp.provide = (name, value) => {
|
||
const $name = "$" + name;
|
||
defineGetter(nuxtApp, $name, value);
|
||
defineGetter(nuxtApp.vueApp.config.globalProperties, $name, value);
|
||
};
|
||
defineGetter(nuxtApp.vueApp, "$nuxt", nuxtApp);
|
||
defineGetter(nuxtApp.vueApp.config.globalProperties, "$nuxt", nuxtApp);
|
||
const runtimeConfig = options.ssrContext.runtimeConfig;
|
||
nuxtApp.provide("config", runtimeConfig);
|
||
return nuxtApp;
|
||
}
|
||
function registerPluginHooks(nuxtApp, plugin2) {
|
||
if (plugin2.hooks) {
|
||
nuxtApp.hooks.addHooks(plugin2.hooks);
|
||
}
|
||
}
|
||
async function applyPlugin(nuxtApp, plugin2) {
|
||
if (typeof plugin2 === "function") {
|
||
const { provide: provide2 } = await nuxtApp.runWithContext(() => plugin2(nuxtApp)) || {};
|
||
if (provide2 && typeof provide2 === "object") {
|
||
for (const key in provide2) {
|
||
nuxtApp.provide(key, provide2[key]);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
async function applyPlugins(nuxtApp, plugins2) {
|
||
const resolvedPlugins = /* @__PURE__ */ new Set();
|
||
const unresolvedPlugins = [];
|
||
const parallels = [];
|
||
let error = void 0;
|
||
let promiseDepth = 0;
|
||
async function executePlugin(plugin2) {
|
||
const unresolvedPluginsForThisPlugin = plugin2.dependsOn?.filter((name) => plugins2.some((p) => p._name === name) && !resolvedPlugins.has(name)) ?? [];
|
||
if (unresolvedPluginsForThisPlugin.length > 0) {
|
||
unresolvedPlugins.push([new Set(unresolvedPluginsForThisPlugin), plugin2]);
|
||
} else {
|
||
const promise = applyPlugin(nuxtApp, plugin2).then(async () => {
|
||
if (plugin2._name) {
|
||
resolvedPlugins.add(plugin2._name);
|
||
await Promise.all(unresolvedPlugins.map(async ([dependsOn, unexecutedPlugin]) => {
|
||
if (dependsOn.has(plugin2._name)) {
|
||
dependsOn.delete(plugin2._name);
|
||
if (dependsOn.size === 0) {
|
||
promiseDepth++;
|
||
await executePlugin(unexecutedPlugin);
|
||
}
|
||
}
|
||
}));
|
||
}
|
||
}).catch((e) => {
|
||
if (!plugin2.parallel && !nuxtApp.payload.error) {
|
||
throw e;
|
||
}
|
||
error ||= e;
|
||
});
|
||
if (plugin2.parallel) {
|
||
parallels.push(promise);
|
||
} else {
|
||
await promise;
|
||
}
|
||
}
|
||
}
|
||
for (const plugin2 of plugins2) {
|
||
if (nuxtApp.ssrContext?.islandContext && plugin2.env?.islands === false) {
|
||
continue;
|
||
}
|
||
registerPluginHooks(nuxtApp, plugin2);
|
||
}
|
||
for (const plugin2 of plugins2) {
|
||
if (nuxtApp.ssrContext?.islandContext && plugin2.env?.islands === false) {
|
||
continue;
|
||
}
|
||
await executePlugin(plugin2);
|
||
}
|
||
await Promise.all(parallels);
|
||
if (promiseDepth) {
|
||
for (let i = 0; i < promiseDepth; i++) {
|
||
await Promise.all(parallels);
|
||
}
|
||
}
|
||
if (error) {
|
||
throw nuxtApp.payload.error || error;
|
||
}
|
||
}
|
||
// @__NO_SIDE_EFFECTS__
|
||
function defineNuxtPlugin(plugin2) {
|
||
if (typeof plugin2 === "function") {
|
||
return plugin2;
|
||
}
|
||
const _name = plugin2._name || plugin2.name;
|
||
delete plugin2.name;
|
||
return Object.assign(plugin2.setup || (() => {
|
||
}), plugin2, { [NuxtPluginIndicator]: true, _name });
|
||
}
|
||
function callWithNuxt(nuxt, setup, args) {
|
||
const fn = () => setup();
|
||
const nuxtAppCtx = getNuxtAppCtx(nuxt._id);
|
||
{
|
||
return nuxt.vueApp.runWithContext(() => nuxtAppCtx.callAsync(nuxt, fn));
|
||
}
|
||
}
|
||
function tryUseNuxtApp(id) {
|
||
let nuxtAppInstance;
|
||
if (hasInjectionContext()) {
|
||
nuxtAppInstance = getCurrentInstance()?.appContext.app.$nuxt;
|
||
}
|
||
nuxtAppInstance ||= getNuxtAppCtx(id).tryUse();
|
||
return nuxtAppInstance || null;
|
||
}
|
||
function useNuxtApp(id) {
|
||
const nuxtAppInstance = tryUseNuxtApp(id);
|
||
if (!nuxtAppInstance) {
|
||
{
|
||
throw new Error("[nuxt] instance unavailable");
|
||
}
|
||
}
|
||
return nuxtAppInstance;
|
||
}
|
||
// @__NO_SIDE_EFFECTS__
|
||
function useRuntimeConfig(_event) {
|
||
return useNuxtApp().$config;
|
||
}
|
||
function defineGetter(obj, key, val) {
|
||
Object.defineProperty(obj, key, { get: () => val });
|
||
}
|
||
const LayoutMetaSymbol = /* @__PURE__ */ Symbol("layout-meta");
|
||
const PageRouteSymbol = /* @__PURE__ */ Symbol("route");
|
||
function toArray$1(value) {
|
||
return Array.isArray(value) ? value : [value];
|
||
}
|
||
import.meta.url.replace(/\/app\/.*$/, "/");
|
||
const useRouter = () => {
|
||
return useNuxtApp()?.$router;
|
||
};
|
||
const useRoute = () => {
|
||
if (hasInjectionContext()) {
|
||
return inject(PageRouteSymbol, useNuxtApp()._route);
|
||
}
|
||
return useNuxtApp()._route;
|
||
};
|
||
// @__NO_SIDE_EFFECTS__
|
||
function defineNuxtRouteMiddleware(middleware) {
|
||
return middleware;
|
||
}
|
||
const isProcessingMiddleware = () => {
|
||
try {
|
||
if (useNuxtApp()._processingMiddleware) {
|
||
return true;
|
||
}
|
||
} catch {
|
||
return false;
|
||
}
|
||
return false;
|
||
};
|
||
const URL_QUOTE_RE = /"/g;
|
||
const navigateTo = (to, options) => {
|
||
to ||= "/";
|
||
const toPath = typeof to === "string" ? to : "path" in to ? resolveRouteObject(to) : useRouter().resolve(to).href;
|
||
const isExternalHost = hasProtocol(toPath, { acceptRelative: true });
|
||
const isExternal = options?.external || isExternalHost;
|
||
if (isExternal) {
|
||
if (!options?.external) {
|
||
throw new Error("Navigating to an external URL is not allowed by default. Use `navigateTo(url, { external: true })`.");
|
||
}
|
||
const { protocol } = new URL(toPath, "http://localhost");
|
||
if (protocol && isScriptProtocol(protocol)) {
|
||
throw new Error(`Cannot navigate to a URL with '${protocol}' protocol.`);
|
||
}
|
||
}
|
||
const inMiddleware = isProcessingMiddleware();
|
||
const router = useRouter();
|
||
const nuxtApp = useNuxtApp();
|
||
{
|
||
if (nuxtApp.ssrContext) {
|
||
const fullPath = typeof to === "string" || isExternal ? toPath : router.resolve(to).fullPath || "/";
|
||
const location2 = isExternal ? toPath : joinURL((/* @__PURE__ */ useRuntimeConfig()).app.baseURL, fullPath);
|
||
const redirect = async function(response) {
|
||
await nuxtApp.callHook("app:redirected");
|
||
const encodedLoc = location2.replace(URL_QUOTE_RE, "%22");
|
||
const encodedHeader = encodeURL(location2, isExternalHost);
|
||
nuxtApp.ssrContext["~renderResponse"] = {
|
||
statusCode: sanitizeStatusCode(options?.redirectCode || 302, 302),
|
||
body: `<!DOCTYPE html><html><head><meta http-equiv="refresh" content="0; url=${encodedLoc}"></head></html>`,
|
||
headers: { location: encodedHeader }
|
||
};
|
||
return response;
|
||
};
|
||
if (!isExternal && inMiddleware) {
|
||
router.afterEach((final) => final.fullPath === fullPath ? redirect(false) : void 0);
|
||
return to;
|
||
}
|
||
return redirect(!inMiddleware ? void 0 : (
|
||
/* abort route navigation */
|
||
false
|
||
));
|
||
}
|
||
}
|
||
if (isExternal) {
|
||
nuxtApp._scope.stop();
|
||
if (options?.replace) {
|
||
(void 0).replace(toPath);
|
||
} else {
|
||
(void 0).href = toPath;
|
||
}
|
||
if (inMiddleware) {
|
||
if (!nuxtApp.isHydrating) {
|
||
return false;
|
||
}
|
||
return new Promise(() => {
|
||
});
|
||
}
|
||
return Promise.resolve();
|
||
}
|
||
const encodedTo = typeof to === "string" ? encodeRoutePath(to) : to;
|
||
return options?.replace ? router.replace(encodedTo) : router.push(encodedTo);
|
||
};
|
||
function resolveRouteObject(to) {
|
||
return withQuery(to.path || "", to.query || {}) + (to.hash || "");
|
||
}
|
||
function encodeURL(location2, isExternalHost = false) {
|
||
const url = new URL(location2, "http://localhost");
|
||
if (!isExternalHost) {
|
||
return url.pathname + url.search + url.hash;
|
||
}
|
||
if (location2.startsWith("//")) {
|
||
return url.toString().replace(url.protocol, "");
|
||
}
|
||
return url.toString();
|
||
}
|
||
function encodeRoutePath(url) {
|
||
const parsed = parseURL(url);
|
||
return encodePath(decodePath(parsed.pathname)) + parsed.search + parsed.hash;
|
||
}
|
||
const NUXT_ERROR_SIGNATURE = "__nuxt_error";
|
||
const useError = /* @__NO_SIDE_EFFECTS__ */ () => toRef(useNuxtApp().payload, "error");
|
||
const showError = (error) => {
|
||
const nuxtError = createError(error);
|
||
try {
|
||
const error2 = /* @__PURE__ */ useError();
|
||
if (false) ;
|
||
error2.value ||= nuxtError;
|
||
} catch {
|
||
throw nuxtError;
|
||
}
|
||
return nuxtError;
|
||
};
|
||
const isNuxtError = (error) => !!error && typeof error === "object" && NUXT_ERROR_SIGNATURE in error;
|
||
const createError = (error) => {
|
||
if (typeof error !== "string" && error.statusText) {
|
||
error.message ??= error.statusText;
|
||
}
|
||
const nuxtError = createError$1(error);
|
||
Object.defineProperty(nuxtError, NUXT_ERROR_SIGNATURE, {
|
||
value: true,
|
||
configurable: false,
|
||
writable: false
|
||
});
|
||
Object.defineProperty(nuxtError, "status", {
|
||
// eslint-disable-next-line @typescript-eslint/no-deprecated
|
||
get: () => nuxtError.statusCode,
|
||
configurable: true
|
||
});
|
||
Object.defineProperty(nuxtError, "statusText", {
|
||
// eslint-disable-next-line @typescript-eslint/no-deprecated
|
||
get: () => nuxtError.statusMessage,
|
||
configurable: true
|
||
});
|
||
return nuxtError;
|
||
};
|
||
function freezeHead(head) {
|
||
const realPush = head.push;
|
||
head.push = () => ({ dispose: () => {
|
||
}, patch: () => {
|
||
}, _poll: () => {
|
||
} });
|
||
return () => {
|
||
head.push = realPush;
|
||
};
|
||
}
|
||
const unhead_k2P3m_ZDyjlr2mMYnoDPwavjsDN8hBlk9cFai0bbopU = /* @__PURE__ */ defineNuxtPlugin({
|
||
name: "nuxt:head",
|
||
enforce: "pre",
|
||
setup(nuxtApp) {
|
||
const head = nuxtApp.ssrContext.head;
|
||
if (nuxtApp.ssrContext.islandContext) {
|
||
const unfreeze = freezeHead(head);
|
||
nuxtApp.hooks.hookOnce("app:created", unfreeze);
|
||
}
|
||
nuxtApp.vueApp.use(head);
|
||
}
|
||
});
|
||
function toArray(value) {
|
||
return Array.isArray(value) ? value : [value];
|
||
}
|
||
const matcher = (m, p) => {
|
||
return [];
|
||
};
|
||
const _routeRulesMatcher = (path) => defu({}, ...matcher().map((r) => r.data).reverse());
|
||
const routeRulesMatcher = _routeRulesMatcher;
|
||
function getRouteRules(arg) {
|
||
const path = typeof arg === "string" ? arg : arg.path;
|
||
try {
|
||
return routeRulesMatcher(path);
|
||
} catch (e) {
|
||
console.error("[nuxt] Error matching route rules.", e);
|
||
return {};
|
||
}
|
||
}
|
||
const __nuxt_page_meta$1 = { layout: false };
|
||
const __nuxt_page_meta = { ssr: false };
|
||
const _routes = [
|
||
{
|
||
name: "demo",
|
||
path: "/demo",
|
||
component: () => import("./_nuxt/demo-BC4si0ca.js")
|
||
},
|
||
{
|
||
name: "about",
|
||
path: "/about",
|
||
component: () => import("./_nuxt/about-DRb7Qi-T.js")
|
||
},
|
||
{
|
||
name: "index",
|
||
path: "/",
|
||
component: () => import("./_nuxt/index-BDL6Z3sD.js")
|
||
},
|
||
{
|
||
name: "contact",
|
||
path: "/contact",
|
||
component: () => import("./_nuxt/contact-ERUzdvQx.js")
|
||
},
|
||
{
|
||
name: "security",
|
||
path: "/security",
|
||
component: () => import("./_nuxt/security-xgUg9gDm.js")
|
||
},
|
||
{
|
||
name: "solution",
|
||
path: "/solution",
|
||
component: () => import("./_nuxt/solution-Cdu4og0R.js")
|
||
},
|
||
{
|
||
name: "resources",
|
||
path: "/resources",
|
||
component: () => import("./_nuxt/resources-a5Wv6dYO.js")
|
||
},
|
||
{
|
||
name: "scenarios",
|
||
path: "/scenarios",
|
||
component: () => import("./_nuxt/scenarios-c-hTY43N.js")
|
||
},
|
||
{
|
||
name: "capabilities",
|
||
path: "/capabilities",
|
||
component: () => import("./_nuxt/capabilities-Cm2IW4XJ.js")
|
||
},
|
||
{
|
||
name: "service-loop",
|
||
path: "/service-loop",
|
||
component: () => import("./_nuxt/service-loop-DeE-MiwA.js")
|
||
},
|
||
{
|
||
name: "platform",
|
||
path: "/platform",
|
||
meta: __nuxt_page_meta$1 || {},
|
||
component: () => import("./_nuxt/index-kIYeHZWZ.js")
|
||
},
|
||
{
|
||
name: "platform-login",
|
||
path: "/platform/login",
|
||
meta: __nuxt_page_meta || {},
|
||
component: () => import("./_nuxt/login-Bp9OHacV.js")
|
||
},
|
||
{
|
||
name: "platform-work-orders",
|
||
path: "/platform/work-orders",
|
||
component: () => import("./_nuxt/work-orders-BQLXwCMt.js")
|
||
},
|
||
{
|
||
name: "platform-applications",
|
||
path: "/platform/applications",
|
||
component: () => import("./_nuxt/applications-Cy7tl04a.js")
|
||
}
|
||
];
|
||
const ROUTE_KEY_PARENTHESES_RE = /(:\w+)\([^)]+\)/g;
|
||
const ROUTE_KEY_SYMBOLS_RE = /(:\w+)[?+*]/g;
|
||
const ROUTE_KEY_NORMAL_RE = /:\w+/g;
|
||
function generateRouteKey(route) {
|
||
const source = route?.meta.key ?? route.path.replace(ROUTE_KEY_PARENTHESES_RE, "$1").replace(ROUTE_KEY_SYMBOLS_RE, "$1").replace(ROUTE_KEY_NORMAL_RE, (r) => route.params[r.slice(1)]?.toString() || "");
|
||
return typeof source === "function" ? source(route) : source;
|
||
}
|
||
function isChangingPage(to, from) {
|
||
if (to === from || from === START_LOCATION) {
|
||
return false;
|
||
}
|
||
if (generateRouteKey(to) !== generateRouteKey(from)) {
|
||
return true;
|
||
}
|
||
const areComponentsSame = to.matched.every(
|
||
(comp, index) => comp.components && comp.components.default === from.matched[index]?.components?.default
|
||
);
|
||
if (areComponentsSame) {
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
const routerOptions0 = {
|
||
scrollBehavior(to, from, savedPosition) {
|
||
const nuxtApp = useNuxtApp();
|
||
const hashScrollBehaviour = useRouter().options?.scrollBehaviorType ?? "auto";
|
||
if (to.path.replace(/\/$/, "") === from.path.replace(/\/$/, "")) {
|
||
if (from.hash && !to.hash) {
|
||
return { left: 0, top: 0 };
|
||
}
|
||
if (to.hash) {
|
||
return { el: to.hash, top: _getHashElementScrollMarginTop(to.hash), behavior: hashScrollBehaviour };
|
||
}
|
||
return false;
|
||
}
|
||
const routeAllowsScrollToTop = typeof to.meta.scrollToTop === "function" ? to.meta.scrollToTop(to, from) : to.meta.scrollToTop;
|
||
if (routeAllowsScrollToTop === false) {
|
||
return false;
|
||
}
|
||
if (from === START_LOCATION) {
|
||
return _calculatePosition(to, from, savedPosition, hashScrollBehaviour);
|
||
}
|
||
return new Promise((resolve) => {
|
||
const doScroll = () => {
|
||
requestAnimationFrame(() => resolve(_calculatePosition(to, from, savedPosition, hashScrollBehaviour)));
|
||
};
|
||
nuxtApp.hooks.hookOnce("page:loading:end", () => {
|
||
const transitionPromise = nuxtApp["~transitionPromise"];
|
||
if (transitionPromise) {
|
||
transitionPromise.then(doScroll);
|
||
} else {
|
||
doScroll();
|
||
}
|
||
});
|
||
});
|
||
}
|
||
};
|
||
function _getHashElementScrollMarginTop(selector) {
|
||
try {
|
||
const elem = (void 0).querySelector(selector);
|
||
if (elem) {
|
||
return (Number.parseFloat(getComputedStyle(elem).scrollMarginTop) || 0) + (Number.parseFloat(getComputedStyle((void 0).documentElement).scrollPaddingTop) || 0);
|
||
}
|
||
} catch {
|
||
}
|
||
return 0;
|
||
}
|
||
function _calculatePosition(to, from, savedPosition, defaultHashScrollBehaviour) {
|
||
if (savedPosition) {
|
||
return savedPosition;
|
||
}
|
||
if (to.hash) {
|
||
return {
|
||
el: to.hash,
|
||
top: _getHashElementScrollMarginTop(to.hash),
|
||
behavior: isChangingPage(to, from) ? defaultHashScrollBehaviour : "instant"
|
||
};
|
||
}
|
||
return {
|
||
left: 0,
|
||
top: 0
|
||
};
|
||
}
|
||
const configRouterOptions = {
|
||
hashMode: false,
|
||
scrollBehaviorType: "auto"
|
||
};
|
||
const hashMode = false;
|
||
const routerOptions = {
|
||
...configRouterOptions,
|
||
...routerOptions0
|
||
};
|
||
const validate = /* @__PURE__ */ defineNuxtRouteMiddleware(async (to, from) => {
|
||
let __temp, __restore;
|
||
if (!to.meta?.validate) {
|
||
return;
|
||
}
|
||
const result = ([__temp, __restore] = executeAsync(() => Promise.resolve(to.meta.validate(to))), __temp = await __temp, __restore(), __temp);
|
||
if (result === true) {
|
||
return;
|
||
}
|
||
const error = createError({
|
||
fatal: false,
|
||
// eslint-disable-next-line @typescript-eslint/no-deprecated
|
||
status: result && (result.status || result.statusCode) || 404,
|
||
// eslint-disable-next-line @typescript-eslint/no-deprecated
|
||
statusText: result && (result.statusText || result.statusMessage) || `Page Not Found: ${to.fullPath}`,
|
||
data: {
|
||
path: to.fullPath
|
||
}
|
||
});
|
||
return error;
|
||
});
|
||
const manifest_45route_45rule = /* @__PURE__ */ defineNuxtRouteMiddleware((to) => {
|
||
{
|
||
return;
|
||
}
|
||
});
|
||
const globalMiddleware = [
|
||
validate,
|
||
manifest_45route_45rule
|
||
];
|
||
const namedMiddleware = {};
|
||
const plugin = /* @__PURE__ */ defineNuxtPlugin({
|
||
name: "nuxt:router",
|
||
enforce: "pre",
|
||
async setup(nuxtApp) {
|
||
let __temp, __restore;
|
||
let routerBase = (/* @__PURE__ */ useRuntimeConfig()).app.baseURL;
|
||
const history = routerOptions.history?.(routerBase) ?? createMemoryHistory(routerBase);
|
||
const routes2 = routerOptions.routes ? ([__temp, __restore] = executeAsync(() => routerOptions.routes(_routes)), __temp = await __temp, __restore(), __temp) ?? _routes : _routes;
|
||
let startPosition;
|
||
const router = createRouter({
|
||
...routerOptions,
|
||
scrollBehavior: (to, from, savedPosition) => {
|
||
if (from === START_LOCATION) {
|
||
startPosition = savedPosition;
|
||
return;
|
||
}
|
||
if (routerOptions.scrollBehavior) {
|
||
router.options.scrollBehavior = routerOptions.scrollBehavior;
|
||
if ("scrollRestoration" in (void 0).history) {
|
||
const unsub = router.beforeEach(() => {
|
||
unsub();
|
||
(void 0).history.scrollRestoration = "manual";
|
||
});
|
||
}
|
||
return routerOptions.scrollBehavior(to, START_LOCATION, startPosition || savedPosition);
|
||
}
|
||
},
|
||
history,
|
||
routes: routes2
|
||
});
|
||
nuxtApp.vueApp.use(router);
|
||
const previousRoute = shallowRef(router.currentRoute.value);
|
||
router.afterEach((_to, from) => {
|
||
previousRoute.value = from;
|
||
});
|
||
Object.defineProperty(nuxtApp.vueApp.config.globalProperties, "previousRoute", {
|
||
get: () => previousRoute.value
|
||
});
|
||
const initialURL = nuxtApp.ssrContext.url;
|
||
const _route = shallowRef(router.currentRoute.value);
|
||
const syncCurrentRoute = () => {
|
||
_route.value = router.currentRoute.value;
|
||
};
|
||
router.afterEach((to, from) => {
|
||
const lastTo = to.matched.at(-1)?.components?.default;
|
||
const lastFrom = from.matched.at(-1)?.components?.default;
|
||
if (lastTo === lastFrom) {
|
||
syncCurrentRoute();
|
||
return;
|
||
}
|
||
if (to.matched.length < from.matched.length && to.matched.every((m, i) => m.components?.default === from.matched[i]?.components?.default)) {
|
||
syncCurrentRoute();
|
||
}
|
||
});
|
||
const route = { sync: syncCurrentRoute };
|
||
for (const key in _route.value) {
|
||
Object.defineProperty(route, key, {
|
||
get: () => _route.value[key],
|
||
enumerable: true
|
||
});
|
||
}
|
||
nuxtApp._route = shallowReactive(route);
|
||
nuxtApp._middleware ||= {
|
||
global: [],
|
||
named: {}
|
||
};
|
||
const error = /* @__PURE__ */ useError();
|
||
if (!nuxtApp.ssrContext?.islandContext) {
|
||
router.afterEach(async (to, _from, failure) => {
|
||
delete nuxtApp._processingMiddleware;
|
||
if (failure) {
|
||
await nuxtApp.callHook("page:loading:end");
|
||
}
|
||
if (failure?.type === 4) {
|
||
return;
|
||
}
|
||
if (to.redirectedFrom && to.fullPath !== initialURL) {
|
||
await nuxtApp.runWithContext(() => navigateTo(to.fullPath || "/"));
|
||
}
|
||
});
|
||
}
|
||
try {
|
||
if (true) {
|
||
;
|
||
[__temp, __restore] = executeAsync(() => router.push(initialURL)), await __temp, __restore();
|
||
;
|
||
}
|
||
;
|
||
[__temp, __restore] = executeAsync(() => router.isReady()), await __temp, __restore();
|
||
;
|
||
} catch (error2) {
|
||
[__temp, __restore] = executeAsync(() => nuxtApp.runWithContext(() => showError(error2))), await __temp, __restore();
|
||
}
|
||
const resolvedInitialRoute = router.currentRoute.value;
|
||
const hasDeferredRoute = false;
|
||
syncCurrentRoute();
|
||
if (nuxtApp.ssrContext?.islandContext) {
|
||
return { provide: { router } };
|
||
}
|
||
const initialLayout = nuxtApp.payload.state._layout;
|
||
router.beforeEach(async (to, from) => {
|
||
await nuxtApp.callHook("page:loading:start");
|
||
to.meta = reactive(to.meta);
|
||
if (nuxtApp.isHydrating && initialLayout && !isReadonly(to.meta.layout)) {
|
||
to.meta.layout = initialLayout;
|
||
}
|
||
nuxtApp._processingMiddleware = true;
|
||
if (!nuxtApp.ssrContext?.islandContext) {
|
||
const middlewareEntries = /* @__PURE__ */ new Set([...globalMiddleware, ...nuxtApp._middleware.global]);
|
||
for (const component of to.matched) {
|
||
const componentMiddleware = component.meta.middleware;
|
||
if (!componentMiddleware) {
|
||
continue;
|
||
}
|
||
for (const entry2 of toArray(componentMiddleware)) {
|
||
middlewareEntries.add(entry2);
|
||
}
|
||
}
|
||
const routeRules = getRouteRules({ path: to.path });
|
||
if (routeRules.appMiddleware) {
|
||
for (const key in routeRules.appMiddleware) {
|
||
if (routeRules.appMiddleware[key]) {
|
||
middlewareEntries.add(key);
|
||
} else {
|
||
middlewareEntries.delete(key);
|
||
}
|
||
}
|
||
}
|
||
for (const entry2 of middlewareEntries) {
|
||
const middleware = typeof entry2 === "string" ? nuxtApp._middleware.named[entry2] || await namedMiddleware[entry2]?.().then((r) => r.default || r) : entry2;
|
||
if (!middleware) {
|
||
throw new Error(`Unknown route middleware: '${entry2}'.`);
|
||
}
|
||
try {
|
||
if (false) ;
|
||
const result = await nuxtApp.runWithContext(() => middleware(to, from));
|
||
if (true) {
|
||
if (result === false || result instanceof Error) {
|
||
const error2 = result || createError({
|
||
status: 404,
|
||
statusText: `Page Not Found: ${initialURL}`
|
||
});
|
||
await nuxtApp.runWithContext(() => showError(error2));
|
||
return false;
|
||
}
|
||
}
|
||
if (result === true) {
|
||
continue;
|
||
}
|
||
if (result === false) {
|
||
return result;
|
||
}
|
||
if (result) {
|
||
if (isNuxtError(result) && result.fatal) {
|
||
await nuxtApp.runWithContext(() => showError(result));
|
||
}
|
||
return result;
|
||
}
|
||
} catch (err) {
|
||
const error2 = createError(err);
|
||
if (error2.fatal) {
|
||
await nuxtApp.runWithContext(() => showError(error2));
|
||
}
|
||
return error2;
|
||
}
|
||
}
|
||
}
|
||
});
|
||
router.onError(async () => {
|
||
delete nuxtApp._processingMiddleware;
|
||
await nuxtApp.callHook("page:loading:end");
|
||
});
|
||
router.afterEach((to) => {
|
||
if (to.matched.length === 0 && !error.value) {
|
||
return nuxtApp.runWithContext(() => showError(createError({
|
||
status: 404,
|
||
fatal: false,
|
||
statusText: `Page not found: ${to.fullPath}`,
|
||
data: {
|
||
path: to.fullPath
|
||
}
|
||
})));
|
||
}
|
||
});
|
||
nuxtApp.hooks.hookOnce("app:created", async () => {
|
||
try {
|
||
if ("name" in resolvedInitialRoute) {
|
||
resolvedInitialRoute.name = void 0;
|
||
}
|
||
if (hasDeferredRoute) ;
|
||
else {
|
||
await router.replace({
|
||
...resolvedInitialRoute,
|
||
force: true
|
||
});
|
||
}
|
||
router.options.scrollBehavior = routerOptions.scrollBehavior;
|
||
} catch (error2) {
|
||
await nuxtApp.runWithContext(() => showError(error2));
|
||
}
|
||
});
|
||
return { provide: { router } };
|
||
}
|
||
});
|
||
function definePayloadReducer(name, reduce) {
|
||
{
|
||
useNuxtApp().ssrContext["~payloadReducers"][name] = reduce;
|
||
}
|
||
}
|
||
const reducers = [
|
||
["NuxtError", (data) => isNuxtError(data) && data.toJSON()],
|
||
["EmptyShallowRef", (data) => isRef(data) && isShallow(data) && !data.value && (typeof data.value === "bigint" ? "0n" : JSON.stringify(data.value) || "_")],
|
||
["EmptyRef", (data) => isRef(data) && !data.value && (typeof data.value === "bigint" ? "0n" : JSON.stringify(data.value) || "_")],
|
||
["ShallowRef", (data) => isRef(data) && isShallow(data) && data.value],
|
||
["ShallowReactive", (data) => isReactive(data) && isShallow(data) && toRaw(data)],
|
||
["Ref", (data) => isRef(data) && data.value],
|
||
["Reactive", (data) => isReactive(data) && toRaw(data)]
|
||
];
|
||
const revive_payload_server_MVtmlZaQpj6ApFmshWfUWl5PehCebzaBf2NuRMiIbms = /* @__PURE__ */ defineNuxtPlugin({
|
||
name: "nuxt:revive-payload:server",
|
||
setup() {
|
||
for (const [reducer, fn] of reducers) {
|
||
definePayloadReducer(reducer, fn);
|
||
}
|
||
}
|
||
});
|
||
const components_plugin_z4hgvsiddfKkfXTP6M8M4zG5Cb7sGnDhcryKVM45Di4 = /* @__PURE__ */ defineNuxtPlugin({
|
||
name: "nuxt:global-components"
|
||
});
|
||
function useRequestEvent(nuxtApp) {
|
||
nuxtApp ||= useNuxtApp();
|
||
return nuxtApp.ssrContext?.event;
|
||
}
|
||
function prerenderRoutes(path) {
|
||
if (!import.meta.prerender) {
|
||
return;
|
||
}
|
||
const paths = toArray$1(path);
|
||
appendHeader(useRequestEvent(), "x-nitro-prerender", paths.map((p) => encodeURIComponent(p)).join(", "));
|
||
}
|
||
let routes;
|
||
const prerender_server_sqIxOBipVr4FbVMA9kqWL0wT8FPop6sKAXLVfifsJzk = /* @__PURE__ */ defineNuxtPlugin(async () => {
|
||
let __temp, __restore;
|
||
if (!import.meta.prerender || hashMode) {
|
||
return;
|
||
}
|
||
if (routes && !routes.length) {
|
||
return;
|
||
}
|
||
routes ||= Array.from(processRoutes(([__temp, __restore] = executeAsync(() => routerOptions.routes?.(_routes)), __temp = await __temp, __restore(), __temp) ?? _routes));
|
||
const batch = routes.splice(0, 10);
|
||
prerenderRoutes(batch);
|
||
});
|
||
const OPTIONAL_PARAM_RE = /^\/?:.*(?:\?|\(\.\*\)\*)$/;
|
||
function shouldPrerender(path) {
|
||
return crawlLinks;
|
||
}
|
||
function processRoutes(routes2, currentPath = "/", routesToPrerender = /* @__PURE__ */ new Set()) {
|
||
for (const route of routes2) {
|
||
if (OPTIONAL_PARAM_RE.test(route.path) && !route.children?.length && shouldPrerender()) {
|
||
routesToPrerender.add(currentPath);
|
||
}
|
||
if (route.path.includes(":")) {
|
||
continue;
|
||
}
|
||
const fullPath = joinURL(currentPath, route.path);
|
||
{
|
||
routesToPrerender.add(fullPath);
|
||
}
|
||
if (route.children) {
|
||
processRoutes(route.children, fullPath, routesToPrerender);
|
||
}
|
||
}
|
||
return routesToPrerender;
|
||
}
|
||
const plugins = [
|
||
unhead_k2P3m_ZDyjlr2mMYnoDPwavjsDN8hBlk9cFai0bbopU,
|
||
plugin,
|
||
revive_payload_server_MVtmlZaQpj6ApFmshWfUWl5PehCebzaBf2NuRMiIbms,
|
||
components_plugin_z4hgvsiddfKkfXTP6M8M4zG5Cb7sGnDhcryKVM45Di4,
|
||
prerender_server_sqIxOBipVr4FbVMA9kqWL0wT8FPop6sKAXLVfifsJzk
|
||
];
|
||
const firstNonUndefined = (...args) => args.find((arg) => arg !== void 0);
|
||
// @__NO_SIDE_EFFECTS__
|
||
function defineNuxtLink(options) {
|
||
const componentName = options.componentName || "NuxtLink";
|
||
function isHashLinkWithoutHashMode(link) {
|
||
return typeof link === "string" && link.startsWith("#");
|
||
}
|
||
function resolveTrailingSlashBehavior(to, resolve, trailingSlash) {
|
||
const effectiveTrailingSlash = trailingSlash ?? options.trailingSlash;
|
||
if (!to || effectiveTrailingSlash !== "append" && effectiveTrailingSlash !== "remove") {
|
||
return to;
|
||
}
|
||
if (typeof to === "string") {
|
||
return applyTrailingSlashBehavior(to, effectiveTrailingSlash);
|
||
}
|
||
const path = "path" in to && to.path !== void 0 ? to.path : resolve(to).path;
|
||
const resolvedPath = {
|
||
...to,
|
||
name: void 0,
|
||
// named routes would otherwise always override trailing slash behavior
|
||
path: applyTrailingSlashBehavior(path, effectiveTrailingSlash)
|
||
};
|
||
return resolvedPath;
|
||
}
|
||
function useNuxtLink(props) {
|
||
const router = useRouter();
|
||
const config = /* @__PURE__ */ useRuntimeConfig();
|
||
const hasTarget = computed(() => !!unref(props.target) && unref(props.target) !== "_self");
|
||
const isAbsoluteUrl = computed(() => {
|
||
const path = unref(props.to) || unref(props.href) || "";
|
||
return typeof path === "string" && hasProtocol(path, { acceptRelative: true });
|
||
});
|
||
const builtinRouterLink = resolveComponent("RouterLink");
|
||
const useBuiltinLink = builtinRouterLink && typeof builtinRouterLink !== "string" ? builtinRouterLink.useLink : void 0;
|
||
const isExternal = computed(() => {
|
||
if (unref(props.external)) {
|
||
return true;
|
||
}
|
||
const path = unref(props.to) || unref(props.href) || "";
|
||
if (typeof path === "object") {
|
||
return false;
|
||
}
|
||
return path === "" || isAbsoluteUrl.value;
|
||
});
|
||
const to = computed(() => {
|
||
const path = unref(props.to) || unref(props.href) || "";
|
||
if (isExternal.value) {
|
||
return path;
|
||
}
|
||
return resolveTrailingSlashBehavior(path, router.resolve, unref(props.trailingSlash));
|
||
});
|
||
const link = isExternal.value ? void 0 : useBuiltinLink?.({ ...props, to, viewTransition: unref(props.viewTransition) });
|
||
const href = computed(() => {
|
||
const effectiveTrailingSlash = unref(props.trailingSlash) ?? options.trailingSlash;
|
||
if (!to.value || isAbsoluteUrl.value || isHashLinkWithoutHashMode(to.value)) {
|
||
return to.value;
|
||
}
|
||
if (isExternal.value) {
|
||
const path = typeof to.value === "object" && "path" in to.value ? resolveRouteObject(to.value) : to.value;
|
||
const href2 = typeof path === "object" ? router.resolve(path).href : path;
|
||
return applyTrailingSlashBehavior(href2, effectiveTrailingSlash);
|
||
}
|
||
if (typeof to.value === "object") {
|
||
return router.resolve(to.value)?.href ?? null;
|
||
}
|
||
return applyTrailingSlashBehavior(joinURL(config.app.baseURL, to.value), effectiveTrailingSlash);
|
||
});
|
||
return {
|
||
to,
|
||
hasTarget,
|
||
isAbsoluteUrl,
|
||
isExternal,
|
||
//
|
||
href,
|
||
isActive: link?.isActive ?? computed(() => to.value === router.currentRoute.value.path),
|
||
isExactActive: link?.isExactActive ?? computed(() => to.value === router.currentRoute.value.path),
|
||
route: link?.route ?? computed(() => router.resolve(to.value)),
|
||
async navigate(_e) {
|
||
await navigateTo(href.value, { replace: unref(props.replace), external: isExternal.value || hasTarget.value });
|
||
}
|
||
};
|
||
}
|
||
return defineComponent({
|
||
name: componentName,
|
||
props: {
|
||
// Routing
|
||
to: {
|
||
type: [String, Object],
|
||
default: void 0,
|
||
required: false
|
||
},
|
||
href: {
|
||
type: [String, Object],
|
||
default: void 0,
|
||
required: false
|
||
},
|
||
// Attributes
|
||
target: {
|
||
type: String,
|
||
default: void 0,
|
||
required: false
|
||
},
|
||
rel: {
|
||
type: String,
|
||
default: void 0,
|
||
required: false
|
||
},
|
||
noRel: {
|
||
type: Boolean,
|
||
default: void 0,
|
||
required: false
|
||
},
|
||
// Prefetching
|
||
prefetch: {
|
||
type: Boolean,
|
||
default: void 0,
|
||
required: false
|
||
},
|
||
prefetchOn: {
|
||
type: [String, Object],
|
||
default: void 0,
|
||
required: false
|
||
},
|
||
noPrefetch: {
|
||
type: Boolean,
|
||
default: void 0,
|
||
required: false
|
||
},
|
||
// Styling
|
||
activeClass: {
|
||
type: String,
|
||
default: void 0,
|
||
required: false
|
||
},
|
||
exactActiveClass: {
|
||
type: String,
|
||
default: void 0,
|
||
required: false
|
||
},
|
||
prefetchedClass: {
|
||
type: String,
|
||
default: void 0,
|
||
required: false
|
||
},
|
||
// Vue Router's `<RouterLink>` additional props
|
||
replace: {
|
||
type: Boolean,
|
||
default: void 0,
|
||
required: false
|
||
},
|
||
ariaCurrentValue: {
|
||
type: String,
|
||
default: void 0,
|
||
required: false
|
||
},
|
||
// Edge cases handling
|
||
external: {
|
||
type: Boolean,
|
||
default: void 0,
|
||
required: false
|
||
},
|
||
// Slot API
|
||
custom: {
|
||
type: Boolean,
|
||
default: void 0,
|
||
required: false
|
||
},
|
||
// Behavior
|
||
trailingSlash: {
|
||
type: String,
|
||
default: void 0,
|
||
required: false
|
||
}
|
||
},
|
||
useLink: useNuxtLink,
|
||
setup(props, { slots }) {
|
||
const router = useRouter();
|
||
const { to, href, navigate, isExternal, hasTarget, isAbsoluteUrl } = useNuxtLink(props);
|
||
shallowRef(false);
|
||
const el = void 0;
|
||
const elRef = void 0;
|
||
async function prefetch(nuxtApp = useNuxtApp()) {
|
||
{
|
||
return;
|
||
}
|
||
}
|
||
return () => {
|
||
if (!isExternal.value && !hasTarget.value && !isHashLinkWithoutHashMode(to.value)) {
|
||
const routerLinkProps = {
|
||
ref: elRef,
|
||
to: to.value,
|
||
activeClass: props.activeClass || options.activeClass,
|
||
exactActiveClass: props.exactActiveClass || options.exactActiveClass,
|
||
replace: props.replace,
|
||
ariaCurrentValue: props.ariaCurrentValue,
|
||
custom: props.custom
|
||
};
|
||
if (!props.custom) {
|
||
routerLinkProps.rel = props.rel || void 0;
|
||
}
|
||
return h(
|
||
resolveComponent("RouterLink"),
|
||
routerLinkProps,
|
||
slots.default
|
||
);
|
||
}
|
||
const target = props.target || null;
|
||
const rel = firstNonUndefined(
|
||
// converts `""` to `null` to prevent the attribute from being added as empty (`rel=""`)
|
||
props.noRel ? "" : props.rel,
|
||
options.externalRelAttribute,
|
||
/*
|
||
* A fallback rel of `noopener noreferrer` is applied for external links or links that open in a new tab.
|
||
* This solves a reverse tabnapping security flaw in browsers pre-2021 as well as improving privacy.
|
||
*/
|
||
isAbsoluteUrl.value || hasTarget.value ? "noopener noreferrer" : ""
|
||
) || null;
|
||
if (props.custom) {
|
||
if (!slots.default) {
|
||
return null;
|
||
}
|
||
return slots.default({
|
||
href: href.value,
|
||
navigate,
|
||
prefetch,
|
||
get route() {
|
||
if (!href.value) {
|
||
return void 0;
|
||
}
|
||
const url = new URL(href.value, "http://localhost");
|
||
return {
|
||
path: url.pathname,
|
||
fullPath: url.pathname,
|
||
get query() {
|
||
return parseQuery(url.search);
|
||
},
|
||
hash: url.hash,
|
||
params: {},
|
||
name: void 0,
|
||
matched: [],
|
||
redirectedFrom: void 0,
|
||
meta: {},
|
||
href: href.value
|
||
};
|
||
},
|
||
rel,
|
||
target,
|
||
isExternal: isExternal.value || hasTarget.value,
|
||
isActive: false,
|
||
isExactActive: false
|
||
});
|
||
}
|
||
return h("a", {
|
||
ref: el,
|
||
href: href.value || null,
|
||
// converts `""` to `null` to prevent the attribute from being added as empty (`href=""`)
|
||
rel,
|
||
target,
|
||
onClick: async (event) => {
|
||
if (isExternal.value || hasTarget.value) {
|
||
return;
|
||
}
|
||
event.preventDefault();
|
||
try {
|
||
const encodedHref = encodeRoutePath(href.value);
|
||
return await (props.replace ? router.replace(encodedHref) : router.push(encodedHref));
|
||
} finally {
|
||
}
|
||
}
|
||
}, slots.default?.());
|
||
};
|
||
}
|
||
});
|
||
}
|
||
const __nuxt_component_0 = /* @__PURE__ */ defineNuxtLink(nuxtLinkDefaults);
|
||
function applyTrailingSlashBehavior(to, trailingSlash) {
|
||
const normalizeFn = trailingSlash === "append" ? withTrailingSlash : withoutTrailingSlash;
|
||
const hasProtocolDifferentFromHttp = hasProtocol(to) && !to.startsWith("http");
|
||
if (hasProtocolDifferentFromHttp) {
|
||
return to;
|
||
}
|
||
return normalizeFn(to, true);
|
||
}
|
||
const siteName = "智慧医养居家上门服务平台";
|
||
const siteTagline = "面向政府、医院与养老机构的智慧医养居家上门服务闭环管理平台";
|
||
const siteDescription = "覆盖申请受理、能力评估、方案制定、智能派单、上门执行、过程监管、验收评价、结算归档全流程，帮助机构实现服务可监管、过程可追溯、质量可评价、费用可结算。";
|
||
const navMenus = [
|
||
{ label: "首页", to: "/" },
|
||
{ label: "平台演示", to: "/demo" },
|
||
{ label: "解决方案", to: "/solution" },
|
||
{ label: "核心能力", to: "/capabilities" },
|
||
{ label: "应用场景", to: "/scenarios" },
|
||
{ label: "服务闭环", to: "/service-loop" },
|
||
{ label: "安全合规", to: "/security" },
|
||
{ label: "资源中心", to: "/resources" },
|
||
{ label: "关于我们", to: "/about" },
|
||
{ label: "联系我们", to: "/contact" }
|
||
];
|
||
const painPoints = [
|
||
{ title: "申请受理难", desc: "多渠道申请分散，材料收集靠纸质，资格校验靠人工，效率低且容易遗漏。" },
|
||
{ title: "派单调度难", desc: "依赖人工经验派单，不考虑资质、区域、负载匹配，冲突和超时频发。" },
|
||
{ title: "过程监管难", desc: "服务过程不可见，GPS签到、执行记录、证据链缺失，质量无法保证。" }
|
||
];
|
||
const capabilities = [
|
||
{ icon: "clipboard", title: "需求受理", desc: "多渠道统一接入，自动校验材料、资格与重复申请" },
|
||
{ icon: "health", title: "能力评估", desc: "上门评估定级，GPS签到+现场拍照，护理等级与风险评估" },
|
||
{ icon: "document", title: "方案制定", desc: "评估驱动、费用透明计算、长护险抵扣、签署版本化管理" },
|
||
{ icon: "rocket", title: "智能派单", desc: "硬约束过滤+软约束评分，推荐Top5并附带匹配解释" },
|
||
{ icon: "check", title: "上门执行", desc: "GPS签到校验、项目级执行记录、图文音视频证据链留存" },
|
||
{ icon: "eye", title: "过程监管", desc: "抽查计划、违规记录、整改跟踪、审计日志全流程可追溯" },
|
||
{ icon: "star", title: "验收评价", desc: "星级评分、标签评价、语音评价，评分影响后续派单优先级" },
|
||
{ icon: "money", title: "结算归档", desc: "方案价→执行记录→验收→支付→归档，全链路金额可追溯" }
|
||
];
|
||
const scenarios = [
|
||
{ title: "政府监管", desc: "为民政/卫健部门提供居家养老服务全流程监管能力", icon: "government" },
|
||
{ title: "医院延续护理", desc: "院后居家照护服务延伸，提升连续照护能力", icon: "hospital" },
|
||
{ title: "养老机构", desc: "规范化派单、服务执行、质量评价和人员管理", icon: "home" },
|
||
{ title: "社区服务中心", desc: "社区居家照护派单、上门服务和数据上报", icon: "community" },
|
||
{ title: "长护险管理", desc: "长护险服务过程监管、费用结算和合规审计", icon: "shield" }
|
||
];
|
||
const securityItems = [
|
||
{ title: "RBAC权限体系", desc: "功能权限+数据范围+字段权限+操作审计，四级控制" },
|
||
{ title: "数据分类分级", desc: "个人身份、敏感健康、行踪轨迹、财务数据分级管控" },
|
||
{ title: "授权同意管理", desc: "GPS定位、照片、录音录像、健康信息采集前必须记录授权" },
|
||
{ title: "审计日志追溯", desc: "所有状态流转、敏感数据访问、高风险操作只追加不删除" },
|
||
{ title: "脱敏展示", desc: "姓名、手机号、身份证、地址按角色分级脱敏" },
|
||
{ title: "合规留痕", desc: "评估报告、方案快照、签署记录、支付凭证版本化管理" }
|
||
];
|
||
const metrics = [
|
||
{ label: "服务完成率", value: "≥90%", desc: "正常完成工单占比" },
|
||
{ label: "签到合规率", value: "≥95%", desc: "GPS签到合格率" },
|
||
{ label: "异常工单率", value: "≤5%", desc: "异常上报占比" },
|
||
{ label: "满意度评分", value: "≥4.5", desc: "服务对象平均评分" }
|
||
];
|
||
const footerLinks = {
|
||
solutions: [
|
||
{ label: "解决方案", to: "/solution" },
|
||
{ label: "核心能力", to: "/capabilities" },
|
||
{ label: "服务闭环", to: "/service-loop" }
|
||
],
|
||
scenarios: [
|
||
{ label: "应用场景", to: "/scenarios" },
|
||
{ label: "安全合规", to: "/security" },
|
||
{ label: "资源中心", to: "/resources" }
|
||
],
|
||
company: [
|
||
{ label: "关于我们", to: "/about" },
|
||
{ label: "联系我们", to: "/contact" }
|
||
]
|
||
};
|
||
const _sfc_main$4 = /* @__PURE__ */ defineComponent({
|
||
__name: "AppHeader",
|
||
__ssrInlineRender: true,
|
||
setup(__props) {
|
||
const mobileOpen = ref(false);
|
||
const config = /* @__PURE__ */ useRuntimeConfig();
|
||
const loginUrl = config.public.platformLoginUrl;
|
||
return (_ctx, _push, _parent, _attrs) => {
|
||
const _component_NuxtLink = __nuxt_component_0;
|
||
_push(`<header${ssrRenderAttrs(mergeProps({ class: "sticky top-0 z-50 bg-white/95 backdrop-blur border-b border-gray-100" }, _attrs))}><div class="section-container flex items-center justify-between h-16">`);
|
||
_push(ssrRenderComponent(_component_NuxtLink, {
|
||
to: "/",
|
||
class: "flex items-center gap-2 text-primary-700 font-bold text-lg shrink-0"
|
||
}, {
|
||
default: withCtx((_, _push2, _parent2, _scopeId) => {
|
||
if (_push2) {
|
||
_push2(`<span class="w-8 h-8 rounded-lg bg-primary flex items-center justify-center text-white text-sm font-mono"${_scopeId}>H</span> ${ssrInterpolate(unref(siteName))}`);
|
||
} else {
|
||
return [
|
||
createVNode("span", { class: "w-8 h-8 rounded-lg bg-primary flex items-center justify-center text-white text-sm font-mono" }, "H"),
|
||
createTextVNode(" " + toDisplayString(unref(siteName)), 1)
|
||
];
|
||
}
|
||
}),
|
||
_: 1
|
||
}, _parent));
|
||
_push(`<nav class="hidden lg:flex items-center gap-1"><!--[-->`);
|
||
ssrRenderList(unref(navMenus), (m) => {
|
||
_push(ssrRenderComponent(_component_NuxtLink, {
|
||
key: m.to,
|
||
to: m.to,
|
||
class: "px-3 py-2 rounded-lg text-sm text-text-secondary hover:text-primary hover:bg-primary-50 transition-colors"
|
||
}, {
|
||
default: withCtx((_, _push2, _parent2, _scopeId) => {
|
||
if (_push2) {
|
||
_push2(`${ssrInterpolate(m.label)}`);
|
||
} else {
|
||
return [
|
||
createTextVNode(toDisplayString(m.label), 1)
|
||
];
|
||
}
|
||
}),
|
||
_: 2
|
||
}, _parent));
|
||
});
|
||
_push(`<!--]--></nav><div class="hidden lg:flex items-center gap-3"><a${ssrRenderAttr("href", unref(loginUrl))} class="text-sm text-text-secondary hover:text-primary transition-colors">平台登录</a>`);
|
||
_push(ssrRenderComponent(_component_NuxtLink, {
|
||
to: "/contact",
|
||
class: "px-4 py-2 bg-cta text-white rounded-lg text-sm font-medium hover:bg-cta-700 transition-colors"
|
||
}, {
|
||
default: withCtx((_, _push2, _parent2, _scopeId) => {
|
||
if (_push2) {
|
||
_push2(` 预约演示 `);
|
||
} else {
|
||
return [
|
||
createTextVNode(" 预约演示 ")
|
||
];
|
||
}
|
||
}),
|
||
_: 1
|
||
}, _parent));
|
||
_push(`</div><button class="lg:hidden p-2" aria-label="菜单"><svg class="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"${ssrRenderAttr("d", mobileOpen.value ? "M6 18L18 6M6 6l12 12" : "M4 6h16M4 12h16M4 18h16")}></path></svg></button></div>`);
|
||
if (mobileOpen.value) {
|
||
_push(`<div class="lg:hidden border-t bg-white"><div class="section-container py-4 space-y-1"><!--[-->`);
|
||
ssrRenderList(unref(navMenus), (m) => {
|
||
_push(ssrRenderComponent(_component_NuxtLink, {
|
||
key: m.to,
|
||
to: m.to,
|
||
onClick: ($event) => mobileOpen.value = false,
|
||
class: "block px-3 py-2 rounded-lg text-text-secondary hover:text-primary hover:bg-primary-50"
|
||
}, {
|
||
default: withCtx((_, _push2, _parent2, _scopeId) => {
|
||
if (_push2) {
|
||
_push2(`${ssrInterpolate(m.label)}`);
|
||
} else {
|
||
return [
|
||
createTextVNode(toDisplayString(m.label), 1)
|
||
];
|
||
}
|
||
}),
|
||
_: 2
|
||
}, _parent));
|
||
});
|
||
_push(`<!--]--><div class="pt-3 border-t">`);
|
||
_push(ssrRenderComponent(_component_NuxtLink, {
|
||
to: "/contact",
|
||
onClick: ($event) => mobileOpen.value = false,
|
||
class: "block w-full text-center px-4 py-3 bg-cta text-white rounded-lg font-medium"
|
||
}, {
|
||
default: withCtx((_, _push2, _parent2, _scopeId) => {
|
||
if (_push2) {
|
||
_push2(` 预约演示 `);
|
||
} else {
|
||
return [
|
||
createTextVNode(" 预约演示 ")
|
||
];
|
||
}
|
||
}),
|
||
_: 1
|
||
}, _parent));
|
||
_push(`</div></div></div>`);
|
||
} else {
|
||
_push(`<!---->`);
|
||
}
|
||
_push(`</header>`);
|
||
};
|
||
}
|
||
});
|
||
const _sfc_setup$4 = _sfc_main$4.setup;
|
||
_sfc_main$4.setup = (props, ctx) => {
|
||
const ssrContext = useSSRContext();
|
||
(ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("components/AppHeader.vue");
|
||
return _sfc_setup$4 ? _sfc_setup$4(props, ctx) : void 0;
|
||
};
|
||
const defineRouteProvider = (name = "RouteProvider") => defineComponent({
|
||
name,
|
||
props: {
|
||
route: {
|
||
type: Object,
|
||
required: true
|
||
},
|
||
vnode: Object,
|
||
vnodeRef: Object,
|
||
renderKey: String,
|
||
trackRootNodes: Boolean
|
||
},
|
||
setup(props) {
|
||
const previousKey = props.renderKey;
|
||
const previousRoute = props.route;
|
||
const route = {};
|
||
for (const key in props.route) {
|
||
Object.defineProperty(route, key, {
|
||
get: () => previousKey === props.renderKey ? props.route[key] : previousRoute[key],
|
||
enumerable: true
|
||
});
|
||
}
|
||
provide(PageRouteSymbol, shallowReactive(route));
|
||
return () => {
|
||
if (!props.vnode) {
|
||
return props.vnode;
|
||
}
|
||
return h(props.vnode, { ref: props.vnodeRef });
|
||
};
|
||
}
|
||
});
|
||
const RouteProvider = defineRouteProvider();
|
||
const __nuxt_component_1 = defineComponent({
|
||
name: "NuxtPage",
|
||
inheritAttrs: false,
|
||
props: {
|
||
name: {
|
||
type: String
|
||
},
|
||
transition: {
|
||
type: [Boolean, Object],
|
||
default: void 0
|
||
},
|
||
keepalive: {
|
||
type: [Boolean, Object],
|
||
default: void 0
|
||
},
|
||
route: {
|
||
type: Object
|
||
},
|
||
pageKey: {
|
||
type: [Function, String],
|
||
default: null
|
||
}
|
||
},
|
||
setup(props, { attrs, slots, expose }) {
|
||
const nuxtApp = useNuxtApp();
|
||
const pageRef = ref();
|
||
inject(PageRouteSymbol, null);
|
||
expose({ pageRef });
|
||
inject(LayoutMetaSymbol, null);
|
||
nuxtApp.deferHydration();
|
||
return () => {
|
||
return h(RouterView, { name: props.name, route: props.route, ...attrs }, {
|
||
default: (routeProps) => {
|
||
return h(Suspense, { suspensible: true }, {
|
||
default() {
|
||
return h(RouteProvider, {
|
||
vnode: slots.default ? normalizeSlot(slots.default, routeProps) : routeProps.Component,
|
||
route: routeProps.route,
|
||
vnodeRef: pageRef
|
||
});
|
||
}
|
||
});
|
||
}
|
||
});
|
||
};
|
||
}
|
||
});
|
||
function normalizeSlot(slot, data) {
|
||
const slotContent = slot(data);
|
||
return slotContent.length === 1 ? h(slotContent[0]) : h(Fragment, void 0, slotContent);
|
||
}
|
||
const _sfc_main$3 = /* @__PURE__ */ defineComponent({
|
||
__name: "AppFooter",
|
||
__ssrInlineRender: true,
|
||
setup(__props) {
|
||
return (_ctx, _push, _parent, _attrs) => {
|
||
const _component_NuxtLink = __nuxt_component_0;
|
||
_push(`<footer${ssrRenderAttrs(mergeProps({ class: "bg-gray-900 text-gray-300 pt-16 pb-8" }, _attrs))}><div class="section-container"><div class="grid grid-cols-2 md:grid-cols-4 gap-8 mb-12"><div><h4 class="text-white font-bold mb-4">${ssrInterpolate(unref(siteName))}</h4><p class="text-sm text-gray-400">智慧医养居家上门服务闭环管理平台</p></div><div><h5 class="text-white font-semibold mb-3">解决方案</h5><ul class="space-y-2"><!--[-->`);
|
||
ssrRenderList(unref(footerLinks).solutions, (l) => {
|
||
_push(`<li>`);
|
||
_push(ssrRenderComponent(_component_NuxtLink, {
|
||
to: l.to,
|
||
class: "text-sm text-gray-400 hover:text-white transition-colors"
|
||
}, {
|
||
default: withCtx((_, _push2, _parent2, _scopeId) => {
|
||
if (_push2) {
|
||
_push2(`${ssrInterpolate(l.label)}`);
|
||
} else {
|
||
return [
|
||
createTextVNode(toDisplayString(l.label), 1)
|
||
];
|
||
}
|
||
}),
|
||
_: 2
|
||
}, _parent));
|
||
_push(`</li>`);
|
||
});
|
||
_push(`<!--]--></ul></div><div><h5 class="text-white font-semibold mb-3">应用场景</h5><ul class="space-y-2"><!--[-->`);
|
||
ssrRenderList(unref(footerLinks).scenarios, (l) => {
|
||
_push(`<li>`);
|
||
_push(ssrRenderComponent(_component_NuxtLink, {
|
||
to: l.to,
|
||
class: "text-sm text-gray-400 hover:text-white transition-colors"
|
||
}, {
|
||
default: withCtx((_, _push2, _parent2, _scopeId) => {
|
||
if (_push2) {
|
||
_push2(`${ssrInterpolate(l.label)}`);
|
||
} else {
|
||
return [
|
||
createTextVNode(toDisplayString(l.label), 1)
|
||
];
|
||
}
|
||
}),
|
||
_: 2
|
||
}, _parent));
|
||
_push(`</li>`);
|
||
});
|
||
_push(`<!--]--></ul></div><div><h5 class="text-white font-semibold mb-3">关于</h5><ul class="space-y-2"><!--[-->`);
|
||
ssrRenderList(unref(footerLinks).company, (l) => {
|
||
_push(`<li>`);
|
||
_push(ssrRenderComponent(_component_NuxtLink, {
|
||
to: l.to,
|
||
class: "text-sm text-gray-400 hover:text-white transition-colors"
|
||
}, {
|
||
default: withCtx((_, _push2, _parent2, _scopeId) => {
|
||
if (_push2) {
|
||
_push2(`${ssrInterpolate(l.label)}`);
|
||
} else {
|
||
return [
|
||
createTextVNode(toDisplayString(l.label), 1)
|
||
];
|
||
}
|
||
}),
|
||
_: 2
|
||
}, _parent));
|
||
_push(`</li>`);
|
||
});
|
||
_push(`<!--]--></ul></div></div><div class="border-t border-gray-700 pt-8 text-center text-sm text-gray-500"><p>© ${ssrInterpolate((/* @__PURE__ */ new Date()).getFullYear())} ${ssrInterpolate(unref(siteName))}. All rights reserved.</p><p class="mt-1 text-xs">ICP备案号：上线前补充 | 公安备案号：上线前补充</p><p class="mt-2 text-xs text-gray-600">本网站中系统界面图片为功能示意图（示意素材，待替换为真实系统截图）。</p></div></div></footer>`);
|
||
};
|
||
}
|
||
});
|
||
const _sfc_setup$3 = _sfc_main$3.setup;
|
||
_sfc_main$3.setup = (props, ctx) => {
|
||
const ssrContext = useSSRContext();
|
||
(ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("components/AppFooter.vue");
|
||
return _sfc_setup$3 ? _sfc_setup$3(props, ctx) : void 0;
|
||
};
|
||
const _export_sfc = (sfc, props) => {
|
||
const target = sfc.__vccOpts || sfc;
|
||
for (const [key, val] of props) {
|
||
target[key] = val;
|
||
}
|
||
return target;
|
||
};
|
||
const _sfc_main$2 = {};
|
||
function _sfc_ssrRender(_ctx, _push, _parent, _attrs) {
|
||
const _component_AppHeader = _sfc_main$4;
|
||
const _component_NuxtPage = __nuxt_component_1;
|
||
const _component_AppFooter = _sfc_main$3;
|
||
_push(`<div${ssrRenderAttrs(mergeProps({ class: "min-h-screen bg-surface-white text-text-primary" }, _attrs))}>`);
|
||
_push(ssrRenderComponent(_component_AppHeader, null, null, _parent));
|
||
_push(`<main>`);
|
||
_push(ssrRenderComponent(_component_NuxtPage, null, null, _parent));
|
||
_push(`</main>`);
|
||
_push(ssrRenderComponent(_component_AppFooter, null, null, _parent));
|
||
_push(`</div>`);
|
||
}
|
||
const _sfc_setup$2 = _sfc_main$2.setup;
|
||
_sfc_main$2.setup = (props, ctx) => {
|
||
const ssrContext = useSSRContext();
|
||
(ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("app.vue");
|
||
return _sfc_setup$2 ? _sfc_setup$2(props, ctx) : void 0;
|
||
};
|
||
const AppComponent = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["ssrRender", _sfc_ssrRender]]);
|
||
const _sfc_main$1 = {
|
||
__name: "nuxt-error-page",
|
||
__ssrInlineRender: true,
|
||
props: {
|
||
error: Object
|
||
},
|
||
setup(__props) {
|
||
const props = __props;
|
||
const _error = props.error;
|
||
const status = Number(_error.statusCode || 500);
|
||
const is404 = status === 404;
|
||
const statusText = _error.statusMessage ?? (is404 ? "Page Not Found" : "Internal Server Error");
|
||
const description = _error.message || _error.toString();
|
||
const stack = void 0;
|
||
const _Error404 = defineAsyncComponent(() => import("./_nuxt/error-404-Cx-ou_ki.js"));
|
||
const _Error = defineAsyncComponent(() => import("./_nuxt/error-500-CvzBcyf_.js"));
|
||
const ErrorTemplate = is404 ? _Error404 : _Error;
|
||
return (_ctx, _push, _parent, _attrs) => {
|
||
_push(ssrRenderComponent(unref(ErrorTemplate), mergeProps({ status: unref(status), statusText: unref(statusText), statusCode: unref(status), statusMessage: unref(statusText), description: unref(description), stack: unref(stack) }, _attrs), null, _parent));
|
||
};
|
||
}
|
||
};
|
||
const _sfc_setup$1 = _sfc_main$1.setup;
|
||
_sfc_main$1.setup = (props, ctx) => {
|
||
const ssrContext = useSSRContext();
|
||
(ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("node_modules/nuxt/dist/app/components/nuxt-error-page.vue");
|
||
return _sfc_setup$1 ? _sfc_setup$1(props, ctx) : void 0;
|
||
};
|
||
const _sfc_main = {
|
||
__name: "nuxt-root",
|
||
__ssrInlineRender: true,
|
||
setup(__props) {
|
||
const IslandRenderer = () => null;
|
||
const nuxtApp = useNuxtApp();
|
||
nuxtApp.deferHydration();
|
||
nuxtApp.ssrContext.url;
|
||
const SingleRenderer = false;
|
||
provide(PageRouteSymbol, useRoute());
|
||
nuxtApp.hooks.callHookWith((hooks) => hooks.map((hook) => hook()), "vue:setup", []);
|
||
const error = /* @__PURE__ */ useError();
|
||
const abortRender = error.value && !nuxtApp.ssrContext.error;
|
||
function invokeAppErrorHandler(err, target, info) {
|
||
const errorHandler = nuxtApp.vueApp.config.errorHandler;
|
||
if (errorHandler && !errorHandler.__nuxt_default) {
|
||
try {
|
||
errorHandler(err, target, info);
|
||
} catch (handlerError) {
|
||
console.error("[nuxt] Error in `app.config.errorHandler`", handlerError);
|
||
}
|
||
}
|
||
}
|
||
onErrorCaptured((err, target, info) => {
|
||
nuxtApp.hooks.callHook("vue:error", err, target, info).catch((hookError) => console.error("[nuxt] Error in `vue:error` hook", hookError));
|
||
{
|
||
const p = nuxtApp.runWithContext(() => showError(err));
|
||
onServerPrefetch(() => p);
|
||
invokeAppErrorHandler(err, target, info);
|
||
return false;
|
||
}
|
||
});
|
||
const islandContext = nuxtApp.ssrContext.islandContext;
|
||
return (_ctx, _push, _parent, _attrs) => {
|
||
ssrRenderSuspense(_push, {
|
||
default: () => {
|
||
if (unref(abortRender)) {
|
||
_push(`<div></div>`);
|
||
} else if (unref(error)) {
|
||
_push(ssrRenderComponent(unref(_sfc_main$1), { error: unref(error) }, null, _parent));
|
||
} else if (unref(islandContext)) {
|
||
_push(ssrRenderComponent(unref(IslandRenderer), { context: unref(islandContext) }, null, _parent));
|
||
} else if (unref(SingleRenderer)) {
|
||
ssrRenderVNode(_push, createVNode(resolveDynamicComponent(unref(SingleRenderer)), null, null), _parent);
|
||
} else {
|
||
_push(ssrRenderComponent(unref(AppComponent), null, null, _parent));
|
||
}
|
||
},
|
||
_: 1
|
||
});
|
||
};
|
||
}
|
||
};
|
||
const _sfc_setup = _sfc_main.setup;
|
||
_sfc_main.setup = (props, ctx) => {
|
||
const ssrContext = useSSRContext();
|
||
(ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("node_modules/nuxt/dist/app/components/nuxt-root.vue");
|
||
return _sfc_setup ? _sfc_setup(props, ctx) : void 0;
|
||
};
|
||
let entry;
|
||
{
|
||
entry = async function createNuxtAppServer(ssrContext) {
|
||
const vueApp = createApp(_sfc_main);
|
||
const nuxt = createNuxtApp({ vueApp, ssrContext });
|
||
try {
|
||
await applyPlugins(nuxt, plugins);
|
||
await nuxt.hooks.callHook("app:created", vueApp);
|
||
} catch (error) {
|
||
await nuxt.hooks.callHook("app:error", error);
|
||
nuxt.payload.error ||= createError(error);
|
||
}
|
||
if (ssrContext && (ssrContext["~renderResponse"] || ssrContext._renderResponse)) {
|
||
throw new Error("skipping render");
|
||
}
|
||
return vueApp;
|
||
};
|
||
}
|
||
const entry_default = ((ssrContext) => entry(ssrContext));
|
||
export {
|
||
__nuxt_component_0 as _,
|
||
_export_sfc as a,
|
||
securityItems as b,
|
||
capabilities as c,
|
||
siteDescription as d,
|
||
entry_default as default,
|
||
siteName as e,
|
||
siteTagline as f,
|
||
metrics as m,
|
||
navigateTo as n,
|
||
painPoints as p,
|
||
scenarios as s,
|
||
tryUseNuxtApp as t,
|
||
useRuntimeConfig as u
|
||
};
|
||
//# sourceMappingURL=server.mjs.map
|