赵忠林
528fe28ffc
- 新增api目录下多个接口路径代理处理文件，支持动态拼接目标URL - 根据环境变量选择不同的后端服务地址（如dev和生产环境） - 统一添加TenantId和Authorization请求头传递租户及身份信息 - 实现请求参数及搜索参数的完整转发 - 引入better-sqlite3及node内建模块支持服务端功能 - 新增专家详情页面，实现文章、成果及预约咨询功能展示 - 页面实现加载骨架屏、标签页切换及空状态提示优化体验
1994 lines
66 KiB
JavaScript
1994 lines
66 KiB
JavaScript
import process from 'node:process';globalThis._importMeta_=globalThis._importMeta_||{url:"file:///_entry.js",env:process.env};import { defineComponent, shallowRef, watch, unref, provide, inject, getCurrentInstance, h, resolveComponent, hasInjectionContext, computed, defineAsyncComponent, createElementBlock, cloneVNode, useSSRContext, createApp, mergeProps, withCtx, createTextVNode, toRef, onErrorCaptured, onServerPrefetch, createVNode, resolveDynamicComponent, shallowReactive, reactive, effectScope, isReadonly, isRef, isShallow, isReactive, toRaw, getCurrentScope } from 'vue';
|
|
import { q as parseQuery, f as createError$1, r as hasProtocol, s as isScriptProtocol, t as joinURL, w as withQuery, v as sanitizeStatusCode, x as withTrailingSlash, y as withoutTrailingSlash, z as getContext, $ as $fetch, A as baseURL, B as createHooks, C as executeAsync } from '../nitro/nitro.mjs';
|
|
import { createMemoryHistory, createRouter, START_LOCATION } from 'vue-router';
|
|
import Antd from 'ant-design-vue';
|
|
import _extends from '@babel/runtime/helpers/esm/extends';
|
|
import { serialize as serialize$1, compile, stringify } from 'stylis';
|
|
import { ssrRenderComponent, ssrRenderAttrs, ssrInterpolate, ssrRenderSuspense, ssrRenderVNode } from 'vue/server-renderer';
|
|
import dayjs from 'dayjs';
|
|
import { u as useSeoMeta$1, a as useHead$1, h as headSymbol } from '../routes/renderer.mjs';
|
|
import 'node:http';
|
|
import 'node:https';
|
|
import 'node:events';
|
|
import 'node:buffer';
|
|
import 'node:fs';
|
|
import 'node:path';
|
|
import 'node:crypto';
|
|
import 'node:url';
|
|
import 'better-sqlite3';
|
|
import 'vue-bundle-renderer/runtime';
|
|
import 'unhead/server';
|
|
import 'devalue';
|
|
import 'unhead/plugins';
|
|
import 'unhead/utils';
|
|
|
|
const SPLIT = '%';
|
|
class Entity {
|
|
constructor(instanceId) {
|
|
/** @private Internal cache map. Do not access this directly */
|
|
this.cache = new Map();
|
|
this.instanceId = instanceId;
|
|
}
|
|
get(keys) {
|
|
return this.cache.get(Array.isArray(keys) ? keys.join(SPLIT) : keys) || null;
|
|
}
|
|
update(keys, valueFn) {
|
|
const path = Array.isArray(keys) ? keys.join(SPLIT) : keys;
|
|
const prevValue = this.cache.get(path);
|
|
const nextValue = valueFn(prevValue);
|
|
if (nextValue === null) {
|
|
this.cache.delete(path);
|
|
} else {
|
|
this.cache.set(path, nextValue);
|
|
}
|
|
}
|
|
}
|
|
|
|
// https://stackoverflow.com/questions/46176165/ways-to-get-string-literal-type-of-array-values-without-enum-overhead
|
|
const withInstall = comp => {
|
|
const c = comp;
|
|
c.install = function (app) {
|
|
app.component(c.displayName || c.name, comp);
|
|
};
|
|
return comp;
|
|
};
|
|
function objectType(defaultVal) {
|
|
return {
|
|
type: Object,
|
|
default: defaultVal
|
|
};
|
|
}
|
|
function booleanType(defaultVal) {
|
|
return {
|
|
type: Boolean,
|
|
default: defaultVal
|
|
};
|
|
}
|
|
function anyType(defaultVal, required) {
|
|
const type = {
|
|
validator: () => true,
|
|
default: defaultVal
|
|
};
|
|
return required ? type : type;
|
|
}
|
|
function arrayType(defaultVal) {
|
|
return {
|
|
type: Array,
|
|
default: defaultVal
|
|
};
|
|
}
|
|
function stringType(defaultVal) {
|
|
return {
|
|
type: String,
|
|
default: defaultVal
|
|
};
|
|
}
|
|
function someType(types, defaultVal) {
|
|
return types ? {
|
|
type: types,
|
|
default: defaultVal
|
|
} : anyType(defaultVal);
|
|
}
|
|
|
|
const ATTR_TOKEN = 'data-token-hash';
|
|
const ATTR_MARK = 'data-css-hash';
|
|
// Mark css-in-js instance in style element
|
|
const CSS_IN_JS_INSTANCE = '__cssinjs_instance__';
|
|
function createCache() {
|
|
const cssinjsInstanceId = Math.random().toString(12).slice(2);
|
|
// Tricky SSR: Move all inline style to the head.
|
|
// PS: We do not recommend tricky mode.
|
|
if (typeof document !== 'undefined' && document.head && document.body) {
|
|
const styles = document.body.querySelectorAll(`style[${ATTR_MARK}]`) || [];
|
|
const {
|
|
firstChild
|
|
} = document.head;
|
|
Array.from(styles).forEach(style => {
|
|
style[CSS_IN_JS_INSTANCE] = style[CSS_IN_JS_INSTANCE] || cssinjsInstanceId;
|
|
// Not force move if no head
|
|
// Not force move if no head
|
|
if (style[CSS_IN_JS_INSTANCE] === cssinjsInstanceId) {
|
|
document.head.insertBefore(style, firstChild);
|
|
}
|
|
});
|
|
// Deduplicate of moved styles
|
|
const styleHash = {};
|
|
Array.from(document.querySelectorAll(`style[${ATTR_MARK}]`)).forEach(style => {
|
|
var _a;
|
|
const hash = style.getAttribute(ATTR_MARK);
|
|
if (styleHash[hash]) {
|
|
if (style[CSS_IN_JS_INSTANCE] === cssinjsInstanceId) {
|
|
(_a = style.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(style);
|
|
}
|
|
} else {
|
|
styleHash[hash] = true;
|
|
}
|
|
});
|
|
}
|
|
return new Entity(cssinjsInstanceId);
|
|
}
|
|
const StyleContextKey = Symbol('StyleContextKey');
|
|
// fix: https://github.com/vueComponent/ant-design-vue/issues/7023
|
|
const getCache = () => {
|
|
var _a, _b, _c;
|
|
const instance = getCurrentInstance();
|
|
let cache;
|
|
if (instance && instance.appContext) {
|
|
const globalCache = (_c = (_b = (_a = instance.appContext) === null || _a === void 0 ? void 0 : _a.config) === null || _b === void 0 ? void 0 : _b.globalProperties) === null || _c === void 0 ? void 0 : _c.__ANTDV_CSSINJS_CACHE__;
|
|
if (globalCache) {
|
|
cache = globalCache;
|
|
} else {
|
|
cache = createCache();
|
|
if (instance.appContext.config.globalProperties) {
|
|
instance.appContext.config.globalProperties.__ANTDV_CSSINJS_CACHE__ = cache;
|
|
}
|
|
}
|
|
} else {
|
|
cache = createCache();
|
|
}
|
|
return cache;
|
|
};
|
|
const defaultStyleContext = {
|
|
cache: createCache(),
|
|
defaultCache: true,
|
|
hashPriority: 'low'
|
|
};
|
|
// fix: https://github.com/vueComponent/ant-design-vue/issues/6912
|
|
const useStyleInject = () => {
|
|
const cache = getCache();
|
|
return inject(StyleContextKey, shallowRef(_extends(_extends({}, defaultStyleContext), {
|
|
cache
|
|
})));
|
|
};
|
|
const useStyleProvider = props => {
|
|
const parentContext = useStyleInject();
|
|
const context = shallowRef(_extends(_extends({}, defaultStyleContext), {
|
|
cache: createCache()
|
|
}));
|
|
watch([() => unref(props), parentContext], () => {
|
|
const mergedContext = _extends({}, parentContext.value);
|
|
const propsValue = unref(props);
|
|
Object.keys(propsValue).forEach(key => {
|
|
const value = propsValue[key];
|
|
if (propsValue[key] !== undefined) {
|
|
mergedContext[key] = value;
|
|
}
|
|
});
|
|
const {
|
|
cache
|
|
} = propsValue;
|
|
mergedContext.cache = mergedContext.cache || createCache();
|
|
mergedContext.defaultCache = !cache && parentContext.value.defaultCache;
|
|
context.value = mergedContext;
|
|
}, {
|
|
immediate: true
|
|
});
|
|
provide(StyleContextKey, context);
|
|
return context;
|
|
};
|
|
const styleProviderProps = () => ({
|
|
autoClear: booleanType(),
|
|
/** @private Test only. Not work in production. */
|
|
mock: stringType(),
|
|
/**
|
|
* Only set when you need ssr to extract style on you own.
|
|
* If not provided, it will auto create <style /> on the end of Provider in server side.
|
|
*/
|
|
cache: objectType(),
|
|
/** Tell children that this context is default generated context */
|
|
defaultCache: booleanType(),
|
|
/** Use `:where` selector to reduce hashId css selector priority */
|
|
hashPriority: stringType(),
|
|
/** Tell cssinjs where to inject style in */
|
|
container: someType(),
|
|
/** Component wil render inline `<style />` for fallback in SSR. Not recommend. */
|
|
ssrInline: booleanType(),
|
|
/** Transform css before inject in document. Please note that `transformers` do not support dynamic update */
|
|
transformers: arrayType(),
|
|
/**
|
|
* Linters to lint css before inject in document.
|
|
* Styles will be linted after transforming.
|
|
* Please note that `linters` do not support dynamic update.
|
|
*/
|
|
linters: arrayType()
|
|
});
|
|
withInstall(defineComponent({
|
|
name: 'AStyleProvider',
|
|
inheritAttrs: false,
|
|
props: styleProviderProps(),
|
|
setup(props, _ref) {
|
|
let {
|
|
slots
|
|
} = _ref;
|
|
useStyleProvider(props);
|
|
return () => {
|
|
var _a;
|
|
return (_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots);
|
|
};
|
|
}
|
|
}));
|
|
|
|
const ATTR_CACHE_MAP = 'data-ant-cssinjs-cache-path';
|
|
function serialize(cachePathMap) {
|
|
return Object.keys(cachePathMap).map(path => {
|
|
const hash = cachePathMap[path];
|
|
return `${path}:${hash}`;
|
|
}).join(';');
|
|
}
|
|
|
|
// ============================================================================
|
|
// == Parser ==
|
|
// ============================================================================
|
|
// Preprocessor style content to browser support one
|
|
function normalizeStyle(styleStr) {
|
|
const serialized = serialize$1(compile(styleStr), stringify);
|
|
return serialized.replace(/\{%%%\:[^;];}/g, ';');
|
|
}
|
|
// ============================================================================
|
|
// == SSR ==
|
|
// ============================================================================
|
|
function extractStyle(cache) {
|
|
let plain = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
|
|
const matchPrefix = `style%`;
|
|
// prefix with `style` is used for `useStyleRegister` to cache style context
|
|
const styleKeys = Array.from(cache.cache.keys()).filter(key => key.startsWith(matchPrefix));
|
|
// Common effect styles like animation
|
|
const effectStyles = {};
|
|
// Mapping of cachePath to style hash
|
|
const cachePathMap = {};
|
|
let styleText = '';
|
|
function toStyleStr(style, tokenKey, styleId) {
|
|
let customizeAttrs = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
|
|
const attrs = _extends(_extends({}, customizeAttrs), {
|
|
[ATTR_TOKEN]: tokenKey,
|
|
[ATTR_MARK]: styleId
|
|
});
|
|
const attrStr = Object.keys(attrs).map(attr => {
|
|
const val = attrs[attr];
|
|
return val ? `${attr}="${val}"` : null;
|
|
}).filter(v => v).join(' ');
|
|
return plain ? style : `<style ${attrStr}>${style}</style>`;
|
|
}
|
|
const orderStyles = styleKeys.map(key => {
|
|
const cachePath = key.slice(matchPrefix.length).replace(/%/g, '|');
|
|
const [styleStr, tokenKey, styleId, effectStyle, clientOnly, order] = cache.cache.get(key)[1];
|
|
// Skip client only style
|
|
if (clientOnly) {
|
|
return null;
|
|
}
|
|
// ====================== Style ======================
|
|
// Used for vc-util
|
|
const sharedAttrs = {
|
|
'data-vc-order': 'prependQueue',
|
|
'data-vc-priority': `${order}`
|
|
};
|
|
let keyStyleText = toStyleStr(styleStr, tokenKey, styleId, sharedAttrs);
|
|
// Save cache path with hash mapping
|
|
cachePathMap[cachePath] = styleId;
|
|
// =============== Create effect style ===============
|
|
if (effectStyle) {
|
|
Object.keys(effectStyle).forEach(effectKey => {
|
|
// Effect style can be reused
|
|
if (!effectStyles[effectKey]) {
|
|
effectStyles[effectKey] = true;
|
|
keyStyleText += toStyleStr(normalizeStyle(effectStyle[effectKey]), tokenKey, `_effect-${effectKey}`, sharedAttrs);
|
|
}
|
|
});
|
|
}
|
|
const ret = [order, keyStyleText];
|
|
return ret;
|
|
}).filter(o => o);
|
|
orderStyles.sort((o1, o2) => o1[0] - o2[0]).forEach(_ref2 => {
|
|
let [, style] = _ref2;
|
|
styleText += style;
|
|
});
|
|
// ==================== Fill Cache Path ====================
|
|
styleText += toStyleStr(`.${ATTR_CACHE_MAP}{content:"${serialize(cachePathMap)}";}`, undefined, undefined, {
|
|
[ATTR_CACHE_MAP]: ATTR_CACHE_MAP
|
|
});
|
|
return styleText;
|
|
}
|
|
|
|
if (!globalThis.$fetch) {
|
|
globalThis.$fetch = $fetch.create({
|
|
baseURL: baseURL()
|
|
});
|
|
}
|
|
if (!("global" in globalThis)) {
|
|
globalThis.global = globalThis;
|
|
}
|
|
const nuxtLinkDefaults = { "componentName": "NuxtLink" };
|
|
const asyncDataDefaults = { "deep": false };
|
|
const appId = "nuxt-app";
|
|
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,
|
|
versions: {
|
|
get nuxt() {
|
|
return "4.2.2";
|
|
},
|
|
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 PageRouteSymbol = /* @__PURE__ */ Symbol("route");
|
|
globalThis._importMeta_.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();
|
|
}
|
|
return options?.replace ? router.replace(to) : router.push(to);
|
|
};
|
|
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();
|
|
}
|
|
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 clearError = async (options = {}) => {
|
|
const nuxtApp = useNuxtApp();
|
|
const error = /* @__PURE__ */ useError();
|
|
nuxtApp.callHook("app:error:cleared", options);
|
|
if (options.redirect) {
|
|
await useRouter().replace(options.redirect);
|
|
}
|
|
error.value = void 0;
|
|
};
|
|
const isNuxtError = (error) => !!error && typeof error === "object" && NUXT_ERROR_SIGNATURE in error;
|
|
const createError = (error) => {
|
|
const nuxtError = createError$1(error);
|
|
Object.defineProperty(nuxtError, NUXT_ERROR_SIGNATURE, {
|
|
value: true,
|
|
configurable: false,
|
|
writable: false
|
|
});
|
|
return nuxtError;
|
|
};
|
|
const unhead__ymL50Gnw4LMhG971h5jZDnuGBbLmnj_x6wFrgJrk8Y = /* @__PURE__ */ defineNuxtPlugin({
|
|
name: "nuxt:head",
|
|
enforce: "pre",
|
|
setup(nuxtApp) {
|
|
const head = nuxtApp.ssrContext.head;
|
|
nuxtApp.vueApp.use(head);
|
|
}
|
|
});
|
|
function toArray(value) {
|
|
return Array.isArray(value) ? value : [value];
|
|
}
|
|
const __nuxt_page_meta$j = { layout: false };
|
|
const __nuxt_page_meta$i = { layout: "default" };
|
|
const __nuxt_page_meta$h = { layout: "default" };
|
|
const __nuxt_page_meta$g = { layout: "default" };
|
|
const __nuxt_page_meta$f = { layout: "blank" };
|
|
const __nuxt_page_meta$e = { layout: "admin" };
|
|
const __nuxt_page_meta$d = { layout: "admin" };
|
|
const __nuxt_page_meta$c = { layout: "admin" };
|
|
const __nuxt_page_meta$b = { layout: "admin" };
|
|
const __nuxt_page_meta$a = { layout: "admin" };
|
|
const __nuxt_page_meta$9 = { layout: "admin" };
|
|
const __nuxt_page_meta$8 = { layout: "admin" };
|
|
const __nuxt_page_meta$7 = { layout: "admin" };
|
|
const __nuxt_page_meta$6 = { layout: "admin" };
|
|
const __nuxt_page_meta$5 = { layout: "admin" };
|
|
const __nuxt_page_meta$4 = { layout: "admin" };
|
|
const __nuxt_page_meta$3 = { layout: "admin" };
|
|
const __nuxt_page_meta$2 = { layout: "admin" };
|
|
const __nuxt_page_meta$1 = { layout: "admin" };
|
|
const __nuxt_page_meta = { layout: "admin" };
|
|
const _routes = [
|
|
{
|
|
name: "index",
|
|
path: "/",
|
|
component: () => import('./index-C_KINsjY.mjs')
|
|
},
|
|
{
|
|
name: "login",
|
|
path: "/login",
|
|
meta: __nuxt_page_meta$j || {},
|
|
component: () => import('./login-SVLbv5UR.mjs')
|
|
},
|
|
{
|
|
name: "contact",
|
|
path: "/contact",
|
|
component: () => import('./contact-BpH_I62G.mjs')
|
|
},
|
|
{
|
|
name: "privacy",
|
|
path: "/privacy",
|
|
meta: __nuxt_page_meta$i || {},
|
|
component: () => import('./privacy-CgGrr3Sb.mjs')
|
|
},
|
|
{
|
|
name: "website",
|
|
path: "/website",
|
|
meta: __nuxt_page_meta$h || {},
|
|
component: () => import('./website-Cj_wOCFL.mjs')
|
|
},
|
|
{
|
|
name: "articles",
|
|
path: "/articles",
|
|
component: () => import('./articles-CkRo2zT3.mjs')
|
|
},
|
|
{
|
|
name: "agreement",
|
|
path: "/agreement",
|
|
meta: __nuxt_page_meta$g || {},
|
|
component: () => import('./agreement-BZqT3Txx.mjs')
|
|
},
|
|
{
|
|
name: "bind-phone",
|
|
path: "/bind-phone",
|
|
meta: __nuxt_page_meta$f || {},
|
|
component: () => import('./bind-phone-CjPFbjTp.mjs')
|
|
},
|
|
{
|
|
name: "news",
|
|
path: "/news",
|
|
component: () => import('./index-BdoBRFUe.mjs')
|
|
},
|
|
{
|
|
name: "about",
|
|
path: "/about",
|
|
component: () => import('./index-BHhoACKU.mjs')
|
|
},
|
|
{
|
|
name: "admin",
|
|
path: "/admin",
|
|
meta: __nuxt_page_meta$e || {},
|
|
component: () => import('./index-DhQFY9Jt.mjs')
|
|
},
|
|
{
|
|
name: "admin-users",
|
|
path: "/admin/users",
|
|
meta: __nuxt_page_meta$d || {},
|
|
component: () => import('./users-R2tJfhAK.mjs')
|
|
},
|
|
{
|
|
name: "expert-id",
|
|
path: "/expert/:id()",
|
|
component: () => import('./_id_-BqOla5il.mjs')
|
|
},
|
|
{
|
|
name: "hanmo",
|
|
path: "/hanmo",
|
|
component: () => import('./index-72jJ6-i-.mjs')
|
|
},
|
|
{
|
|
name: "article-id",
|
|
path: "/article/:id()",
|
|
component: () => import('./_id_-BuB0HRsp.mjs')
|
|
},
|
|
{
|
|
name: "expert-apply",
|
|
path: "/expert/apply",
|
|
component: () => import('./apply-B2xHqrDp.mjs')
|
|
},
|
|
{
|
|
name: "expert",
|
|
path: "/expert",
|
|
component: () => import('./index-DcD4r-Ko.mjs')
|
|
},
|
|
{
|
|
name: "about-charter",
|
|
path: "/about/charter",
|
|
component: () => import('./charter-CaIzBdXO.mjs')
|
|
},
|
|
{
|
|
name: "profile",
|
|
path: "/profile",
|
|
component: () => import('./index-BpW8YK7f.mjs')
|
|
},
|
|
{
|
|
name: "admin-articles",
|
|
path: "/admin/articles",
|
|
meta: __nuxt_page_meta$c || {},
|
|
component: () => import('./articles-DR9-Jw1_.mjs')
|
|
},
|
|
{
|
|
name: "admin-settings",
|
|
path: "/admin/settings",
|
|
meta: __nuxt_page_meta$b || {},
|
|
component: () => import('./settings-C9KNDE2-.mjs')
|
|
},
|
|
{
|
|
name: "admin-downloads",
|
|
path: "/admin/downloads",
|
|
meta: __nuxt_page_meta$a || {},
|
|
component: () => import('./downloads-HRDItwoB.mjs')
|
|
},
|
|
{
|
|
name: "reference",
|
|
path: "/reference",
|
|
component: () => import('./index-Y1VlXdUo.mjs')
|
|
},
|
|
{
|
|
name: "admin-categories",
|
|
path: "/admin/categories",
|
|
meta: __nuxt_page_meta$9 || {},
|
|
component: () => import('./categories-Dt7fGmD0.mjs')
|
|
},
|
|
{
|
|
name: "membership",
|
|
path: "/membership",
|
|
component: () => import('./index-B8o-rKOg.mjs')
|
|
},
|
|
{
|
|
name: "think-tank",
|
|
path: "/think-tank",
|
|
component: () => import('./index-CtXc2H4b.mjs')
|
|
},
|
|
{
|
|
name: "suggestions",
|
|
path: "/suggestions",
|
|
component: () => import('./index-A9wylOpH.mjs')
|
|
},
|
|
{
|
|
name: "about-consultation",
|
|
path: "/about/consultation",
|
|
component: () => import('./consultation-Bg8868q3.mjs')
|
|
},
|
|
{
|
|
name: "about-organization",
|
|
path: "/about/organization",
|
|
component: () => import('./organization-DYr7-Q3T.mjs')
|
|
},
|
|
{
|
|
name: "consultation",
|
|
path: "/consultation",
|
|
component: () => import('./index-BlIekb68.mjs')
|
|
},
|
|
{
|
|
name: "about-join-personal",
|
|
path: "/about/join/personal",
|
|
component: () => import('./personal-C_9ecoqh.mjs')
|
|
},
|
|
{
|
|
name: "admin-announcements",
|
|
path: "/admin/announcements",
|
|
meta: __nuxt_page_meta$8 || {},
|
|
component: () => import('./announcements-BflH5AKP.mjs')
|
|
},
|
|
{
|
|
name: "admin-experts",
|
|
path: "/admin/experts",
|
|
meta: __nuxt_page_meta$7 || {},
|
|
component: () => import('./index-Ds4UieiM.mjs')
|
|
},
|
|
{
|
|
name: "admin-members",
|
|
path: "/admin/members",
|
|
meta: __nuxt_page_meta$6 || {},
|
|
component: () => import('./index-DdeGb0tg.mjs')
|
|
},
|
|
{
|
|
name: "admin-experts-review",
|
|
path: "/admin/experts/review",
|
|
meta: __nuxt_page_meta$5 || {},
|
|
component: () => import('./review-By9z7K8B.mjs')
|
|
},
|
|
{
|
|
name: "admin-members-review",
|
|
path: "/admin/members/review",
|
|
meta: __nuxt_page_meta$4 || {},
|
|
component: () => import('./review-BytUCWvf.mjs')
|
|
},
|
|
{
|
|
name: "about-join-enterprise",
|
|
path: "/about/join/enterprise",
|
|
component: () => import('./enterprise-BjfXTXvE.mjs')
|
|
},
|
|
{
|
|
name: "admin-suggestions",
|
|
path: "/admin/suggestions",
|
|
meta: __nuxt_page_meta$3 || {},
|
|
component: () => import('./index-BO9w7hej.mjs')
|
|
},
|
|
{
|
|
name: "admin-article-categories",
|
|
path: "/admin/article-categories",
|
|
meta: __nuxt_page_meta$2 || {},
|
|
component: () => import('./article-categories-Cr84tAzn.mjs')
|
|
},
|
|
{
|
|
name: "admin-applications-expert",
|
|
path: "/admin/applications/expert",
|
|
meta: __nuxt_page_meta$1 || {},
|
|
component: () => import('./expert-BQyfMLGC.mjs')
|
|
},
|
|
{
|
|
name: "admin-applications-member",
|
|
path: "/admin/applications/member",
|
|
meta: __nuxt_page_meta || {},
|
|
component: () => import('./member-BW0JmP4L.mjs')
|
|
}
|
|
];
|
|
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;
|
|
}
|
|
const hookToWait = nuxtApp._runningTransition ? "page:transition:finish" : "page:loading:end";
|
|
return new Promise((resolve) => {
|
|
if (from === START_LOCATION) {
|
|
resolve(_calculatePosition(to, from, savedPosition, hashScrollBehaviour));
|
|
return;
|
|
}
|
|
nuxtApp.hooks.hookOnce(hookToWait, () => {
|
|
requestAnimationFrame(() => resolve(_calculatePosition(to, from, savedPosition, hashScrollBehaviour)));
|
|
});
|
|
});
|
|
}
|
|
};
|
|
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;
|
|
}
|
|
const isPageNavigation = isChangingPage(to, from);
|
|
if (to.hash) {
|
|
return {
|
|
el: to.hash,
|
|
top: _getHashElementScrollMarginTop(to.hash),
|
|
behavior: isPageNavigation ? defaultHashScrollBehaviour : "instant"
|
|
};
|
|
}
|
|
return {
|
|
left: 0,
|
|
top: 0
|
|
};
|
|
}
|
|
const configRouterOptions = {
|
|
hashMode: false,
|
|
scrollBehaviorType: "auto"
|
|
};
|
|
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,
|
|
statusCode: result && result.statusCode || 404,
|
|
statusMessage: result && result.statusMessage || `Page Not Found: ${to.fullPath}`,
|
|
data: {
|
|
path: to.fullPath
|
|
}
|
|
});
|
|
return error;
|
|
});
|
|
const globalMiddleware = [
|
|
validate
|
|
];
|
|
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) => {
|
|
if (to.matched.at(-1)?.components?.default === from.matched.at(-1)?.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: {}
|
|
};
|
|
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;
|
|
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);
|
|
}
|
|
}
|
|
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({
|
|
statusCode: 404,
|
|
statusMessage: `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) {
|
|
return nuxtApp.runWithContext(() => showError(createError({
|
|
statusCode: 404,
|
|
fatal: false,
|
|
statusMessage: `Page not found: ${to.fullPath}`,
|
|
data: {
|
|
path: to.fullPath
|
|
}
|
|
})));
|
|
}
|
|
});
|
|
nuxtApp.hooks.hookOnce("app:created", async () => {
|
|
try {
|
|
if ("name" in resolvedInitialRoute) {
|
|
resolvedInitialRoute.name = void 0;
|
|
}
|
|
await router.replace({
|
|
...resolvedInitialRoute,
|
|
force: true
|
|
});
|
|
router.options.scrollBehavior = routerOptions.scrollBehavior;
|
|
} catch (error2) {
|
|
await nuxtApp.runWithContext(() => showError(error2));
|
|
}
|
|
});
|
|
return { provide: { router } };
|
|
}
|
|
});
|
|
function injectHead(nuxtApp) {
|
|
const nuxt = nuxtApp || useNuxtApp();
|
|
return nuxt.ssrContext?.head || nuxt.runWithContext(() => {
|
|
if (hasInjectionContext()) {
|
|
const head = inject(headSymbol);
|
|
if (!head) {
|
|
throw new Error("[nuxt] [unhead] Missing Unhead instance.");
|
|
}
|
|
return head;
|
|
}
|
|
});
|
|
}
|
|
function useHead(input, options = {}) {
|
|
const head = options.head || injectHead(options.nuxt);
|
|
return useHead$1(input, { head, ...options });
|
|
}
|
|
function useSeoMeta(input, options = {}) {
|
|
const head = options.head || injectHead(options.nuxt);
|
|
return useSeoMeta$1(input, { head, ...options });
|
|
}
|
|
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_uqEpBSESdniTFxz7_FKR_ivErgLVBox145kLiayDpy8 = /* @__PURE__ */ defineNuxtPlugin({
|
|
name: "nuxt:revive-payload:server",
|
|
setup() {
|
|
for (const [reducer, fn] of reducers) {
|
|
definePayloadReducer(reducer, fn);
|
|
}
|
|
}
|
|
});
|
|
const LazyProseA = defineAsyncComponent(() => import('./ProseA-DDsnum9F.mjs').then((r) => r["default"] || r.default || r));
|
|
const LazyProseBlockquote = defineAsyncComponent(() => import('./ProseBlockquote-CayFHhs2.mjs').then((r) => r["default"] || r.default || r));
|
|
const LazyProseCode = defineAsyncComponent(() => import('./ProseCode-HLgL7sXg.mjs').then((r) => r["default"] || r.default || r));
|
|
const LazyProseEm = defineAsyncComponent(() => import('./ProseEm-kW4GpWSe.mjs').then((r) => r["default"] || r.default || r));
|
|
const LazyProseH1 = defineAsyncComponent(() => import('./ProseH1-B8Gaqr9R.mjs').then((r) => r["default"] || r.default || r));
|
|
const LazyProseH2 = defineAsyncComponent(() => import('./ProseH2-BrCjL_dH.mjs').then((r) => r["default"] || r.default || r));
|
|
const LazyProseH3 = defineAsyncComponent(() => import('./ProseH3-DvNJAiID.mjs').then((r) => r["default"] || r.default || r));
|
|
const LazyProseH4 = defineAsyncComponent(() => import('./ProseH4-EhNmreYS.mjs').then((r) => r["default"] || r.default || r));
|
|
const LazyProseH5 = defineAsyncComponent(() => import('./ProseH5-D-4PhYNE.mjs').then((r) => r["default"] || r.default || r));
|
|
const LazyProseH6 = defineAsyncComponent(() => import('./ProseH6-5ccgq34t.mjs').then((r) => r["default"] || r.default || r));
|
|
const LazyProseHr = defineAsyncComponent(() => import('./ProseHr-DJpbLfKw.mjs').then((r) => r["default"] || r.default || r));
|
|
const LazyProseImg = defineAsyncComponent(() => import('./ProseImg-CQldQXCh.mjs').then((r) => r["default"] || r.default || r));
|
|
const LazyProseLi = defineAsyncComponent(() => import('./ProseLi-BHcRglpP.mjs').then((r) => r["default"] || r.default || r));
|
|
const LazyProseOl = defineAsyncComponent(() => import('./ProseOl-BzuM7e93.mjs').then((r) => r["default"] || r.default || r));
|
|
const LazyProseP = defineAsyncComponent(() => import('./ProseP-BJ_CC903.mjs').then((r) => r["default"] || r.default || r));
|
|
const LazyProsePre = defineAsyncComponent(() => import('./ProsePre-k3evsb7j.mjs').then((r) => r["default"] || r.default || r));
|
|
const LazyProseScript = defineAsyncComponent(() => import('./ProseScript-DCuYMpw2.mjs').then((r) => r["default"] || r.default || r));
|
|
const LazyProseStrong = defineAsyncComponent(() => import('./ProseStrong-DEtiyBs6.mjs').then((r) => r["default"] || r.default || r));
|
|
const LazyProseTable = defineAsyncComponent(() => import('./ProseTable-_BTkYJX5.mjs').then((r) => r["default"] || r.default || r));
|
|
const LazyProseTbody = defineAsyncComponent(() => import('./ProseTbody-DAzESFO3.mjs').then((r) => r["default"] || r.default || r));
|
|
const LazyProseTd = defineAsyncComponent(() => import('./ProseTd-Cz-NZ1lK.mjs').then((r) => r["default"] || r.default || r));
|
|
const LazyProseTh = defineAsyncComponent(() => import('./ProseTh-CSqbMEKX.mjs').then((r) => r["default"] || r.default || r));
|
|
const LazyProseThead = defineAsyncComponent(() => import('./ProseThead-BUjOagnR.mjs').then((r) => r["default"] || r.default || r));
|
|
const LazyProseTr = defineAsyncComponent(() => import('./ProseTr-DW-ktPU4.mjs').then((r) => r["default"] || r.default || r));
|
|
const LazyProseUl = defineAsyncComponent(() => import('./ProseUl-CIrluWCJ.mjs').then((r) => r["default"] || r.default || r));
|
|
const lazyGlobalComponents = [
|
|
["ProseA", LazyProseA],
|
|
["ProseBlockquote", LazyProseBlockquote],
|
|
["ProseCode", LazyProseCode],
|
|
["ProseEm", LazyProseEm],
|
|
["ProseH1", LazyProseH1],
|
|
["ProseH2", LazyProseH2],
|
|
["ProseH3", LazyProseH3],
|
|
["ProseH4", LazyProseH4],
|
|
["ProseH5", LazyProseH5],
|
|
["ProseH6", LazyProseH6],
|
|
["ProseHr", LazyProseHr],
|
|
["ProseImg", LazyProseImg],
|
|
["ProseLi", LazyProseLi],
|
|
["ProseOl", LazyProseOl],
|
|
["ProseP", LazyProseP],
|
|
["ProsePre", LazyProsePre],
|
|
["ProseScript", LazyProseScript],
|
|
["ProseStrong", LazyProseStrong],
|
|
["ProseTable", LazyProseTable],
|
|
["ProseTbody", LazyProseTbody],
|
|
["ProseTd", LazyProseTd],
|
|
["ProseTh", LazyProseTh],
|
|
["ProseThead", LazyProseThead],
|
|
["ProseTr", LazyProseTr],
|
|
["ProseUl", LazyProseUl]
|
|
];
|
|
const components_plugin_4kY4pyzJIYX99vmMAAIorFf3CnAaptHitJgf7JxiED8 = /* @__PURE__ */ defineNuxtPlugin({
|
|
name: "nuxt:global-components",
|
|
setup(nuxtApp) {
|
|
for (const [name, component] of lazyGlobalComponents) {
|
|
nuxtApp.vueApp.component(name, component);
|
|
nuxtApp.vueApp.component("Lazy" + name, component);
|
|
}
|
|
}
|
|
});
|
|
function parseStyleTags(styleHTML) {
|
|
const tags = [];
|
|
const styleTagRe = /<style([^>]*)>([\s\S]*?)<\/style>/gi;
|
|
let match;
|
|
while (match = styleTagRe.exec(styleHTML)) {
|
|
const rawAttrs = (match[1] || "").trim();
|
|
const children = match[2] || "";
|
|
const props = { children };
|
|
const attrRe = /([^\s=]+)\s*=\s*"([^"]*)"/g;
|
|
let a;
|
|
while (a = attrRe.exec(rawAttrs)) {
|
|
const key = a[1];
|
|
const value = a[2];
|
|
props[key] = value;
|
|
}
|
|
tags.push(props);
|
|
}
|
|
return tags;
|
|
}
|
|
const antd_EbTWzn70I_tfBTnrt9_8gcrW1N1DfdE0Vc_cH_mRleg = /* @__PURE__ */ defineNuxtPlugin((nuxtApp) => {
|
|
nuxtApp.vueApp.use(Antd);
|
|
const cssinjsCache = createCache();
|
|
nuxtApp.vueApp.config.globalProperties.__ANTDV_CSSINJS_CACHE__ = cssinjsCache;
|
|
{
|
|
nuxtApp.hook("app:rendered", ({ ssrContext }) => {
|
|
if (!ssrContext) return;
|
|
const styleText = extractStyle(cssinjsCache);
|
|
const styleTags = parseStyleTags(styleText);
|
|
if (styleTags.length) {
|
|
ssrContext.head.push({ style: styleTags });
|
|
}
|
|
});
|
|
}
|
|
});
|
|
function useRequestEvent(nuxtApp) {
|
|
nuxtApp ||= useNuxtApp();
|
|
return nuxtApp.ssrContext?.event;
|
|
}
|
|
function useRequestFetch() {
|
|
return useRequestEvent()?.$fetch || globalThis.$fetch;
|
|
}
|
|
const prerender_server_W44kr8fRA3HgDTvI7hRSGVIIgKKsG3sVE3mTSsg29ws = /* @__PURE__ */ defineNuxtPlugin(async () => {
|
|
{
|
|
return;
|
|
}
|
|
});
|
|
const plugins = [
|
|
unhead__ymL50Gnw4LMhG971h5jZDnuGBbLmnj_x6wFrgJrk8Y,
|
|
plugin,
|
|
revive_payload_server_uqEpBSESdniTFxz7_FKR_ivErgLVBox145kLiayDpy8,
|
|
components_plugin_4kY4pyzJIYX99vmMAAIorFf3CnAaptHitJgf7JxiED8,
|
|
antd_EbTWzn70I_tfBTnrt9_8gcrW1N1DfdE0Vc_cH_mRleg,
|
|
prerender_server_W44kr8fRA3HgDTvI7hRSGVIIgKKsG3sVE3mTSsg29ws
|
|
];
|
|
defineComponent({
|
|
name: "ServerPlaceholder",
|
|
render() {
|
|
return createElementBlock("div");
|
|
}
|
|
});
|
|
const clientOnlySymbol = /* @__PURE__ */ Symbol.for("nuxt:client-only");
|
|
const __nuxt_component_0$1 = defineComponent({
|
|
name: "ClientOnly",
|
|
inheritAttrs: false,
|
|
props: ["fallback", "placeholder", "placeholderTag", "fallbackTag"],
|
|
...false,
|
|
setup(props, { slots, attrs }) {
|
|
const mounted = shallowRef(false);
|
|
const vm = getCurrentInstance();
|
|
if (vm) {
|
|
vm._nuxtClientOnly = true;
|
|
}
|
|
provide(clientOnlySymbol, true);
|
|
return () => {
|
|
if (mounted.value) {
|
|
const vnodes = slots.default?.();
|
|
if (vnodes && vnodes.length === 1) {
|
|
return [cloneVNode(vnodes[0], attrs)];
|
|
}
|
|
return vnodes;
|
|
}
|
|
const slot = slots.fallback || slots.placeholder;
|
|
if (slot) {
|
|
return h(slot);
|
|
}
|
|
const fallbackStr = props.fallback || props.placeholder || "";
|
|
const fallbackTag = props.fallbackTag || props.placeholderTag || "span";
|
|
return createElementBlock(fallbackTag, attrs, fallbackStr);
|
|
};
|
|
}
|
|
});
|
|
const SERVER_API_URL = "/api/_server";
|
|
const MODULES_API_URL = "/api/_modules";
|
|
const APP_API_URL = "/api/app";
|
|
const TEMPLATE_ID = "5";
|
|
const _sfc_main$2 = /* @__PURE__ */ defineComponent({
|
|
__name: "app",
|
|
__ssrInlineRender: true,
|
|
setup(__props) {
|
|
dayjs.locale("zh-cn");
|
|
return (_ctx, _push, _parent, _attrs) => {
|
|
const _component_ClientOnly = __nuxt_component_0$1;
|
|
_push(ssrRenderComponent(_component_ClientOnly, _attrs, {}, _parent));
|
|
};
|
|
}
|
|
});
|
|
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 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(() => !!props.target && props.target !== "_self");
|
|
const isAbsoluteUrl = computed(() => {
|
|
const path = props.to || 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 (props.external) {
|
|
return true;
|
|
}
|
|
const path = props.to || props.href || "";
|
|
if (typeof path === "object") {
|
|
return false;
|
|
}
|
|
return path === "" || isAbsoluteUrl.value;
|
|
});
|
|
const to = computed(() => {
|
|
const path = props.to || props.href || "";
|
|
if (isExternal.value) {
|
|
return path;
|
|
}
|
|
return resolveTrailingSlashBehavior(path, router.resolve, props.trailingSlash);
|
|
});
|
|
const link = isExternal.value ? void 0 : useBuiltinLink?.({ ...props, to });
|
|
const href = computed(() => {
|
|
const effectiveTrailingSlash = 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: 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: (event) => {
|
|
if (isExternal.value || hasTarget.value) {
|
|
return;
|
|
}
|
|
event.preventDefault();
|
|
return props.replace ? router.replace(href.value) : router.push(href.value);
|
|
}
|
|
}, 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 _sfc_main$1 = /* @__PURE__ */ defineComponent({
|
|
__name: "error",
|
|
__ssrInlineRender: true,
|
|
props: {
|
|
error: {}
|
|
},
|
|
setup(__props) {
|
|
const props = __props;
|
|
const errorCode = computed(() => props.error?.statusCode || 404);
|
|
const errorTitle = computed(() => {
|
|
switch (errorCode.value) {
|
|
case 403:
|
|
return "没有访问权限";
|
|
case 404:
|
|
return "页面不存在";
|
|
case 500:
|
|
return "服务器错误";
|
|
default:
|
|
return "出错了";
|
|
}
|
|
});
|
|
const errorDesc = computed(() => {
|
|
switch (errorCode.value) {
|
|
case 403:
|
|
return "抱歉，您没有权限访问此页面";
|
|
case 404:
|
|
return "抱歉，您访问的页面不存在或已被删除";
|
|
case 500:
|
|
return "抱歉，服务器发生了一些问题，请稍后再试";
|
|
default:
|
|
return "抱歉，发生了一些未知错误";
|
|
}
|
|
});
|
|
function goHome() {
|
|
clearError({ redirect: "/" });
|
|
}
|
|
function goBack() {
|
|
clearError({ redirect: "/" });
|
|
}
|
|
useHead({
|
|
title: computed(() => `${errorCode.value} - ${errorTitle.value} | 广西决策咨询网`)
|
|
});
|
|
return (_ctx, _push, _parent, _attrs) => {
|
|
const _component_a_button = resolveComponent("a-button");
|
|
const _component_NuxtLink = __nuxt_component_0;
|
|
_push(`<div${ssrRenderAttrs(mergeProps({ class: "error-page" }, _attrs))} data-v-b952a4cf><div class="error-content" data-v-b952a4cf><div class="error-bg" data-v-b952a4cf><div class="bg-circle circle-1" data-v-b952a4cf></div><div class="bg-circle circle-2" data-v-b952a4cf></div><div class="bg-circle circle-3" data-v-b952a4cf></div></div><div class="error-main" data-v-b952a4cf><div class="error-code" data-v-b952a4cf>${ssrInterpolate(__props.error?.statusCode || 404)}</div><div class="error-title" data-v-b952a4cf>${ssrInterpolate(unref(errorTitle))}</div><div class="error-desc" data-v-b952a4cf>${ssrInterpolate(unref(errorDesc))}</div><div class="error-actions" data-v-b952a4cf>`);
|
|
_push(ssrRenderComponent(_component_a_button, {
|
|
type: "primary",
|
|
size: "large",
|
|
onClick: goHome
|
|
}, {
|
|
default: withCtx((_, _push2, _parent2, _scopeId) => {
|
|
if (_push2) {
|
|
_push2(` 🏠 返回首页 `);
|
|
} else {
|
|
return [
|
|
createTextVNode(" 🏠 返回首页 ")
|
|
];
|
|
}
|
|
}),
|
|
_: 1
|
|
}, _parent));
|
|
_push(ssrRenderComponent(_component_a_button, {
|
|
size: "large",
|
|
onClick: goBack
|
|
}, {
|
|
default: withCtx((_, _push2, _parent2, _scopeId) => {
|
|
if (_push2) {
|
|
_push2(` ← 返回上一页 `);
|
|
} else {
|
|
return [
|
|
createTextVNode(" ← 返回上一页 ")
|
|
];
|
|
}
|
|
}),
|
|
_: 1
|
|
}, _parent));
|
|
_push(`</div><div class="quick-nav-section" data-v-b952a4cf><div class="quick-nav-title" data-v-b952a4cf>您可能想访问</div><div class="quick-nav-grid" data-v-b952a4cf>`);
|
|
_push(ssrRenderComponent(_component_NuxtLink, {
|
|
to: "/",
|
|
class: "quick-nav-item"
|
|
}, {
|
|
default: withCtx((_, _push2, _parent2, _scopeId) => {
|
|
if (_push2) {
|
|
_push2(`首页`);
|
|
} else {
|
|
return [
|
|
createTextVNode("首页")
|
|
];
|
|
}
|
|
}),
|
|
_: 1
|
|
}, _parent));
|
|
_push(ssrRenderComponent(_component_NuxtLink, {
|
|
to: "/news",
|
|
class: "quick-nav-item"
|
|
}, {
|
|
default: withCtx((_, _push2, _parent2, _scopeId) => {
|
|
if (_push2) {
|
|
_push2(`政策要闻`);
|
|
} else {
|
|
return [
|
|
createTextVNode("政策要闻")
|
|
];
|
|
}
|
|
}),
|
|
_: 1
|
|
}, _parent));
|
|
_push(ssrRenderComponent(_component_NuxtLink, {
|
|
to: "/consultation",
|
|
class: "quick-nav-item"
|
|
}, {
|
|
default: withCtx((_, _push2, _parent2, _scopeId) => {
|
|
if (_push2) {
|
|
_push2(`决策咨询`);
|
|
} else {
|
|
return [
|
|
createTextVNode("决策咨询")
|
|
];
|
|
}
|
|
}),
|
|
_: 1
|
|
}, _parent));
|
|
_push(ssrRenderComponent(_component_NuxtLink, {
|
|
to: "/expert",
|
|
class: "quick-nav-item"
|
|
}, {
|
|
default: withCtx((_, _push2, _parent2, _scopeId) => {
|
|
if (_push2) {
|
|
_push2(`专家资讯`);
|
|
} else {
|
|
return [
|
|
createTextVNode("专家资讯")
|
|
];
|
|
}
|
|
}),
|
|
_: 1
|
|
}, _parent));
|
|
_push(ssrRenderComponent(_component_NuxtLink, {
|
|
to: "/think-tank",
|
|
class: "quick-nav-item"
|
|
}, {
|
|
default: withCtx((_, _push2, _parent2, _scopeId) => {
|
|
if (_push2) {
|
|
_push2(`智库观察`);
|
|
} else {
|
|
return [
|
|
createTextVNode("智库观察")
|
|
];
|
|
}
|
|
}),
|
|
_: 1
|
|
}, _parent));
|
|
_push(ssrRenderComponent(_component_NuxtLink, {
|
|
to: "/suggestions",
|
|
class: "quick-nav-item"
|
|
}, {
|
|
default: withCtx((_, _push2, _parent2, _scopeId) => {
|
|
if (_push2) {
|
|
_push2(`建言献策`);
|
|
} else {
|
|
return [
|
|
createTextVNode("建言献策")
|
|
];
|
|
}
|
|
}),
|
|
_: 1
|
|
}, _parent));
|
|
_push(ssrRenderComponent(_component_NuxtLink, {
|
|
to: "/about",
|
|
class: "quick-nav-item"
|
|
}, {
|
|
default: withCtx((_, _push2, _parent2, _scopeId) => {
|
|
if (_push2) {
|
|
_push2(`关于我们`);
|
|
} else {
|
|
return [
|
|
createTextVNode("关于我们")
|
|
];
|
|
}
|
|
}),
|
|
_: 1
|
|
}, _parent));
|
|
_push(ssrRenderComponent(_component_NuxtLink, {
|
|
to: "/membership",
|
|
class: "quick-nav-item"
|
|
}, {
|
|
default: withCtx((_, _push2, _parent2, _scopeId) => {
|
|
if (_push2) {
|
|
_push2(`会员服务`);
|
|
} else {
|
|
return [
|
|
createTextVNode("会员服务")
|
|
];
|
|
}
|
|
}),
|
|
_: 1
|
|
}, _parent));
|
|
_push(`</div></div></div></div></div>`);
|
|
};
|
|
}
|
|
});
|
|
const _export_sfc = (sfc, props) => {
|
|
const target = sfc.__vccOpts || sfc;
|
|
for (const [key, val] of props) {
|
|
target[key] = val;
|
|
}
|
|
return target;
|
|
};
|
|
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("error.vue");
|
|
return _sfc_setup$1 ? _sfc_setup$1(props, ctx) : void 0;
|
|
};
|
|
const ErrorComponent = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__scopeId", "data-v-b952a4cf"]]);
|
|
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;
|
|
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);
|
|
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(ErrorComponent), { 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(_sfc_main$2), 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/.pnpm/nuxt@4.2.2_@parcel+watcher@2.5.1_@types+node@25.0.3_@vue+compiler-sfc@3.5.26_better-sql_ac6a4d57fe59bc83c2ad1951937f70f6/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?._renderResponse) {
|
|
throw new Error("skipping render");
|
|
}
|
|
return vueApp;
|
|
};
|
|
}
|
|
const entry_default = (ssrContext) => entry(ssrContext);
|
|
|
|
export { APP_API_URL as A, MODULES_API_URL as M, SERVER_API_URL as S, TEMPLATE_ID as T, __nuxt_component_0 as _, _export_sfc as a, useSeoMeta as b, useHead as c, useRouter as d, entry_default as default, useRoute as e, useRequestFetch as f, useRuntimeConfig as g, useNuxtApp as h, asyncDataDefaults as i, createError as j, navigateTo as n, useRequestEvent as u };
|
|
//# sourceMappingURL=server.mjs.map
|