7899 lines
253 KiB
JavaScript
7899 lines
253 KiB
JavaScript
import process from 'node:process';globalThis._importMeta_={url:import.meta.url,env:process.env};import { tmpdir } from 'node:os';
|
||
import { defineEventHandler, handleCacheHeaders, splitCookiesString, createEvent, fetchWithEvent, isEvent, eventHandler, setHeaders, createError, sendRedirect, proxyRequest, getRequestHeader, setResponseHeaders, setResponseStatus, send, getRequestHeaders, setResponseHeader, appendResponseHeader, getRequestURL, getResponseHeader, getResponseStatus, getCookie, setCookie, sanitizeStatusCode, removeResponseHeader, getRouterParam, getQuery as getQuery$1, readBody, createApp, createRouter as createRouter$1, toNodeListener, lazyEventHandler, getResponseStatusText } from 'file:///app/node_modules/h3/dist/index.mjs';
|
||
import { Server } from 'node:http';
|
||
import { resolve, dirname, join } from 'node:path';
|
||
import crypto$1 from 'node:crypto';
|
||
import { parentPort, threadId } from 'node:worker_threads';
|
||
import { escapeHtml } from 'file:///app/node_modules/@vue/shared/dist/shared.cjs.js';
|
||
import viteNodeEntry_mjs from 'file:///app/node_modules/@nuxt/vite-builder/dist/vite-node-entry.mjs';
|
||
import { viteNodeFetch } from 'file:///app/node_modules/@nuxt/vite-builder/dist/vite-node.mjs';
|
||
import { createRenderer, getRequestDependencies, getPreloadLinks, getPrefetchLinks } from 'file:///app/node_modules/vue-bundle-renderer/dist/runtime.mjs';
|
||
import { parseURL, withoutBase, joinURL, getQuery, withQuery, joinRelativeURL, parsePath, withLeadingSlash, withoutTrailingSlash, withTrailingSlash, decodePath, encodePath } from 'file:///app/node_modules/ufo/dist/index.mjs';
|
||
import { renderToString } from 'file:///app/node_modules/vue/server-renderer/index.mjs';
|
||
import destr, { destr as destr$1 } from 'file:///app/node_modules/destr/dist/index.mjs';
|
||
import { createHooks } from 'file:///app/node_modules/hookable/dist/index.mjs';
|
||
import { createFetch, Headers as Headers$1 } from 'file:///app/node_modules/ofetch/dist/node.mjs';
|
||
import { fetchNodeRequestHandler, callNodeRequestHandler } from 'file:///app/node_modules/node-mock-http/dist/index.mjs';
|
||
import { createStorage, defineDriver, prefixStorage } from 'file:///app/node_modules/unstorage/dist/index.mjs';
|
||
import unstorage_47drivers_47fs from 'file:///app/node_modules/unstorage/drivers/fs.mjs';
|
||
import fsDriver from 'file:///app/node_modules/unstorage/drivers/fs-lite.mjs';
|
||
import lruCache from 'file:///app/node_modules/unstorage/drivers/lru-cache.mjs';
|
||
import { digest, hash as hash$1 } from 'file:///app/node_modules/ohash/dist/index.mjs';
|
||
import { klona } from 'file:///app/node_modules/klona/dist/index.mjs';
|
||
import defu, { defuFn, createDefu } from 'file:///app/node_modules/defu/dist/defu.mjs';
|
||
import { snakeCase } from 'file:///app/node_modules/scule/dist/index.mjs';
|
||
import { getContext } from 'file:///app/node_modules/unctx/dist/index.mjs';
|
||
import { toRouteMatcher, createRouter } from 'file:///app/node_modules/radix3/dist/index.mjs';
|
||
import { readFile } from 'node:fs/promises';
|
||
import consola, { consola as consola$1 } from 'file:///app/node_modules/consola/dist/index.mjs';
|
||
import { ErrorParser } from 'file:///app/node_modules/youch-core/build/index.js';
|
||
import { Youch } from 'file:///app/node_modules/youch/build/index.js';
|
||
import { SourceMapConsumer } from 'file:///app/node_modules/source-map/source-map.js';
|
||
import { createRouterMatcher } from 'file:///app/node_modules/@nuxtjs/i18n/node_modules/vue-router/vue-router.node.mjs';
|
||
import { AsyncLocalStorage } from 'node:async_hooks';
|
||
import { stringify, uneval } from 'file:///app/node_modules/devalue/index.js';
|
||
import { captureRawStackTrace, parseRawStackTrace } from 'file:///app/node_modules/errx/dist/index.js';
|
||
import { isVNode, isRef, toValue } from 'file:///app/node_modules/vue/index.mjs';
|
||
import _wH6JrtIxmaSoA8lCPWFnE9z4lQeXW6H5z3l5aymEQw from 'file:///app/node_modules/@nuxt/vite-builder/dist/fix-stacktrace.mjs';
|
||
import { promises } from 'node:fs';
|
||
import { fileURLToPath } from 'node:url';
|
||
import { dirname as dirname$1, resolve as resolve$1 } from 'file:///app/node_modules/pathe/dist/index.mjs';
|
||
import { createHead as createHead$1, propsToString, renderSSRHead } from 'file:///app/node_modules/unhead/dist/server.mjs';
|
||
import { DeprecationsPlugin, PromisesPlugin, TemplateParamsPlugin, AliasSortingPlugin } from 'file:///app/node_modules/unhead/dist/plugins.mjs';
|
||
import { walkResolver } from 'file:///app/node_modules/unhead/dist/utils.mjs';
|
||
|
||
const serverAssets = [{"baseName":"server","dir":"/app/server/assets"}];
|
||
|
||
const assets$1 = createStorage();
|
||
|
||
for (const asset of serverAssets) {
|
||
assets$1.mount(asset.baseName, unstorage_47drivers_47fs({ base: asset.dir, ignore: (asset?.ignore || []) }));
|
||
}
|
||
|
||
// @ts-check
|
||
|
||
|
||
/**
|
||
* @param {string} item
|
||
*/
|
||
function normalizeFsKey (item) {
|
||
const safe = item.replace(/[^\w.-]/g, '_');
|
||
const prefix = safe.slice(0, 20);
|
||
const hash = crypto$1.createHash('sha256').update(item).digest('hex');
|
||
return `${prefix}-${hash}`
|
||
}
|
||
|
||
const _47app_47node_modules_47_64nuxt_47nitro_45server_47dist_47runtime_47utils_47cache_45driver_46js = defineDriver(
|
||
/**
|
||
* @param {{ base?: string }} opts
|
||
*/
|
||
(opts) => {
|
||
const fs = fsDriver({ base: opts.base });
|
||
const lru = lruCache({ max: 1000 });
|
||
|
||
return {
|
||
...fs, // fall back to file system - only the bottom three methods are used in renderer
|
||
async setItem (key, value, opts) {
|
||
await Promise.all([
|
||
fs.setItem?.(normalizeFsKey(key), value, opts),
|
||
lru.setItem?.(key, value, opts),
|
||
]);
|
||
},
|
||
async hasItem (key, opts) {
|
||
return await lru.hasItem(key, opts) || await fs.hasItem(normalizeFsKey(key), opts)
|
||
},
|
||
async getItem (key, opts) {
|
||
return await lru.getItem(key, opts) || await fs.getItem(normalizeFsKey(key), opts)
|
||
},
|
||
}
|
||
},
|
||
);
|
||
|
||
const storage$1 = createStorage({});
|
||
|
||
storage$1.mount('/assets', assets$1);
|
||
|
||
storage$1.mount('root', unstorage_47drivers_47fs({"driver":"fs","readOnly":true,"base":"/app","watchOptions":{"ignored":[null]}}));
|
||
storage$1.mount('src', unstorage_47drivers_47fs({"driver":"fs","readOnly":true,"base":"/app/server","watchOptions":{"ignored":[null]}}));
|
||
storage$1.mount('cache:nuxt:payload', _47app_47node_modules_47_64nuxt_47nitro_45server_47dist_47runtime_47utils_47cache_45driver_46js({"driver":"/app/node_modules/@nuxt/nitro-server/dist/runtime/utils/cache-driver.js","base":"/app/.nuxt/cache/nuxt/payload"}));
|
||
storage$1.mount('build', unstorage_47drivers_47fs({"driver":"fs","readOnly":false,"base":"/app/.nuxt"}));
|
||
storage$1.mount('cache', unstorage_47drivers_47fs({"driver":"fs","readOnly":false,"base":"/app/.nuxt/cache"}));
|
||
storage$1.mount('data', unstorage_47drivers_47fs({"driver":"fs","base":"/app/.data/kv"}));
|
||
|
||
function useStorage(base = "") {
|
||
return base ? prefixStorage(storage$1, base) : storage$1;
|
||
}
|
||
|
||
const Hasher = /* @__PURE__ */ (() => {
|
||
class Hasher2 {
|
||
buff = "";
|
||
#context = /* @__PURE__ */ new Map();
|
||
write(str) {
|
||
this.buff += str;
|
||
}
|
||
dispatch(value) {
|
||
const type = value === null ? "null" : typeof value;
|
||
return this[type](value);
|
||
}
|
||
object(object) {
|
||
if (object && typeof object.toJSON === "function") {
|
||
return this.object(object.toJSON());
|
||
}
|
||
const objString = Object.prototype.toString.call(object);
|
||
let objType = "";
|
||
const objectLength = objString.length;
|
||
objType = objectLength < 10 ? "unknown:[" + objString + "]" : objString.slice(8, objectLength - 1);
|
||
objType = objType.toLowerCase();
|
||
let objectNumber = null;
|
||
if ((objectNumber = this.#context.get(object)) === void 0) {
|
||
this.#context.set(object, this.#context.size);
|
||
} else {
|
||
return this.dispatch("[CIRCULAR:" + objectNumber + "]");
|
||
}
|
||
if (typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(object)) {
|
||
this.write("buffer:");
|
||
return this.write(object.toString("utf8"));
|
||
}
|
||
if (objType !== "object" && objType !== "function" && objType !== "asyncfunction") {
|
||
if (this[objType]) {
|
||
this[objType](object);
|
||
} else {
|
||
this.unknown(object, objType);
|
||
}
|
||
} else {
|
||
const keys = Object.keys(object).sort();
|
||
const extraKeys = [];
|
||
this.write("object:" + (keys.length + extraKeys.length) + ":");
|
||
const dispatchForKey = (key) => {
|
||
this.dispatch(key);
|
||
this.write(":");
|
||
this.dispatch(object[key]);
|
||
this.write(",");
|
||
};
|
||
for (const key of keys) {
|
||
dispatchForKey(key);
|
||
}
|
||
for (const key of extraKeys) {
|
||
dispatchForKey(key);
|
||
}
|
||
}
|
||
}
|
||
array(arr, unordered) {
|
||
unordered = unordered === void 0 ? false : unordered;
|
||
this.write("array:" + arr.length + ":");
|
||
if (!unordered || arr.length <= 1) {
|
||
for (const entry of arr) {
|
||
this.dispatch(entry);
|
||
}
|
||
return;
|
||
}
|
||
const contextAdditions = /* @__PURE__ */ new Map();
|
||
const entries = arr.map((entry) => {
|
||
const hasher = new Hasher2();
|
||
hasher.dispatch(entry);
|
||
for (const [key, value] of hasher.#context) {
|
||
contextAdditions.set(key, value);
|
||
}
|
||
return hasher.toString();
|
||
});
|
||
this.#context = contextAdditions;
|
||
entries.sort();
|
||
return this.array(entries, false);
|
||
}
|
||
date(date) {
|
||
return this.write("date:" + date.toJSON());
|
||
}
|
||
symbol(sym) {
|
||
return this.write("symbol:" + sym.toString());
|
||
}
|
||
unknown(value, type) {
|
||
this.write(type);
|
||
if (!value) {
|
||
return;
|
||
}
|
||
this.write(":");
|
||
if (value && typeof value.entries === "function") {
|
||
return this.array(
|
||
[...value.entries()],
|
||
true
|
||
/* ordered */
|
||
);
|
||
}
|
||
}
|
||
error(err) {
|
||
return this.write("error:" + err.toString());
|
||
}
|
||
boolean(bool) {
|
||
return this.write("bool:" + bool);
|
||
}
|
||
string(string) {
|
||
this.write("string:" + string.length + ":");
|
||
this.write(string);
|
||
}
|
||
function(fn) {
|
||
this.write("fn:");
|
||
if (isNativeFunction(fn)) {
|
||
this.dispatch("[native]");
|
||
} else {
|
||
this.dispatch(fn.toString());
|
||
}
|
||
}
|
||
number(number) {
|
||
return this.write("number:" + number);
|
||
}
|
||
null() {
|
||
return this.write("Null");
|
||
}
|
||
undefined() {
|
||
return this.write("Undefined");
|
||
}
|
||
regexp(regex) {
|
||
return this.write("regex:" + regex.toString());
|
||
}
|
||
arraybuffer(arr) {
|
||
this.write("arraybuffer:");
|
||
return this.dispatch(new Uint8Array(arr));
|
||
}
|
||
url(url) {
|
||
return this.write("url:" + url.toString());
|
||
}
|
||
map(map) {
|
||
this.write("map:");
|
||
const arr = [...map];
|
||
return this.array(arr, false);
|
||
}
|
||
set(set) {
|
||
this.write("set:");
|
||
const arr = [...set];
|
||
return this.array(arr, false);
|
||
}
|
||
bigint(number) {
|
||
return this.write("bigint:" + number.toString());
|
||
}
|
||
}
|
||
for (const type of [
|
||
"uint8array",
|
||
"uint8clampedarray",
|
||
"unt8array",
|
||
"uint16array",
|
||
"unt16array",
|
||
"uint32array",
|
||
"unt32array",
|
||
"float32array",
|
||
"float64array"
|
||
]) {
|
||
Hasher2.prototype[type] = function(arr) {
|
||
this.write(type + ":");
|
||
return this.array([...arr], false);
|
||
};
|
||
}
|
||
function isNativeFunction(f) {
|
||
if (typeof f !== "function") {
|
||
return false;
|
||
}
|
||
return Function.prototype.toString.call(f).slice(
|
||
-15
|
||
/* "[native code] }".length */
|
||
) === "[native code] }";
|
||
}
|
||
return Hasher2;
|
||
})();
|
||
function serialize(object) {
|
||
const hasher = new Hasher();
|
||
hasher.dispatch(object);
|
||
return hasher.buff;
|
||
}
|
||
function hash(value) {
|
||
return digest(typeof value === "string" ? value : serialize(value)).replace(/[-_]/g, "").slice(0, 10);
|
||
}
|
||
|
||
function defaultCacheOptions() {
|
||
return {
|
||
name: "_",
|
||
base: "/cache",
|
||
swr: true,
|
||
maxAge: 1
|
||
};
|
||
}
|
||
function defineCachedFunction(fn, opts = {}) {
|
||
opts = { ...defaultCacheOptions(), ...opts };
|
||
const pending = {};
|
||
const group = opts.group || "nitro/functions";
|
||
const name = opts.name || fn.name || "_";
|
||
const integrity = opts.integrity || hash([fn, opts]);
|
||
const validate = opts.validate || ((entry) => entry.value !== void 0);
|
||
async function get(key, resolver, shouldInvalidateCache, event) {
|
||
const cacheKey = [opts.base, group, name, key + ".json"].filter(Boolean).join(":").replace(/:\/$/, ":index");
|
||
let entry = await useStorage().getItem(cacheKey).catch((error) => {
|
||
console.error(`[cache] Cache read error.`, error);
|
||
useNitroApp().captureError(error, { event, tags: ["cache"] });
|
||
}) || {};
|
||
if (typeof entry !== "object") {
|
||
entry = {};
|
||
const error = new Error("Malformed data read from cache.");
|
||
console.error("[cache]", error);
|
||
useNitroApp().captureError(error, { event, tags: ["cache"] });
|
||
}
|
||
const ttl = (opts.maxAge ?? 0) * 1e3;
|
||
if (ttl) {
|
||
entry.expires = Date.now() + ttl;
|
||
}
|
||
const expired = shouldInvalidateCache || entry.integrity !== integrity || ttl && Date.now() - (entry.mtime || 0) > ttl || validate(entry) === false;
|
||
const _resolve = async () => {
|
||
const isPending = pending[key];
|
||
if (!isPending) {
|
||
if (entry.value !== void 0 && (opts.staleMaxAge || 0) >= 0 && opts.swr === false) {
|
||
entry.value = void 0;
|
||
entry.integrity = void 0;
|
||
entry.mtime = void 0;
|
||
entry.expires = void 0;
|
||
}
|
||
pending[key] = Promise.resolve(resolver());
|
||
}
|
||
try {
|
||
entry.value = await pending[key];
|
||
} catch (error) {
|
||
if (!isPending) {
|
||
delete pending[key];
|
||
}
|
||
throw error;
|
||
}
|
||
if (!isPending) {
|
||
entry.mtime = Date.now();
|
||
entry.integrity = integrity;
|
||
delete pending[key];
|
||
if (validate(entry) !== false) {
|
||
let setOpts;
|
||
if (opts.maxAge && !opts.swr) {
|
||
setOpts = { ttl: opts.maxAge };
|
||
}
|
||
const promise = useStorage().setItem(cacheKey, entry, setOpts).catch((error) => {
|
||
console.error(`[cache] Cache write error.`, error);
|
||
useNitroApp().captureError(error, { event, tags: ["cache"] });
|
||
});
|
||
if (event?.waitUntil) {
|
||
event.waitUntil(promise);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const _resolvePromise = expired ? _resolve() : Promise.resolve();
|
||
if (entry.value === void 0) {
|
||
await _resolvePromise;
|
||
} else if (expired && event && event.waitUntil) {
|
||
event.waitUntil(_resolvePromise);
|
||
}
|
||
if (opts.swr && validate(entry) !== false) {
|
||
_resolvePromise.catch((error) => {
|
||
console.error(`[cache] SWR handler error.`, error);
|
||
useNitroApp().captureError(error, { event, tags: ["cache"] });
|
||
});
|
||
return entry;
|
||
}
|
||
return _resolvePromise.then(() => entry);
|
||
}
|
||
return async (...args) => {
|
||
const shouldBypassCache = await opts.shouldBypassCache?.(...args);
|
||
if (shouldBypassCache) {
|
||
return fn(...args);
|
||
}
|
||
const key = await (opts.getKey || getKey)(...args);
|
||
const shouldInvalidateCache = await opts.shouldInvalidateCache?.(...args);
|
||
const entry = await get(
|
||
key,
|
||
() => fn(...args),
|
||
shouldInvalidateCache,
|
||
args[0] && isEvent(args[0]) ? args[0] : void 0
|
||
);
|
||
let value = entry.value;
|
||
if (opts.transform) {
|
||
value = await opts.transform(entry, ...args) || value;
|
||
}
|
||
return value;
|
||
};
|
||
}
|
||
function cachedFunction(fn, opts = {}) {
|
||
return defineCachedFunction(fn, opts);
|
||
}
|
||
function getKey(...args) {
|
||
return args.length > 0 ? hash(args) : "";
|
||
}
|
||
function escapeKey(key) {
|
||
return String(key).replace(/\W/g, "");
|
||
}
|
||
function defineCachedEventHandler(handler, opts = defaultCacheOptions()) {
|
||
const variableHeaderNames = (opts.varies || []).filter(Boolean).map((h) => h.toLowerCase()).sort();
|
||
const _opts = {
|
||
...opts,
|
||
getKey: async (event) => {
|
||
const customKey = await opts.getKey?.(event);
|
||
if (customKey) {
|
||
return escapeKey(customKey);
|
||
}
|
||
const _path = event.node.req.originalUrl || event.node.req.url || event.path;
|
||
let _pathname;
|
||
try {
|
||
_pathname = escapeKey(decodeURI(parseURL(_path).pathname)).slice(0, 16) || "index";
|
||
} catch {
|
||
_pathname = "-";
|
||
}
|
||
const _hashedPath = `${_pathname}.${hash(_path)}`;
|
||
const _headers = variableHeaderNames.map((header) => [header, event.node.req.headers[header]]).map(([name, value]) => `${escapeKey(name)}.${hash(value)}`);
|
||
return [_hashedPath, ..._headers].join(":");
|
||
},
|
||
validate: (entry) => {
|
||
if (!entry.value) {
|
||
return false;
|
||
}
|
||
if (entry.value.code >= 400) {
|
||
return false;
|
||
}
|
||
if (entry.value.body === void 0) {
|
||
return false;
|
||
}
|
||
if (entry.value.headers.etag === "undefined" || entry.value.headers["last-modified"] === "undefined") {
|
||
return false;
|
||
}
|
||
return true;
|
||
},
|
||
group: opts.group || "nitro/handlers",
|
||
integrity: opts.integrity || hash([handler, opts])
|
||
};
|
||
const _cachedHandler = cachedFunction(
|
||
async (incomingEvent) => {
|
||
const variableHeaders = {};
|
||
for (const header of variableHeaderNames) {
|
||
const value = incomingEvent.node.req.headers[header];
|
||
if (value !== void 0) {
|
||
variableHeaders[header] = value;
|
||
}
|
||
}
|
||
const reqProxy = cloneWithProxy(incomingEvent.node.req, {
|
||
headers: variableHeaders
|
||
});
|
||
const resHeaders = {};
|
||
let _resSendBody;
|
||
const resProxy = cloneWithProxy(incomingEvent.node.res, {
|
||
statusCode: 200,
|
||
writableEnded: false,
|
||
writableFinished: false,
|
||
headersSent: false,
|
||
closed: false,
|
||
getHeader(name) {
|
||
return resHeaders[name];
|
||
},
|
||
setHeader(name, value) {
|
||
resHeaders[name] = value;
|
||
return this;
|
||
},
|
||
getHeaderNames() {
|
||
return Object.keys(resHeaders);
|
||
},
|
||
hasHeader(name) {
|
||
return name in resHeaders;
|
||
},
|
||
removeHeader(name) {
|
||
delete resHeaders[name];
|
||
},
|
||
getHeaders() {
|
||
return resHeaders;
|
||
},
|
||
end(chunk, arg2, arg3) {
|
||
if (typeof chunk === "string") {
|
||
_resSendBody = chunk;
|
||
}
|
||
if (typeof arg2 === "function") {
|
||
arg2();
|
||
}
|
||
if (typeof arg3 === "function") {
|
||
arg3();
|
||
}
|
||
return this;
|
||
},
|
||
write(chunk, arg2, arg3) {
|
||
if (typeof chunk === "string") {
|
||
_resSendBody = chunk;
|
||
}
|
||
if (typeof arg2 === "function") {
|
||
arg2(void 0);
|
||
}
|
||
if (typeof arg3 === "function") {
|
||
arg3();
|
||
}
|
||
return true;
|
||
},
|
||
writeHead(statusCode, headers2) {
|
||
this.statusCode = statusCode;
|
||
if (headers2) {
|
||
if (Array.isArray(headers2) || typeof headers2 === "string") {
|
||
throw new TypeError("Raw headers is not supported.");
|
||
}
|
||
for (const header in headers2) {
|
||
const value = headers2[header];
|
||
if (value !== void 0) {
|
||
this.setHeader(
|
||
header,
|
||
value
|
||
);
|
||
}
|
||
}
|
||
}
|
||
return this;
|
||
}
|
||
});
|
||
const event = createEvent(reqProxy, resProxy);
|
||
event.fetch = (url, fetchOptions) => fetchWithEvent(event, url, fetchOptions, {
|
||
fetch: useNitroApp().localFetch
|
||
});
|
||
event.$fetch = (url, fetchOptions) => fetchWithEvent(event, url, fetchOptions, {
|
||
fetch: globalThis.$fetch
|
||
});
|
||
event.waitUntil = incomingEvent.waitUntil;
|
||
event.context = incomingEvent.context;
|
||
event.context.cache = {
|
||
options: _opts
|
||
};
|
||
const body = await handler(event) || _resSendBody;
|
||
const headers = event.node.res.getHeaders();
|
||
headers.etag = String(
|
||
headers.Etag || headers.etag || `W/"${hash(body)}"`
|
||
);
|
||
headers["last-modified"] = String(
|
||
headers["Last-Modified"] || headers["last-modified"] || (/* @__PURE__ */ new Date()).toUTCString()
|
||
);
|
||
const cacheControl = [];
|
||
if (opts.swr) {
|
||
if (opts.maxAge) {
|
||
cacheControl.push(`s-maxage=${opts.maxAge}`);
|
||
}
|
||
if (opts.staleMaxAge) {
|
||
cacheControl.push(`stale-while-revalidate=${opts.staleMaxAge}`);
|
||
} else {
|
||
cacheControl.push("stale-while-revalidate");
|
||
}
|
||
} else if (opts.maxAge) {
|
||
cacheControl.push(`max-age=${opts.maxAge}`);
|
||
}
|
||
if (cacheControl.length > 0) {
|
||
headers["cache-control"] = cacheControl.join(", ");
|
||
}
|
||
const cacheEntry = {
|
||
code: event.node.res.statusCode,
|
||
headers,
|
||
body
|
||
};
|
||
return cacheEntry;
|
||
},
|
||
_opts
|
||
);
|
||
return defineEventHandler(async (event) => {
|
||
if (opts.headersOnly) {
|
||
if (handleCacheHeaders(event, { maxAge: opts.maxAge })) {
|
||
return;
|
||
}
|
||
return handler(event);
|
||
}
|
||
const response = await _cachedHandler(
|
||
event
|
||
);
|
||
if (event.node.res.headersSent || event.node.res.writableEnded) {
|
||
return response.body;
|
||
}
|
||
if (handleCacheHeaders(event, {
|
||
modifiedTime: new Date(response.headers["last-modified"]),
|
||
etag: response.headers.etag,
|
||
maxAge: opts.maxAge
|
||
})) {
|
||
return;
|
||
}
|
||
event.node.res.statusCode = response.code;
|
||
for (const name in response.headers) {
|
||
const value = response.headers[name];
|
||
if (name === "set-cookie") {
|
||
event.node.res.appendHeader(
|
||
name,
|
||
splitCookiesString(value)
|
||
);
|
||
} else {
|
||
if (value !== void 0) {
|
||
event.node.res.setHeader(name, value);
|
||
}
|
||
}
|
||
}
|
||
return response.body;
|
||
});
|
||
}
|
||
function cloneWithProxy(obj, overrides) {
|
||
return new Proxy(obj, {
|
||
get(target, property, receiver) {
|
||
if (property in overrides) {
|
||
return overrides[property];
|
||
}
|
||
return Reflect.get(target, property, receiver);
|
||
},
|
||
set(target, property, value, receiver) {
|
||
if (property in overrides) {
|
||
overrides[property] = value;
|
||
return true;
|
||
}
|
||
return Reflect.set(target, property, value, receiver);
|
||
}
|
||
});
|
||
}
|
||
const cachedEventHandler = defineCachedEventHandler;
|
||
|
||
const inlineAppConfig = {
|
||
"nuxt": {}
|
||
};
|
||
|
||
|
||
|
||
const appConfig = defuFn(inlineAppConfig);
|
||
|
||
function getEnv(key, opts) {
|
||
const envKey = snakeCase(key).toUpperCase();
|
||
return destr(
|
||
process.env[opts.prefix + envKey] ?? process.env[opts.altPrefix + envKey]
|
||
);
|
||
}
|
||
function _isObject(input) {
|
||
return typeof input === "object" && !Array.isArray(input);
|
||
}
|
||
function applyEnv(obj, opts, parentKey = "") {
|
||
for (const key in obj) {
|
||
const subKey = parentKey ? `${parentKey}_${key}` : key;
|
||
const envValue = getEnv(subKey, opts);
|
||
if (_isObject(obj[key])) {
|
||
if (_isObject(envValue)) {
|
||
obj[key] = { ...obj[key], ...envValue };
|
||
applyEnv(obj[key], opts, subKey);
|
||
} else if (envValue === void 0) {
|
||
applyEnv(obj[key], opts, subKey);
|
||
} else {
|
||
obj[key] = envValue ?? obj[key];
|
||
}
|
||
} else {
|
||
obj[key] = envValue ?? obj[key];
|
||
}
|
||
if (opts.envExpansion && typeof obj[key] === "string") {
|
||
obj[key] = _expandFromEnv(obj[key]);
|
||
}
|
||
}
|
||
return obj;
|
||
}
|
||
const envExpandRx = /\{\{([^{}]*)\}\}/g;
|
||
function _expandFromEnv(value) {
|
||
return value.replace(envExpandRx, (match, key) => {
|
||
return process.env[key] || match;
|
||
});
|
||
}
|
||
|
||
const _inlineRuntimeConfig = {
|
||
"app": {
|
||
"baseURL": "/",
|
||
"buildId": "dev",
|
||
"buildAssetsDir": "/_nuxt/",
|
||
"cdnURL": ""
|
||
},
|
||
"nitro": {
|
||
"envPrefix": "NUXT_",
|
||
"routeRules": {
|
||
"/__nuxt_error": {
|
||
"cache": false
|
||
},
|
||
"/_nuxt/builds/meta/**": {
|
||
"headers": {
|
||
"cache-control": "public, max-age=31536000, immutable"
|
||
}
|
||
},
|
||
"/_nuxt/builds/**": {
|
||
"headers": {
|
||
"cache-control": "public, max-age=1, immutable"
|
||
}
|
||
}
|
||
}
|
||
},
|
||
"public": {
|
||
"i18n": {
|
||
"baseUrl": "",
|
||
"defaultLocale": "hu",
|
||
"rootRedirect": "",
|
||
"redirectStatusCode": 302,
|
||
"skipSettingLocaleOnNavigate": false,
|
||
"locales": [
|
||
{
|
||
"code": "hu",
|
||
"iso": "hu-HU",
|
||
"name": "Magyar",
|
||
"language": ""
|
||
},
|
||
{
|
||
"code": "en",
|
||
"iso": "en-GB",
|
||
"name": "English",
|
||
"language": ""
|
||
},
|
||
{
|
||
"code": "de",
|
||
"iso": "de-DE",
|
||
"name": "Deutsch",
|
||
"language": ""
|
||
},
|
||
{
|
||
"code": "fr",
|
||
"iso": "fr-FR",
|
||
"name": "Français",
|
||
"language": ""
|
||
},
|
||
{
|
||
"code": "ro",
|
||
"iso": "ro-RO",
|
||
"name": "Română",
|
||
"language": ""
|
||
},
|
||
{
|
||
"code": "cz",
|
||
"iso": "cs-CZ",
|
||
"name": "Čeština",
|
||
"language": ""
|
||
},
|
||
{
|
||
"code": "sk",
|
||
"iso": "sk-SK",
|
||
"name": "Slovenčina",
|
||
"language": ""
|
||
}
|
||
],
|
||
"detectBrowserLanguage": {
|
||
"alwaysRedirect": false,
|
||
"cookieCrossOrigin": false,
|
||
"cookieDomain": "",
|
||
"cookieKey": "i18n_redirected",
|
||
"cookieSecure": false,
|
||
"fallbackLocale": "",
|
||
"redirectOn": "root",
|
||
"useCookie": true
|
||
},
|
||
"experimental": {
|
||
"localeDetector": "",
|
||
"typedPages": true,
|
||
"typedOptionsAndMessages": false,
|
||
"alternateLinkCanonicalQueries": true,
|
||
"devCache": false,
|
||
"cacheLifetime": "",
|
||
"stripMessagesPayload": false,
|
||
"preload": false,
|
||
"strictSeo": false,
|
||
"nitroContextDetection": true,
|
||
"httpCacheDuration": 10,
|
||
"compactRoutes": false,
|
||
"prerenderMessages": false
|
||
},
|
||
"domainLocales": {
|
||
"hu": {
|
||
"domain": ""
|
||
},
|
||
"en": {
|
||
"domain": ""
|
||
},
|
||
"de": {
|
||
"domain": ""
|
||
},
|
||
"fr": {
|
||
"domain": ""
|
||
},
|
||
"ro": {
|
||
"domain": ""
|
||
},
|
||
"cz": {
|
||
"domain": ""
|
||
},
|
||
"sk": {
|
||
"domain": ""
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const envOptions = {
|
||
prefix: "NITRO_",
|
||
altPrefix: _inlineRuntimeConfig.nitro.envPrefix ?? process.env.NITRO_ENV_PREFIX ?? "_",
|
||
envExpansion: _inlineRuntimeConfig.nitro.envExpansion ?? process.env.NITRO_ENV_EXPANSION ?? false
|
||
};
|
||
const _sharedRuntimeConfig = _deepFreeze(
|
||
applyEnv(klona(_inlineRuntimeConfig), envOptions)
|
||
);
|
||
function useRuntimeConfig(event) {
|
||
if (!event) {
|
||
return _sharedRuntimeConfig;
|
||
}
|
||
if (event.context.nitro.runtimeConfig) {
|
||
return event.context.nitro.runtimeConfig;
|
||
}
|
||
const runtimeConfig = klona(_inlineRuntimeConfig);
|
||
applyEnv(runtimeConfig, envOptions);
|
||
event.context.nitro.runtimeConfig = runtimeConfig;
|
||
return runtimeConfig;
|
||
}
|
||
_deepFreeze(klona(appConfig));
|
||
function _deepFreeze(object) {
|
||
const propNames = Object.getOwnPropertyNames(object);
|
||
for (const name of propNames) {
|
||
const value = object[name];
|
||
if (value && typeof value === "object") {
|
||
_deepFreeze(value);
|
||
}
|
||
}
|
||
return Object.freeze(object);
|
||
}
|
||
new Proxy(/* @__PURE__ */ Object.create(null), {
|
||
get: (_, prop) => {
|
||
console.warn(
|
||
"Please use `useRuntimeConfig()` instead of accessing config directly."
|
||
);
|
||
const runtimeConfig = useRuntimeConfig();
|
||
if (prop in runtimeConfig) {
|
||
return runtimeConfig[prop];
|
||
}
|
||
return void 0;
|
||
}
|
||
});
|
||
|
||
getContext("nitro-app", {
|
||
asyncContext: false,
|
||
AsyncLocalStorage: void 0
|
||
});
|
||
|
||
function isPathInScope(pathname, base) {
|
||
let canonical;
|
||
try {
|
||
const pre = pathname.replace(/%2f/gi, "/").replace(/%5c/gi, "\\");
|
||
canonical = new URL(pre, "http://_").pathname;
|
||
} catch {
|
||
return false;
|
||
}
|
||
return !base || canonical === base || canonical.startsWith(base + "/");
|
||
}
|
||
|
||
const config = useRuntimeConfig();
|
||
const _routeRulesMatcher = toRouteMatcher(
|
||
createRouter({ routes: config.nitro.routeRules })
|
||
);
|
||
function createRouteRulesHandler(ctx) {
|
||
return eventHandler((event) => {
|
||
const routeRules = getRouteRules(event);
|
||
if (routeRules.headers) {
|
||
setHeaders(event, routeRules.headers);
|
||
}
|
||
if (routeRules.redirect) {
|
||
let target = routeRules.redirect.to;
|
||
if (target.endsWith("/**")) {
|
||
let targetPath = event.path;
|
||
const strpBase = routeRules.redirect._redirectStripBase;
|
||
if (strpBase) {
|
||
if (!isPathInScope(event.path.split("?")[0], strpBase)) {
|
||
throw createError({ statusCode: 400 });
|
||
}
|
||
targetPath = withoutBase(targetPath, strpBase);
|
||
} else if (targetPath.startsWith("//")) {
|
||
targetPath = targetPath.replace(/^\/+/, "/");
|
||
}
|
||
target = joinURL(target.slice(0, -3), targetPath);
|
||
} else if (event.path.includes("?")) {
|
||
const query = getQuery(event.path);
|
||
target = withQuery(target, query);
|
||
}
|
||
return sendRedirect(event, target, routeRules.redirect.statusCode);
|
||
}
|
||
if (routeRules.proxy) {
|
||
let target = routeRules.proxy.to;
|
||
if (target.endsWith("/**")) {
|
||
let targetPath = event.path;
|
||
const strpBase = routeRules.proxy._proxyStripBase;
|
||
if (strpBase) {
|
||
if (!isPathInScope(event.path.split("?")[0], strpBase)) {
|
||
throw createError({ statusCode: 400 });
|
||
}
|
||
targetPath = withoutBase(targetPath, strpBase);
|
||
} else if (targetPath.startsWith("//")) {
|
||
targetPath = targetPath.replace(/^\/+/, "/");
|
||
}
|
||
target = joinURL(target.slice(0, -3), targetPath);
|
||
} else if (event.path.includes("?")) {
|
||
const query = getQuery(event.path);
|
||
target = withQuery(target, query);
|
||
}
|
||
return proxyRequest(event, target, {
|
||
fetch: ctx.localFetch,
|
||
...routeRules.proxy
|
||
});
|
||
}
|
||
});
|
||
}
|
||
function getRouteRules(event) {
|
||
event.context._nitro = event.context._nitro || {};
|
||
if (!event.context._nitro.routeRules) {
|
||
event.context._nitro.routeRules = getRouteRulesForPath(
|
||
withoutBase(event.path.split("?")[0], useRuntimeConfig().app.baseURL)
|
||
);
|
||
}
|
||
return event.context._nitro.routeRules;
|
||
}
|
||
function getRouteRulesForPath(path) {
|
||
return defu({}, ..._routeRulesMatcher.matchAll(path).reverse());
|
||
}
|
||
|
||
function _captureError(error, type) {
|
||
console.error(`[${type}]`, error);
|
||
useNitroApp().captureError(error, { tags: [type] });
|
||
}
|
||
function trapUnhandledNodeErrors() {
|
||
process.on(
|
||
"unhandledRejection",
|
||
(error) => _captureError(error, "unhandledRejection")
|
||
);
|
||
process.on(
|
||
"uncaughtException",
|
||
(error) => _captureError(error, "uncaughtException")
|
||
);
|
||
}
|
||
function joinHeaders(value) {
|
||
return Array.isArray(value) ? value.join(", ") : String(value);
|
||
}
|
||
function normalizeFetchResponse(response) {
|
||
if (!response.headers.has("set-cookie")) {
|
||
return response;
|
||
}
|
||
return new Response(response.body, {
|
||
status: response.status,
|
||
statusText: response.statusText,
|
||
headers: normalizeCookieHeaders(response.headers)
|
||
});
|
||
}
|
||
function normalizeCookieHeader(header = "") {
|
||
return splitCookiesString(joinHeaders(header));
|
||
}
|
||
function normalizeCookieHeaders(headers) {
|
||
const outgoingHeaders = new Headers();
|
||
for (const [name, header] of headers) {
|
||
if (name === "set-cookie") {
|
||
for (const cookie of normalizeCookieHeader(header)) {
|
||
outgoingHeaders.append("set-cookie", cookie);
|
||
}
|
||
} else {
|
||
outgoingHeaders.set(name, joinHeaders(header));
|
||
}
|
||
}
|
||
return outgoingHeaders;
|
||
}
|
||
|
||
function isJsonRequest(event) {
|
||
|
||
if (hasReqHeader(event, "accept", "text/html")) {
|
||
return false;
|
||
}
|
||
return hasReqHeader(event, "accept", "application/json") || hasReqHeader(event, "user-agent", "curl/") || hasReqHeader(event, "user-agent", "httpie/") || hasReqHeader(event, "sec-fetch-mode", "cors") || event.path.startsWith("/api/") || event.path.endsWith(".json");
|
||
}
|
||
function hasReqHeader(event, name, includes) {
|
||
const value = getRequestHeader(event, name);
|
||
return !!(value && typeof value === "string" && value.toLowerCase().includes(includes));
|
||
}
|
||
|
||
const iframeStorageBridge = (nonce) => `
|
||
(function () {
|
||
const NONCE = ${JSON.stringify(nonce)};
|
||
const memoryStore = Object.create(null);
|
||
|
||
const post = (type, payload) => {
|
||
window.parent.postMessage({ type, nonce: NONCE, ...payload }, '*');
|
||
};
|
||
|
||
const isValid = (data) => data && data.nonce === NONCE;
|
||
|
||
const mockStorage = {
|
||
getItem(key) {
|
||
return Object.hasOwn(memoryStore, key)
|
||
? memoryStore[key]
|
||
: null;
|
||
},
|
||
setItem(key, value) {
|
||
const v = String(value);
|
||
memoryStore[key] = v;
|
||
post('storage-set', { key, value: v });
|
||
},
|
||
removeItem(key) {
|
||
delete memoryStore[key];
|
||
post('storage-remove', { key });
|
||
},
|
||
clear() {
|
||
for (const key of Object.keys(memoryStore))
|
||
delete memoryStore[key];
|
||
post('storage-clear', {});
|
||
},
|
||
key(index) {
|
||
const keys = Object.keys(memoryStore);
|
||
return keys[index] ?? null;
|
||
},
|
||
get length() {
|
||
return Object.keys(memoryStore).length;
|
||
}
|
||
};
|
||
|
||
const defineLocalStorage = () => {
|
||
try {
|
||
Object.defineProperty(window, 'localStorage', {
|
||
value: mockStorage,
|
||
writable: false,
|
||
configurable: true
|
||
});
|
||
} catch {
|
||
window.localStorage = mockStorage;
|
||
}
|
||
};
|
||
|
||
defineLocalStorage();
|
||
|
||
window.addEventListener('message', (event) => {
|
||
const data = event.data;
|
||
if (!isValid(data) || data.type !== 'storage-sync-data') return;
|
||
|
||
const incoming = data.data || {};
|
||
for (const key of Object.keys(incoming))
|
||
memoryStore[key] = incoming[key];
|
||
|
||
if (typeof window.initTheme === 'function')
|
||
window.initTheme();
|
||
window.dispatchEvent(new Event('storage-ready'));
|
||
});
|
||
|
||
// Clipboard API is unavailable in data: URL iframe, so we use postMessage
|
||
document.addEventListener('DOMContentLoaded', function() {
|
||
window.copyErrorMessage = function(button) {
|
||
post('clipboard-copy', { text: button.dataset.errorText });
|
||
button.classList.add('copied');
|
||
setTimeout(function() { button.classList.remove('copied'); }, 2000);
|
||
};
|
||
});
|
||
|
||
post('storage-sync-request', {});
|
||
})();
|
||
`;
|
||
const parentStorageBridge = (nonce) => `
|
||
(function () {
|
||
const host = document.querySelector('nuxt-error-overlay');
|
||
if (!host) return;
|
||
|
||
const NONCE = ${JSON.stringify(nonce)};
|
||
const isValid = (data) => data && data.nonce === NONCE;
|
||
|
||
// Handle clipboard copy from iframe
|
||
window.addEventListener('message', function(e) {
|
||
if (isValid(e.data) && e.data.type === 'clipboard-copy') {
|
||
navigator.clipboard.writeText(e.data.text).catch(function() {});
|
||
}
|
||
});
|
||
|
||
const collectLocalStorage = () => {
|
||
const all = {};
|
||
for (let i = 0; i < localStorage.length; i++) {
|
||
const k = localStorage.key(i);
|
||
if (k != null) all[k] = localStorage.getItem(k);
|
||
}
|
||
return all;
|
||
};
|
||
|
||
const attachWhenReady = () => {
|
||
const root = host.shadowRoot;
|
||
if (!root)
|
||
return false;
|
||
const iframe = root.getElementById('frame');
|
||
if (!iframe || !iframe.contentWindow)
|
||
return false;
|
||
|
||
const handlers = {
|
||
'storage-set': (d) => localStorage.setItem(d.key, d.value),
|
||
'storage-remove': (d) => localStorage.removeItem(d.key),
|
||
'storage-clear': () => localStorage.clear(),
|
||
'storage-sync-request': () => {
|
||
iframe.contentWindow.postMessage({
|
||
type: 'storage-sync-data',
|
||
data: collectLocalStorage(),
|
||
nonce: NONCE
|
||
}, '*');
|
||
}
|
||
};
|
||
|
||
window.addEventListener('message', (event) => {
|
||
const data = event.data;
|
||
if (!isValid(data)) return;
|
||
const fn = handlers[data.type];
|
||
if (fn) fn(data);
|
||
});
|
||
|
||
return true;
|
||
};
|
||
|
||
if (attachWhenReady())
|
||
return;
|
||
|
||
const obs = new MutationObserver(() => {
|
||
if (attachWhenReady())
|
||
obs.disconnect();
|
||
});
|
||
|
||
obs.observe(host, { childList: true, subtree: true });
|
||
})();
|
||
`;
|
||
const errorCSS = `
|
||
:host {
|
||
--preview-width: 240px;
|
||
--preview-height: 180px;
|
||
--base-width: 1200px;
|
||
--base-height: 900px;
|
||
--z-base: 999999998;
|
||
--error-pip-left: auto;
|
||
--error-pip-top: auto;
|
||
--error-pip-right: 5px;
|
||
--error-pip-bottom: 5px;
|
||
--error-pip-origin: bottom right;
|
||
--app-preview-left: auto;
|
||
--app-preview-top: auto;
|
||
--app-preview-right: 5px;
|
||
--app-preview-bottom: 5px;
|
||
all: initial;
|
||
display: contents;
|
||
}
|
||
.sr-only {
|
||
position: absolute;
|
||
width: 1px;
|
||
height: 1px;
|
||
padding: 0;
|
||
margin: -1px;
|
||
overflow: hidden;
|
||
clip: rect(0, 0, 0, 0);
|
||
white-space: nowrap;
|
||
border-width: 0;
|
||
}
|
||
#frame {
|
||
position: fixed;
|
||
left: 0;
|
||
top: 0;
|
||
width: 100vw;
|
||
height: 100vh;
|
||
border: none;
|
||
z-index: var(--z-base);
|
||
}
|
||
#frame[inert] {
|
||
left: var(--error-pip-left);
|
||
top: var(--error-pip-top);
|
||
right: var(--error-pip-right);
|
||
bottom: var(--error-pip-bottom);
|
||
width: var(--base-width);
|
||
height: var(--base-height);
|
||
transform: scale(calc(240 / 1200));
|
||
transform-origin: var(--error-pip-origin);
|
||
overflow: hidden;
|
||
border-radius: calc(1200 * 8px / 240);
|
||
}
|
||
#preview {
|
||
position: fixed;
|
||
left: var(--app-preview-left);
|
||
top: var(--app-preview-top);
|
||
right: var(--app-preview-right);
|
||
bottom: var(--app-preview-bottom);
|
||
width: var(--preview-width);
|
||
height: var(--preview-height);
|
||
overflow: hidden;
|
||
border-radius: 6px;
|
||
pointer-events: none;
|
||
z-index: var(--z-base);
|
||
background: white;
|
||
display: none;
|
||
}
|
||
#preview iframe {
|
||
transform-origin: var(--error-pip-origin);
|
||
}
|
||
#frame:not([inert]) + #preview {
|
||
display: block;
|
||
}
|
||
#toggle {
|
||
position: fixed;
|
||
left: var(--app-preview-left);
|
||
top: var(--app-preview-top);
|
||
right: calc(var(--app-preview-right) - 3px);
|
||
bottom: calc(var(--app-preview-bottom) - 3px);
|
||
width: var(--preview-width);
|
||
height: var(--preview-height);
|
||
background: none;
|
||
border: 3px solid #00DC82;
|
||
border-radius: 8px;
|
||
cursor: pointer;
|
||
opacity: 0.8;
|
||
transition: opacity 0.2s, box-shadow 0.2s;
|
||
z-index: calc(var(--z-base) + 1);
|
||
display: flex;
|
||
align-items: center;
|
||
justify-content: center;
|
||
}
|
||
#toggle:hover,
|
||
#toggle:focus {
|
||
opacity: 1;
|
||
box-shadow: 0 0 20px rgba(0, 220, 130, 0.6);
|
||
}
|
||
#toggle:focus-visible {
|
||
outline: 3px solid #00DC82;
|
||
outline-offset: 0;
|
||
box-shadow: 0 0 24px rgba(0, 220, 130, 0.8);
|
||
}
|
||
#frame[inert] ~ #toggle {
|
||
left: var(--error-pip-left);
|
||
top: var(--error-pip-top);
|
||
right: calc(var(--error-pip-right) - 3px);
|
||
bottom: calc(var(--error-pip-bottom) - 3px);
|
||
cursor: grab;
|
||
}
|
||
:host(.dragging) #frame[inert] ~ #toggle {
|
||
cursor: grabbing;
|
||
}
|
||
#frame:not([inert]) ~ #toggle,
|
||
#frame:not([inert]) + #preview {
|
||
cursor: grab;
|
||
}
|
||
:host(.dragging-preview) #frame:not([inert]) ~ #toggle,
|
||
:host(.dragging-preview) #frame:not([inert]) + #preview {
|
||
cursor: grabbing;
|
||
}
|
||
|
||
#pip-close {
|
||
position: absolute;
|
||
top: 6px;
|
||
right: 6px;
|
||
width: 24px;
|
||
height: 24px;
|
||
border-radius: 50%;
|
||
border: none;
|
||
background: rgba(0, 0, 0, 0.75);
|
||
color: #fff;
|
||
font-size: 16px;
|
||
line-height: 1;
|
||
display: inline-flex;
|
||
align-items: center;
|
||
justify-content: center;
|
||
cursor: pointer;
|
||
box-shadow: 0 2px 8px rgba(0, 0, 0, 0.3);
|
||
pointer-events: auto;
|
||
}
|
||
#pip-close:focus-visible {
|
||
outline: 2px solid #00DC82;
|
||
outline-offset: 2px;
|
||
}
|
||
|
||
#pip-restore {
|
||
position: fixed;
|
||
right: 16px;
|
||
bottom: 16px;
|
||
padding: 8px 14px;
|
||
border-radius: 999px;
|
||
border: 2px solid #00DC82;
|
||
background: #111;
|
||
color: #fff;
|
||
font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', sans-serif;
|
||
font-size: 14px;
|
||
display: inline-flex;
|
||
align-items: center;
|
||
gap: 6px;
|
||
z-index: calc(var(--z-base) + 2);
|
||
cursor: grab;
|
||
}
|
||
#pip-restore:focus-visible {
|
||
outline: 2px solid #00DC82;
|
||
outline-offset: 2px;
|
||
}
|
||
:host(.dragging-restore) #pip-restore {
|
||
cursor: grabbing;
|
||
}
|
||
|
||
#frame[hidden],
|
||
#toggle[hidden],
|
||
#preview[hidden],
|
||
#pip-restore[hidden],
|
||
#pip-close[hidden] {
|
||
display: none !important;
|
||
}
|
||
|
||
@media (prefers-reduced-motion: reduce) {
|
||
#toggle {
|
||
transition: none;
|
||
}
|
||
}
|
||
`;
|
||
function webComponentScript(base64HTML, startMinimized) {
|
||
return `
|
||
(function () {
|
||
try {
|
||
// =========================
|
||
// Host + Shadow
|
||
// =========================
|
||
const host = document.querySelector('nuxt-error-overlay');
|
||
if (!host)
|
||
return;
|
||
const shadow = host.attachShadow({ mode: 'open' });
|
||
|
||
// =========================
|
||
// DOM helpers
|
||
// =========================
|
||
const el = (tag) => document.createElement(tag);
|
||
const on = (node, type, fn, opts) => node.addEventListener(type, fn, opts);
|
||
const hide = (node, v) => node.toggleAttribute('hidden', !!v);
|
||
const setVar = (name, value) => host.style.setProperty(name, value);
|
||
const unsetVar = (name) => host.style.removeProperty(name);
|
||
|
||
// =========================
|
||
// Create DOM
|
||
// =========================
|
||
const style = el('style');
|
||
style.textContent = ${JSON.stringify(errorCSS)};
|
||
|
||
const iframe = el('iframe');
|
||
iframe.id = 'frame';
|
||
iframe.src = 'data:text/html;base64,${base64HTML}';
|
||
iframe.title = 'Detailed error stack trace';
|
||
iframe.setAttribute('sandbox', 'allow-scripts allow-same-origin allow-top-navigation-by-user-activation');
|
||
|
||
const preview = el('div');
|
||
preview.id = 'preview';
|
||
|
||
const toggle = el('div');
|
||
toggle.id = 'toggle';
|
||
toggle.setAttribute('aria-expanded', 'true');
|
||
toggle.setAttribute('role', 'button');
|
||
toggle.setAttribute('tabindex', '0');
|
||
toggle.innerHTML = '<span class="sr-only">Toggle detailed error view</span>';
|
||
|
||
const liveRegion = el('div');
|
||
liveRegion.setAttribute('role', 'status');
|
||
liveRegion.setAttribute('aria-live', 'polite');
|
||
liveRegion.className = 'sr-only';
|
||
|
||
const pipCloseButton = el('button');
|
||
pipCloseButton.id = 'pip-close';
|
||
pipCloseButton.setAttribute('type', 'button');
|
||
pipCloseButton.setAttribute('aria-label', 'Hide error preview overlay');
|
||
pipCloseButton.innerHTML = '×';
|
||
pipCloseButton.hidden = true;
|
||
toggle.appendChild(pipCloseButton);
|
||
|
||
const pipRestoreButton = el('button');
|
||
pipRestoreButton.id = 'pip-restore';
|
||
pipRestoreButton.setAttribute('type', 'button');
|
||
pipRestoreButton.setAttribute('aria-label', 'Show error overlay');
|
||
pipRestoreButton.innerHTML = '<span aria-hidden="true">⟲</span><span>Show error overlay</span>';
|
||
pipRestoreButton.hidden = true;
|
||
|
||
// Order matters: #frame + #preview adjacency
|
||
shadow.appendChild(style);
|
||
shadow.appendChild(liveRegion);
|
||
shadow.appendChild(iframe);
|
||
shadow.appendChild(preview);
|
||
shadow.appendChild(toggle);
|
||
shadow.appendChild(pipRestoreButton);
|
||
|
||
// =========================
|
||
// Constants / keys
|
||
// =========================
|
||
const POS_KEYS = {
|
||
position: 'nuxt-error-overlay:position',
|
||
hiddenPretty: 'nuxt-error-overlay:error-pip:hidden',
|
||
hiddenPreview: 'nuxt-error-overlay:app-preview:hidden'
|
||
};
|
||
|
||
const CSS_VARS = {
|
||
pip: {
|
||
left: '--error-pip-left',
|
||
top: '--error-pip-top',
|
||
right: '--error-pip-right',
|
||
bottom: '--error-pip-bottom'
|
||
},
|
||
preview: {
|
||
left: '--app-preview-left',
|
||
top: '--app-preview-top',
|
||
right: '--app-preview-right',
|
||
bottom: '--app-preview-bottom'
|
||
}
|
||
};
|
||
|
||
const MIN_GAP = 5;
|
||
const DRAG_THRESHOLD = 2;
|
||
|
||
// =========================
|
||
// Local storage safe access + state
|
||
// =========================
|
||
let storageReady = true;
|
||
let isPrettyHidden = false;
|
||
let isPreviewHidden = false;
|
||
|
||
const safeGet = (k) => {
|
||
try {
|
||
return localStorage.getItem(k);
|
||
} catch {
|
||
return null;
|
||
}
|
||
};
|
||
|
||
const safeSet = (k, v) => {
|
||
if (!storageReady)
|
||
return;
|
||
try {
|
||
localStorage.setItem(k, v);
|
||
} catch {}
|
||
};
|
||
|
||
// =========================
|
||
// Sizing helpers
|
||
// =========================
|
||
const vvSize = () => {
|
||
const v = window.visualViewport;
|
||
return v ? { w: v.width, h: v.height } : { w: window.innerWidth, h: window.innerHeight };
|
||
};
|
||
|
||
const previewSize = () => {
|
||
const styles = getComputedStyle(host);
|
||
const w = parseFloat(styles.getPropertyValue('--preview-width')) || 240;
|
||
const h = parseFloat(styles.getPropertyValue('--preview-height')) || 180;
|
||
return { w, h };
|
||
};
|
||
|
||
const sizeForTarget = (target) => {
|
||
if (!target)
|
||
return previewSize();
|
||
const rect = target.getBoundingClientRect();
|
||
if (rect.width && rect.height)
|
||
return { w: rect.width, h: rect.height };
|
||
return previewSize();
|
||
};
|
||
|
||
// =========================
|
||
// Dock model + offset/alignment calculations
|
||
// =========================
|
||
const dock = { edge: null, offset: null, align: null, gap: null };
|
||
|
||
const maxOffsetFor = (edge, size) => {
|
||
const vv = vvSize();
|
||
if (edge === 'left' || edge === 'right')
|
||
return Math.max(MIN_GAP, vv.h - size.h - MIN_GAP);
|
||
return Math.max(MIN_GAP, vv.w - size.w - MIN_GAP);
|
||
};
|
||
|
||
const clampOffset = (edge, value, size) => {
|
||
const max = maxOffsetFor(edge, size);
|
||
return Math.min(Math.max(value, MIN_GAP), max);
|
||
};
|
||
|
||
const updateDockAlignment = (size) => {
|
||
if (!dock.edge || dock.offset == null)
|
||
return;
|
||
const max = maxOffsetFor(dock.edge, size);
|
||
if (dock.offset <= max / 2) {
|
||
dock.align = 'start';
|
||
dock.gap = dock.offset;
|
||
} else {
|
||
dock.align = 'end';
|
||
dock.gap = Math.max(0, max - dock.offset);
|
||
}
|
||
};
|
||
|
||
const appliedOffsetFor = (size) => {
|
||
if (!dock.edge || dock.offset == null)
|
||
return null;
|
||
const max = maxOffsetFor(dock.edge, size);
|
||
|
||
if (dock.align === 'end' && typeof dock.gap === 'number') {
|
||
return clampOffset(dock.edge, max - dock.gap, size);
|
||
}
|
||
if (dock.align === 'start' && typeof dock.gap === 'number') {
|
||
return clampOffset(dock.edge, dock.gap, size);
|
||
}
|
||
return clampOffset(dock.edge, dock.offset, size);
|
||
};
|
||
|
||
const nearestEdgeAt = (x, y) => {
|
||
const { w, h } = vvSize();
|
||
const d = { left: x, right: w - x, top: y, bottom: h - y };
|
||
return Object.keys(d).reduce((a, b) => (d[a] < d[b] ? a : b));
|
||
};
|
||
|
||
const cornerDefaultDock = () => {
|
||
const vv = vvSize();
|
||
const size = previewSize();
|
||
const offset = Math.max(MIN_GAP, vv.w - size.w - MIN_GAP);
|
||
return { edge: 'bottom', offset };
|
||
};
|
||
|
||
const currentTransformOrigin = () => {
|
||
if (!dock.edge) return null;
|
||
if (dock.edge === 'left' || dock.edge === 'top')
|
||
return 'top left';
|
||
if (dock.edge === 'right')
|
||
return 'top right';
|
||
return 'bottom left';
|
||
};
|
||
|
||
// =========================
|
||
// Persist / load dock
|
||
// =========================
|
||
const loadDock = () => {
|
||
const raw = safeGet(POS_KEYS.position);
|
||
if (!raw)
|
||
return;
|
||
try {
|
||
const parsed = JSON.parse(raw);
|
||
const { edge, offset, align, gap } = parsed || {};
|
||
if (!['left', 'right', 'top', 'bottom'].includes(edge))
|
||
return;
|
||
if (typeof offset !== 'number')
|
||
return;
|
||
|
||
dock.edge = edge;
|
||
dock.offset = clampOffset(edge, offset, previewSize());
|
||
dock.align = align === 'start' || align === 'end' ? align : null;
|
||
dock.gap = typeof gap === 'number' ? gap : null;
|
||
|
||
if (!dock.align || dock.gap == null)
|
||
updateDockAlignment(previewSize());
|
||
} catch {}
|
||
};
|
||
|
||
const persistDock = () => {
|
||
if (!dock.edge || dock.offset == null)
|
||
return;
|
||
safeSet(POS_KEYS.position, JSON.stringify({
|
||
edge: dock.edge,
|
||
offset: dock.offset,
|
||
align: dock.align,
|
||
gap: dock.gap
|
||
}));
|
||
};
|
||
|
||
// =========================
|
||
// Apply dock
|
||
// =========================
|
||
const dockToVars = (vars) => ({
|
||
set: (side, v) => host.style.setProperty(vars[side], v),
|
||
clear: (side) => host.style.removeProperty(vars[side])
|
||
});
|
||
|
||
const dockToEl = (node) => ({
|
||
set: (side, v) => { node.style[side] = v; },
|
||
clear: (side) => { node.style[side] = ''; }
|
||
});
|
||
|
||
const applyDock = (target, size, opts) => {
|
||
if (!dock.edge || dock.offset == null) {
|
||
target.clear('left');
|
||
target.clear('top');
|
||
target.clear('right');
|
||
target.clear('bottom');
|
||
return;
|
||
}
|
||
|
||
target.set('left', 'auto');
|
||
target.set('top', 'auto');
|
||
target.set('right', 'auto');
|
||
target.set('bottom', 'auto');
|
||
|
||
const applied = appliedOffsetFor(size);
|
||
|
||
if (dock.edge === 'left') {
|
||
target.set('left', MIN_GAP + 'px');
|
||
target.set('top', applied + 'px');
|
||
} else if (dock.edge === 'right') {
|
||
target.set('right', MIN_GAP + 'px');
|
||
target.set('top', applied + 'px');
|
||
} else if (dock.edge === 'top') {
|
||
target.set('top', MIN_GAP + 'px');
|
||
target.set('left', applied + 'px');
|
||
} else {
|
||
target.set('bottom', MIN_GAP + 'px');
|
||
target.set('left', applied + 'px');
|
||
}
|
||
|
||
if (!opts || opts.persist !== false)
|
||
persistDock();
|
||
};
|
||
|
||
const applyDockAll = (opts) => {
|
||
applyDock(dockToVars(CSS_VARS.pip), previewSize(), opts);
|
||
applyDock(dockToVars(CSS_VARS.preview), previewSize(), opts);
|
||
applyDock(dockToEl(pipRestoreButton), sizeForTarget(pipRestoreButton), opts);
|
||
};
|
||
|
||
const repaintToDock = () => {
|
||
if (!dock.edge || dock.offset == null)
|
||
return;
|
||
const origin = currentTransformOrigin();
|
||
if (origin)
|
||
setVar('--error-pip-origin', origin);
|
||
else
|
||
unsetVar('--error-pip-origin');
|
||
applyDockAll({ persist: false });
|
||
};
|
||
|
||
// =========================
|
||
// Hidden state + UI
|
||
// =========================
|
||
const loadHidden = () => {
|
||
const rawPretty = safeGet(POS_KEYS.hiddenPretty);
|
||
if (rawPretty != null)
|
||
isPrettyHidden = rawPretty === '1' || rawPretty === 'true';
|
||
const rawPreview = safeGet(POS_KEYS.hiddenPreview);
|
||
if (rawPreview != null)
|
||
isPreviewHidden = rawPreview === '1' || rawPreview === 'true';
|
||
};
|
||
|
||
const setPrettyHidden = (v) => {
|
||
isPrettyHidden = !!v;
|
||
safeSet(POS_KEYS.hiddenPretty, isPrettyHidden ? '1' : '0');
|
||
updateUI();
|
||
};
|
||
|
||
const setPreviewHidden = (v) => {
|
||
isPreviewHidden = !!v;
|
||
safeSet(POS_KEYS.hiddenPreview, isPreviewHidden ? '1' : '0');
|
||
updateUI();
|
||
};
|
||
|
||
const isMinimized = () => iframe.hasAttribute('inert');
|
||
|
||
const setMinimized = (v) => {
|
||
if (v) {
|
||
iframe.setAttribute('inert', '');
|
||
toggle.setAttribute('aria-expanded', 'false');
|
||
} else {
|
||
iframe.removeAttribute('inert');
|
||
toggle.setAttribute('aria-expanded', 'true');
|
||
}
|
||
};
|
||
|
||
const setRestoreLabel = (kind) => {
|
||
if (kind === 'pretty') {
|
||
pipRestoreButton.innerHTML = '<span aria-hidden="true">⟲</span><span>Show error overlay</span>';
|
||
pipRestoreButton.setAttribute('aria-label', 'Show error overlay');
|
||
} else {
|
||
pipRestoreButton.innerHTML = '<span aria-hidden="true">⟲</span><span>Show error page</span>';
|
||
pipRestoreButton.setAttribute('aria-label', 'Show error page');
|
||
}
|
||
};
|
||
|
||
const updateUI = () => {
|
||
const minimized = isMinimized();
|
||
const showPiP = minimized && !isPrettyHidden;
|
||
const showPreview = !minimized && !isPreviewHidden;
|
||
const pipHiddenByUser = minimized && isPrettyHidden;
|
||
const previewHiddenByUser = !minimized && isPreviewHidden;
|
||
const showToggle = minimized ? showPiP : showPreview;
|
||
const showRestore = pipHiddenByUser || previewHiddenByUser;
|
||
|
||
hide(iframe, pipHiddenByUser);
|
||
hide(preview, !showPreview);
|
||
hide(toggle, !showToggle);
|
||
hide(pipCloseButton, !showToggle);
|
||
hide(pipRestoreButton, !showRestore);
|
||
|
||
pipCloseButton.setAttribute('aria-label', minimized ? 'Hide error overlay' : 'Hide error page preview');
|
||
|
||
if (pipHiddenByUser)
|
||
setRestoreLabel('pretty');
|
||
else if (previewHiddenByUser)
|
||
setRestoreLabel('preview');
|
||
|
||
host.classList.toggle('pip-hidden', isPrettyHidden);
|
||
host.classList.toggle('preview-hidden', isPreviewHidden);
|
||
};
|
||
|
||
// =========================
|
||
// Preview snapshot
|
||
// =========================
|
||
const updatePreview = () => {
|
||
try {
|
||
let previewIframe = preview.querySelector('iframe');
|
||
if (!previewIframe) {
|
||
previewIframe = el('iframe');
|
||
previewIframe.style.cssText = 'width: 1200px; height: 900px; transform: scale(0.2); transform-origin: top left; border: none;';
|
||
previewIframe.setAttribute('sandbox', 'allow-scripts allow-same-origin');
|
||
preview.appendChild(previewIframe);
|
||
}
|
||
|
||
const doctype = document.doctype ? '<!DOCTYPE ' + document.doctype.name + '>' : '';
|
||
const cleanedHTML = document.documentElement.outerHTML
|
||
.replace(/<nuxt-error-overlay[^>]*>.*?<\\/nuxt-error-overlay>/gs, '')
|
||
.replace(/<script[^>]*>.*?<\\/script>/gs, '');
|
||
|
||
const iframeDoc = previewIframe.contentDocument || previewIframe.contentWindow.document;
|
||
iframeDoc.open();
|
||
iframeDoc.write(doctype + cleanedHTML);
|
||
iframeDoc.close();
|
||
} catch (err) {
|
||
console.error('Failed to update preview:', err);
|
||
}
|
||
};
|
||
|
||
// =========================
|
||
// View toggling
|
||
// =========================
|
||
const toggleView = () => {
|
||
if (isMinimized()) {
|
||
updatePreview();
|
||
setMinimized(false);
|
||
liveRegion.textContent = 'Showing detailed error view';
|
||
setTimeout(() => {
|
||
try {
|
||
iframe.contentWindow.focus();
|
||
} catch {}
|
||
}, 100);
|
||
} else {
|
||
setMinimized(true);
|
||
liveRegion.textContent = 'Showing error page';
|
||
repaintToDock();
|
||
void iframe.offsetWidth;
|
||
}
|
||
updateUI();
|
||
};
|
||
|
||
// =========================
|
||
// Dragging (unified, rAF throttled)
|
||
// =========================
|
||
let drag = null;
|
||
let rafId = null;
|
||
let suppressToggleClick = false;
|
||
let suppressRestoreClick = false;
|
||
|
||
const beginDrag = (e) => {
|
||
if (drag)
|
||
return;
|
||
|
||
if (!dock.edge || dock.offset == null) {
|
||
const def = cornerDefaultDock();
|
||
dock.edge = def.edge;
|
||
dock.offset = def.offset;
|
||
updateDockAlignment(previewSize());
|
||
}
|
||
|
||
const isRestoreTarget = e.currentTarget === pipRestoreButton;
|
||
|
||
drag = {
|
||
kind: isRestoreTarget ? 'restore' : (isMinimized() ? 'pip' : 'preview'),
|
||
pointerId: e.pointerId,
|
||
startX: e.clientX,
|
||
startY: e.clientY,
|
||
lastX: e.clientX,
|
||
lastY: e.clientY,
|
||
moved: false,
|
||
target: e.currentTarget
|
||
};
|
||
|
||
drag.target.setPointerCapture(e.pointerId);
|
||
|
||
if (drag.kind === 'restore')
|
||
host.classList.add('dragging-restore');
|
||
else
|
||
host.classList.add(drag.kind === 'pip' ? 'dragging' : 'dragging-preview');
|
||
|
||
e.preventDefault();
|
||
};
|
||
|
||
const moveDrag = (e) => {
|
||
if (!drag || drag.pointerId !== e.pointerId)
|
||
return;
|
||
|
||
drag.lastX = e.clientX;
|
||
drag.lastY = e.clientY;
|
||
|
||
const dx = drag.lastX - drag.startX;
|
||
const dy = drag.lastY - drag.startY;
|
||
|
||
if (!drag.moved && (Math.abs(dx) > DRAG_THRESHOLD || Math.abs(dy) > DRAG_THRESHOLD)) {
|
||
drag.moved = true;
|
||
}
|
||
|
||
if (!drag.moved)
|
||
return;
|
||
if (rafId)
|
||
return;
|
||
|
||
rafId = requestAnimationFrame(() => {
|
||
rafId = null;
|
||
|
||
const edge = nearestEdgeAt(drag.lastX, drag.lastY);
|
||
const size = sizeForTarget(drag.target);
|
||
|
||
let offset;
|
||
if (edge === 'left' || edge === 'right') {
|
||
const top = drag.lastY - (size.h / 2);
|
||
offset = clampOffset(edge, Math.round(top), size);
|
||
} else {
|
||
const left = drag.lastX - (size.w / 2);
|
||
offset = clampOffset(edge, Math.round(left), size);
|
||
}
|
||
|
||
dock.edge = edge;
|
||
dock.offset = offset;
|
||
updateDockAlignment(size);
|
||
|
||
const origin = currentTransformOrigin();
|
||
setVar('--error-pip-origin', origin || 'bottom right');
|
||
|
||
applyDockAll({ persist: false });
|
||
});
|
||
};
|
||
|
||
const endDrag = (e) => {
|
||
if (!drag || drag.pointerId !== e.pointerId)
|
||
return;
|
||
|
||
const endedKind = drag.kind;
|
||
drag.target.releasePointerCapture(e.pointerId);
|
||
|
||
if (endedKind === 'restore')
|
||
host.classList.remove('dragging-restore');
|
||
else
|
||
host.classList.remove(endedKind === 'pip' ? 'dragging' : 'dragging-preview');
|
||
|
||
const didMove = drag.moved;
|
||
drag = null;
|
||
|
||
if (didMove) {
|
||
persistDock();
|
||
if (endedKind === 'restore')
|
||
suppressRestoreClick = true;
|
||
else
|
||
suppressToggleClick = true;
|
||
e.preventDefault();
|
||
e.stopPropagation();
|
||
}
|
||
};
|
||
|
||
const bindDragTarget = (node) => {
|
||
on(node, 'pointerdown', beginDrag);
|
||
on(node, 'pointermove', moveDrag);
|
||
on(node, 'pointerup', endDrag);
|
||
on(node, 'pointercancel', endDrag);
|
||
};
|
||
|
||
bindDragTarget(toggle);
|
||
bindDragTarget(pipRestoreButton);
|
||
|
||
// =========================
|
||
// Events (toggle / close / restore)
|
||
// =========================
|
||
on(toggle, 'click', (e) => {
|
||
if (suppressToggleClick) {
|
||
e.preventDefault();
|
||
suppressToggleClick = false;
|
||
return;
|
||
}
|
||
toggleView();
|
||
});
|
||
|
||
on(toggle, 'keydown', (e) => {
|
||
if (e.key === 'Enter' || e.key === ' ') {
|
||
e.preventDefault();
|
||
toggleView();
|
||
}
|
||
});
|
||
|
||
on(pipCloseButton, 'click', (e) => {
|
||
e.preventDefault();
|
||
e.stopPropagation();
|
||
if (isMinimized())
|
||
setPrettyHidden(true);
|
||
else
|
||
setPreviewHidden(true);
|
||
});
|
||
|
||
on(pipCloseButton, 'pointerdown', (e) => {
|
||
e.stopPropagation();
|
||
});
|
||
|
||
on(pipRestoreButton, 'click', (e) => {
|
||
if (suppressRestoreClick) {
|
||
e.preventDefault();
|
||
suppressRestoreClick = false;
|
||
return;
|
||
}
|
||
e.preventDefault();
|
||
e.stopPropagation();
|
||
if (isMinimized())
|
||
setPrettyHidden(false);
|
||
else
|
||
setPreviewHidden(false);
|
||
});
|
||
|
||
// =========================
|
||
// Lifecycle: load / sync / repaint
|
||
// =========================
|
||
const loadState = () => {
|
||
loadDock();
|
||
loadHidden();
|
||
|
||
if (isPrettyHidden && !isMinimized())
|
||
setMinimized(true);
|
||
|
||
updateUI();
|
||
repaintToDock();
|
||
};
|
||
|
||
loadState();
|
||
|
||
on(window, 'storage-ready', () => {
|
||
storageReady = true;
|
||
loadState();
|
||
});
|
||
|
||
const onViewportChange = () => repaintToDock();
|
||
|
||
on(window, 'resize', onViewportChange);
|
||
|
||
if (window.visualViewport) {
|
||
on(window.visualViewport, 'resize', onViewportChange);
|
||
on(window.visualViewport, 'scroll', onViewportChange);
|
||
}
|
||
|
||
// initial preview
|
||
setTimeout(updatePreview, 100);
|
||
|
||
// initial minimized option
|
||
if (${startMinimized}) {
|
||
setMinimized(true);
|
||
repaintToDock();
|
||
void iframe.offsetWidth;
|
||
updateUI();
|
||
}
|
||
} catch (err) {
|
||
console.error('Failed to initialize Nuxt error overlay:', err);
|
||
}
|
||
})();
|
||
`;
|
||
}
|
||
function generateErrorOverlayHTML(html, options) {
|
||
const nonce = Array.from(crypto.getRandomValues(new Uint8Array(16)), (b) => b.toString(16).padStart(2, "0")).join("");
|
||
const errorPage = html.replace("<head>", `<head><script>${iframeStorageBridge(nonce)}<\/script>`);
|
||
const base64HTML = Buffer.from(errorPage, "utf8").toString("base64");
|
||
return `
|
||
<script>${parentStorageBridge(nonce)}<\/script>
|
||
<nuxt-error-overlay></nuxt-error-overlay>
|
||
<script>${webComponentScript(base64HTML, options?.startMinimized ?? false)}<\/script>
|
||
`;
|
||
}
|
||
|
||
const errorHandler$0 = (async function errorhandler(error, event, { defaultHandler }) {
|
||
if (event.handled || isJsonRequest(event)) {
|
||
|
||
return;
|
||
}
|
||
|
||
const defaultRes = await defaultHandler(error, event, { json: true });
|
||
|
||
const status = error.status || error.statusCode || 500;
|
||
if (status === 404 && defaultRes.status === 302) {
|
||
setResponseHeaders(event, defaultRes.headers);
|
||
setResponseStatus(event, defaultRes.status, defaultRes.statusText);
|
||
return send(event, JSON.stringify(defaultRes.body, null, 2));
|
||
}
|
||
if (typeof defaultRes.body !== "string" && Array.isArray(defaultRes.body.stack)) {
|
||
|
||
defaultRes.body.stack = defaultRes.body.stack.join("\n");
|
||
}
|
||
const errorObject = defaultRes.body;
|
||
|
||
const url = new URL(errorObject.url);
|
||
errorObject.url = withoutBase(url.pathname, useRuntimeConfig(event).app.baseURL) + url.search + url.hash;
|
||
|
||
errorObject.message = error.unhandled ? errorObject.message || "Server Error" : error.message || errorObject.message || "Server Error";
|
||
|
||
errorObject.data ||= error.data;
|
||
errorObject.statusText ||= error.statusText || error.statusMessage;
|
||
delete defaultRes.headers["content-type"];
|
||
delete defaultRes.headers["content-security-policy"];
|
||
setResponseHeaders(event, defaultRes.headers);
|
||
|
||
const reqHeaders = getRequestHeaders(event);
|
||
|
||
const isRenderingError = event.path.startsWith("/__nuxt_error") || !!reqHeaders["x-nuxt-error"] || !!event.context.nuxt?.["~rendering-error"];
|
||
if (!isRenderingError) {
|
||
event.context.nuxt ||= {};
|
||
event.context.nuxt["~rendering-error"] = true;
|
||
}
|
||
|
||
const res = isRenderingError ? null : await useNitroApp().localFetch(withQuery(joinURL(useRuntimeConfig(event).app.baseURL, "/__nuxt_error"), errorObject), {
|
||
headers: {
|
||
...reqHeaders,
|
||
"x-nuxt-error": "true"
|
||
},
|
||
redirect: "manual"
|
||
}).catch(() => null);
|
||
if (event.handled) {
|
||
return;
|
||
}
|
||
|
||
if (!res) {
|
||
const { template } = await Promise.resolve().then(function () { return error500; });
|
||
{
|
||
|
||
errorObject.description = errorObject.message;
|
||
}
|
||
setResponseHeader(event, "Content-Type", "text/html;charset=UTF-8");
|
||
return send(event, template(errorObject));
|
||
}
|
||
const html = await res.text();
|
||
for (const [header, value] of res.headers.entries()) {
|
||
if (header === "set-cookie") {
|
||
appendResponseHeader(event, header, value);
|
||
continue;
|
||
}
|
||
setResponseHeader(event, header, value);
|
||
}
|
||
setResponseStatus(event, res.status && res.status !== 200 ? res.status : defaultRes.status, res.statusText || defaultRes.statusText);
|
||
if (!globalThis._importMeta_.test && typeof html === "string") {
|
||
const prettyResponse = await defaultHandler(error, event, { json: false });
|
||
if (typeof prettyResponse.body === "string") {
|
||
return send(event, html.replace("</body>", `${generateErrorOverlayHTML(prettyResponse.body, { startMinimized: 300 <= status && status < 500 })}</body>`));
|
||
}
|
||
}
|
||
return send(event, html);
|
||
});
|
||
|
||
function defineNitroErrorHandler(handler) {
|
||
return handler;
|
||
}
|
||
|
||
const errorHandler$1 = defineNitroErrorHandler(
|
||
async function defaultNitroErrorHandler(error, event) {
|
||
const res = await defaultHandler(error, event);
|
||
if (!event.node?.res.headersSent) {
|
||
setResponseHeaders(event, res.headers);
|
||
}
|
||
setResponseStatus(event, res.status, res.statusText);
|
||
return send(
|
||
event,
|
||
typeof res.body === "string" ? res.body : JSON.stringify(res.body, null, 2)
|
||
);
|
||
}
|
||
);
|
||
async function defaultHandler(error, event, opts) {
|
||
const isSensitive = error.unhandled || error.fatal;
|
||
const statusCode = error.statusCode || 500;
|
||
const statusMessage = error.statusMessage || "Server Error";
|
||
const url = getRequestURL(event, { xForwardedHost: true, xForwardedProto: true });
|
||
if (statusCode === 404) {
|
||
const baseURL = "/";
|
||
if (/^\/[^/]/.test(baseURL) && !url.pathname.startsWith(baseURL)) {
|
||
const redirectTo = `${baseURL}${url.pathname.slice(1)}${url.search}`;
|
||
return {
|
||
status: 302,
|
||
statusText: "Found",
|
||
headers: { location: redirectTo },
|
||
body: `Redirecting...`
|
||
};
|
||
}
|
||
}
|
||
await loadStackTrace(error).catch(consola.error);
|
||
const youch = new Youch();
|
||
if (isSensitive && !opts?.silent) {
|
||
const tags = [error.unhandled && "[unhandled]", error.fatal && "[fatal]"].filter(Boolean).join(" ");
|
||
const ansiError = await (await youch.toANSI(error)).replaceAll(process.cwd(), ".");
|
||
consola.error(
|
||
`[request error] ${tags} [${event.method}] ${url}
|
||
|
||
`,
|
||
ansiError
|
||
);
|
||
}
|
||
const useJSON = opts?.json ?? !getRequestHeader(event, "accept")?.includes("text/html");
|
||
const headers = {
|
||
"content-type": useJSON ? "application/json" : "text/html",
|
||
// Prevent browser from guessing the MIME types of resources.
|
||
"x-content-type-options": "nosniff",
|
||
// Prevent error page from being embedded in an iframe
|
||
"x-frame-options": "DENY",
|
||
// Prevent browsers from sending the Referer header
|
||
"referrer-policy": "no-referrer",
|
||
// Disable the execution of any js
|
||
"content-security-policy": "script-src 'self' 'unsafe-inline'; object-src 'none'; base-uri 'self';"
|
||
};
|
||
if (statusCode === 404 || !getResponseHeader(event, "cache-control")) {
|
||
headers["cache-control"] = "no-cache";
|
||
}
|
||
const body = useJSON ? {
|
||
error: true,
|
||
url,
|
||
statusCode,
|
||
statusMessage,
|
||
message: error.message,
|
||
data: error.data,
|
||
stack: error.stack?.split("\n").map((line) => line.trim())
|
||
} : await youch.toHTML(error, {
|
||
request: {
|
||
url: url.href,
|
||
method: event.method,
|
||
headers: getRequestHeaders(event)
|
||
}
|
||
});
|
||
return {
|
||
status: statusCode,
|
||
statusText: statusMessage,
|
||
headers,
|
||
body
|
||
};
|
||
}
|
||
async function loadStackTrace(error) {
|
||
if (!(error instanceof Error)) {
|
||
return;
|
||
}
|
||
const parsed = await new ErrorParser().defineSourceLoader(sourceLoader).parse(error);
|
||
const stack = error.message + "\n" + parsed.frames.map((frame) => fmtFrame(frame)).join("\n");
|
||
Object.defineProperty(error, "stack", { value: stack });
|
||
if (error.cause) {
|
||
await loadStackTrace(error.cause).catch(consola.error);
|
||
}
|
||
}
|
||
async function sourceLoader(frame) {
|
||
if (!frame.fileName || frame.fileType !== "fs" || frame.type === "native") {
|
||
return;
|
||
}
|
||
if (frame.type === "app") {
|
||
const rawSourceMap = await readFile(`${frame.fileName}.map`, "utf8").catch(() => {
|
||
});
|
||
if (rawSourceMap) {
|
||
const consumer = await new SourceMapConsumer(rawSourceMap);
|
||
const originalPosition = consumer.originalPositionFor({ line: frame.lineNumber, column: frame.columnNumber });
|
||
if (originalPosition.source && originalPosition.line) {
|
||
frame.fileName = resolve(dirname(frame.fileName), originalPosition.source);
|
||
frame.lineNumber = originalPosition.line;
|
||
frame.columnNumber = originalPosition.column || 0;
|
||
}
|
||
}
|
||
}
|
||
const contents = await readFile(frame.fileName, "utf8").catch(() => {
|
||
});
|
||
return contents ? { contents } : void 0;
|
||
}
|
||
function fmtFrame(frame) {
|
||
if (frame.type === "native") {
|
||
return frame.raw;
|
||
}
|
||
const src = `${frame.fileName || ""}:${frame.lineNumber}:${frame.columnNumber})`;
|
||
return frame.functionName ? `at ${frame.functionName} (${src}` : `at ${src}`;
|
||
}
|
||
|
||
const errorHandlers = [errorHandler$0, errorHandler$1];
|
||
|
||
async function errorHandler(error, event) {
|
||
for (const handler of errorHandlers) {
|
||
try {
|
||
await handler(error, event, { defaultHandler });
|
||
if (event.handled) {
|
||
return; // Response handled
|
||
}
|
||
} catch(error) {
|
||
// Handler itself thrown, log and continue
|
||
console.error(error);
|
||
}
|
||
}
|
||
// H3 will handle fallback
|
||
}
|
||
|
||
const script = `
|
||
if (!window.__NUXT_DEVTOOLS_TIME_METRIC__) {
|
||
Object.defineProperty(window, '__NUXT_DEVTOOLS_TIME_METRIC__', {
|
||
value: {},
|
||
enumerable: false,
|
||
configurable: true,
|
||
})
|
||
}
|
||
window.__NUXT_DEVTOOLS_TIME_METRIC__.appInit = Date.now()
|
||
`;
|
||
|
||
const _FMnHxsRb1XnhSkgrcxwDEP1elfSPjrP7Wr27yXkb3Aw = (function(nitro) {
|
||
nitro.hooks.hook("render:html", (htmlContext) => {
|
||
htmlContext.head.push(`<script>${script}<\/script>`);
|
||
});
|
||
});
|
||
|
||
/*!
|
||
* shared v11.4.2
|
||
* (c) 2026 kazuya kawaguchi
|
||
* Released under the MIT License.
|
||
*/
|
||
const _create = Object.create;
|
||
const create = (obj = null) => _create(obj);
|
||
/* eslint-enable */
|
||
/**
|
||
* Useful Utilities By Evan you
|
||
* Modified by kazuya kawaguchi
|
||
* MIT License
|
||
* https://github.com/vuejs/vue-next/blob/master/packages/shared/src/index.ts
|
||
* https://github.com/vuejs/vue-next/blob/master/packages/shared/src/codeframe.ts
|
||
*/
|
||
const isArray = Array.isArray;
|
||
const isFunction = (val) => typeof val === 'function';
|
||
const isString = (val) => typeof val === 'string';
|
||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||
const isObject = (val) => val !== null && typeof val === 'object';
|
||
const objectToString = Object.prototype.toString;
|
||
const toTypeString = (value) => objectToString.call(value);
|
||
|
||
const isNotObjectOrIsArray = (val) => !isObject(val) || isArray(val);
|
||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||
function deepCopy(src, des) {
|
||
// src and des should both be objects, and none of them can be a array
|
||
if (isNotObjectOrIsArray(src) || isNotObjectOrIsArray(des)) {
|
||
throw new Error('Invalid value');
|
||
}
|
||
const stack = [{ src, des }];
|
||
while (stack.length) {
|
||
const { src, des } = stack.pop();
|
||
// using `Object.keys` which skips prototype properties
|
||
Object.keys(src).forEach(key => {
|
||
if (key === '__proto__') {
|
||
return;
|
||
}
|
||
// if src[key] is an object/array, set des[key]
|
||
// to empty object/array to prevent setting by reference
|
||
if (isObject(src[key]) && !isObject(des[key])) {
|
||
des[key] = Array.isArray(src[key]) ? [] : create();
|
||
}
|
||
if (isNotObjectOrIsArray(des[key]) || isNotObjectOrIsArray(src[key])) {
|
||
// replace with src[key] when:
|
||
// src[key] or des[key] is not an object, or
|
||
// src[key] or des[key] is an array
|
||
des[key] = src[key];
|
||
}
|
||
else {
|
||
// src[key] and des[key] are both objects, merge them
|
||
stack.push({ src: src[key], des: des[key] });
|
||
}
|
||
});
|
||
}
|
||
}
|
||
|
||
const __nuxtMock = { runWithContext: async (fn) => await fn() };
|
||
const merger = createDefu((obj, key, value) => {
|
||
if (key === "messages" || key === "datetimeFormats" || key === "numberFormats") {
|
||
obj[key] ??= create(null);
|
||
deepCopy(value, obj[key]);
|
||
return true;
|
||
}
|
||
});
|
||
async function loadVueI18nOptions(vueI18nConfigs) {
|
||
const nuxtApp = __nuxtMock;
|
||
let vueI18nOptions = { messages: create(null) };
|
||
for (const configFile of vueI18nConfigs) {
|
||
const resolver = await configFile().then((x) => isModule(x) ? x.default : x);
|
||
const resolved = isFunction(resolver) ? await nuxtApp.runWithContext(() => resolver()) : resolver;
|
||
vueI18nOptions = merger(create(null), resolved, vueI18nOptions);
|
||
}
|
||
vueI18nOptions.fallbackLocale ??= false;
|
||
return vueI18nOptions;
|
||
}
|
||
const isModule = (val) => toTypeString(val) === "[object Module]";
|
||
async function getLocaleMessages(locale, loader) {
|
||
const nuxtApp = __nuxtMock;
|
||
try {
|
||
const getter = await nuxtApp.runWithContext(loader.load).then((x) => isModule(x) ? x.default : x);
|
||
return isFunction(getter) ? await nuxtApp.runWithContext(() => getter(locale)) : getter;
|
||
} catch (e) {
|
||
throw new Error(`Failed loading locale (${locale}): ` + e.message);
|
||
}
|
||
}
|
||
async function getLocaleMessagesMerged(locale, loaders = []) {
|
||
const nuxtApp = __nuxtMock;
|
||
const messages = await Promise.all(
|
||
loaders.map((loader) => nuxtApp.runWithContext(() => getLocaleMessages(locale, loader)))
|
||
);
|
||
const merged = {};
|
||
for (const message of messages) {
|
||
deepCopy(message, merged);
|
||
}
|
||
return merged;
|
||
}
|
||
|
||
var common$6 = {
|
||
loading: "Betöltés...",
|
||
saving: "Mentés...",
|
||
error: "Hiba történt",
|
||
retry: "Újra",
|
||
save: "Mentés",
|
||
saving_data: "Adatok mentése...",
|
||
cancel: "Mégsem",
|
||
discard: "Elvetés",
|
||
"delete": "Törlés",
|
||
delete_confirm: "Biztosan törölni szeretnéd ezt az elemet?",
|
||
delete_btn: "Törlés",
|
||
delete_title: "Törlés Megerősítése",
|
||
deleted: "Sikeresen törölve",
|
||
edit: "Szerkesztés",
|
||
edit_title: "Elem Szerkesztése",
|
||
create: "Létrehozás",
|
||
create_btn: "Létrehozás",
|
||
create_title: "Új Létrehozása",
|
||
create_first: "Hozd létre az első elemet a kezdéshez",
|
||
search: "Keresés",
|
||
search_placeholder: "Keresés...",
|
||
filter: "Szűrés",
|
||
no_results: "Nincs találat",
|
||
no_results_hint: "Próbáld módosítani a keresési vagy szűrési feltételeket",
|
||
no_items: "Nincsenek elemek",
|
||
actions: "Műveletek",
|
||
status: "Státusz",
|
||
active: "Aktív",
|
||
inactive: "Inaktív",
|
||
activate: "Aktiválás",
|
||
deactivate: "Deaktiválás",
|
||
name: "Név",
|
||
name_placeholder: "Add meg a nevet",
|
||
description: "Leírás",
|
||
desc_placeholder: "Add meg a leírást",
|
||
details: "Részletek",
|
||
email: "E-mail",
|
||
id: "Azonosító",
|
||
type: "Típus",
|
||
type_corporate: "Vállalati",
|
||
view: "Megtekintés",
|
||
updated: "Sikeresen frissítve",
|
||
save_error: "Sikertelen mentés",
|
||
invalid_json: "Érvénytelen JSON formátum",
|
||
prev: "Előző",
|
||
next: "Következő",
|
||
none: "Nincs",
|
||
reset: "Visszaállítás",
|
||
confirm: "Megerősítés",
|
||
close: "Bezárás",
|
||
back: "Vissza",
|
||
"continue": "Tovább",
|
||
exit: "Kilépés",
|
||
all: "Minden",
|
||
select_all: "Összes kiválasztása",
|
||
deselect_all: "Összes elrejtése",
|
||
expires: "Lejárat",
|
||
created: "Létrehozva",
|
||
start_date: "Kezdő Dátum",
|
||
end_date: "Befejező Dátum",
|
||
points: "Pontok",
|
||
level: "Szint",
|
||
user: "Felhasználó",
|
||
user_id: "Felhasználó Azonosító",
|
||
services: "Szolgáltatások",
|
||
discoveries: "Felfedezések",
|
||
restriction: "Korlátozás",
|
||
restriction_mild: "Enyhe",
|
||
restriction_moderate: "Mérsékelt",
|
||
restriction_severe: "Súlyos",
|
||
min_xp: "Min XP",
|
||
xp: "XP",
|
||
penalty: "Büntetés",
|
||
feature_flags: "Funkció Kapcsolók",
|
||
permission: "Engedély",
|
||
role: "Szerepkör",
|
||
domain: "Tartomány",
|
||
action: "Művelet",
|
||
value: "Érték",
|
||
key: "Kulcs",
|
||
enabled: "Bekapcsolva",
|
||
disabled: "Kikapcsolva",
|
||
yes: "Igen",
|
||
no: "Nem",
|
||
on: "Be",
|
||
off: "Ki",
|
||
service_finder: "Service Finder",
|
||
admin: "Admin",
|
||
version: "Verzió",
|
||
super_administrator: "Szuper Adminisztrátor",
|
||
administrator: "Adminisztrátor",
|
||
profile_settings: "Profil Beállítások",
|
||
sign_out: "Kijelentkezés",
|
||
unknown_user: "Ismeretlen felhasználó",
|
||
ascending: "Növekvő",
|
||
descending: "Csökkenő"
|
||
};
|
||
const locale_common_46json_68c48c8a = {
|
||
common: common$6
|
||
};
|
||
|
||
var menu$1 = {
|
||
center: "Központ",
|
||
dashboard: "Dashboard",
|
||
providers: "Szolgáltatók",
|
||
providers_title: "Szolgáltatók",
|
||
all_providers: "Összes szolgáltató",
|
||
pending_providers: "Jóváhagyásra váró",
|
||
users_and_partners: "Felhasználók & Partnerek",
|
||
garages: "Garázsok",
|
||
garage_list: "Garázsok listája",
|
||
users: "Felhasználók",
|
||
user_list: "Felhasználók listája",
|
||
persons: "Személyek",
|
||
finance: "Pénzügyek",
|
||
finance_management: "Pénzügyek Kezelése",
|
||
packages: "Csomagok",
|
||
commission_rules: "Jutalék Szabályok",
|
||
financial_ledger: "Pénzügyi Napló",
|
||
gamification: "Gamification",
|
||
game_settings: "Játékmenet Beállítások",
|
||
point_rules: "Pontszabályok",
|
||
levels: "Szintek",
|
||
badges: "Kitüntetések",
|
||
validation_rules: "Validációs Szabályok",
|
||
events_and_seasons: "Események & Szezonok",
|
||
seasons: "Szezonok",
|
||
competitions: "Versenyek",
|
||
user_data: "Felhasználói Adatok",
|
||
statistics: "Statisztikák",
|
||
leaderboard: "Ranglista",
|
||
points_ledger: "Pontnapló",
|
||
ledger: "Pontnapló",
|
||
gamification_hq: "Gamification HQ",
|
||
system_config: "Rendszer Konfig",
|
||
system_parameters: "Rendszerparaméterek",
|
||
system: "Rendszer",
|
||
permissions: "Jogosultságok",
|
||
system_logs: "Rendszernaplók"
|
||
};
|
||
const locale_menu_46json_d8dcbc3e = {
|
||
menu: menu$1
|
||
};
|
||
|
||
var dashboard$1 = {
|
||
title: "Admin Dashboard",
|
||
subtitle: "Rendszer áttekintő irányítópult",
|
||
loading: "Dashboard betöltése...",
|
||
error: "Nem sikerült betölteni a dashboard adatokat.",
|
||
active_users: "Aktív Felhasználók",
|
||
new_this_month: "új e hónapban",
|
||
total_vehicles: "Összes Jármű",
|
||
organizations: "Szervezetek",
|
||
memberships: "tagság",
|
||
new_users: "Új Felhasználók",
|
||
new_today: "ma",
|
||
users_by_role: "Felhasználók Szerepkör Szerint",
|
||
users_by_plan: "Felhasználók Csomag Szerint",
|
||
users_by_language: "Felhasználók Nyelv Szerint",
|
||
registration_trend: "Regisztrációs Trend",
|
||
quick_actions: "Gyors Műveletek",
|
||
invite_admin: "Admin Meghívása",
|
||
add_vehicle: "Jármű Hozzáadása",
|
||
view_reports: "Jelentések Megtekintése",
|
||
recent_activity: "Legutóbbi Tevékenység",
|
||
total_users: "Összes Felhasználó",
|
||
active_season: "Aktív Szezon",
|
||
pending_contributions: "Függő Hozzájárulások",
|
||
xp_earned_today: "Ma Szerzett XP",
|
||
none: "Nincs",
|
||
manage_point_rules: "Pontszabályok kezelése",
|
||
manage_badges: "Kitüntetések kezelése",
|
||
manage_seasons: "Szezonok kezelése",
|
||
recent_ledger: "Legutóbbi Pontnapló Bejegyzések",
|
||
no_ledger: "Még nincsenek pontnapló bejegyzések.",
|
||
top_5: "Top 5 Ranglista",
|
||
full_leaderboard: "Teljes ranglista →",
|
||
no_leaderboard: "Még nincsenek ranglista adatok.",
|
||
level: "Szint",
|
||
xp: "XP",
|
||
points: "pont"
|
||
};
|
||
const locale_dashboard_46json_d0703406 = {
|
||
dashboard: dashboard$1
|
||
};
|
||
|
||
var providers$1 = {
|
||
title: "Szolgáltatók",
|
||
subtitle: "Szolgáltatók listázása, keresése és moderálása",
|
||
loading: "Szolgáltatók betöltése...",
|
||
error: "Hiba történt a szolgáltatók betöltése közben.",
|
||
retry: "Újrapróbálkozás",
|
||
stats_total: "Összes",
|
||
stats_pending: "Függőben",
|
||
stats_approved: "Jóváhagyott",
|
||
stats_rejected: "Elutasított",
|
||
stats_flagged: "Megjelölt",
|
||
search_placeholder: "Keresés név alapján...",
|
||
filter_all_status: "Minden státusz",
|
||
filter_pending: "Függőben",
|
||
filter_approved: "Jóváhagyott",
|
||
filter_rejected: "Elutasított",
|
||
filter_flagged: "Megjelölt",
|
||
filter_all_sources: "Minden forrás",
|
||
source_manual: "Kézi",
|
||
source_ocr: "OCR",
|
||
source_import: "Import",
|
||
source_bot: "Bot (Staging)",
|
||
source_verified_org: "Szervezet",
|
||
sort_created_at: "Létrehozás dátuma",
|
||
sort_name: "Név",
|
||
sort_validation_score: "Validációs pontszám",
|
||
col_id: "ID",
|
||
col_name: "Név",
|
||
col_address: "Cím",
|
||
col_status: "Státusz",
|
||
col_source: "Forrás",
|
||
col_validation: "Validáció",
|
||
col_created: "Létrehozva",
|
||
col_actions: "Műveletek",
|
||
no_providers: "Nincs megjeleníthető szolgáltató.",
|
||
results_count: "{count} találat (összesen: {total})",
|
||
page: "{page}. oldal",
|
||
view_details: "Részletek",
|
||
status_pending: "Függőben",
|
||
status_approved: "Jóváhagyott",
|
||
status_rejected: "Elutasított",
|
||
status_flagged: "Megjelölt",
|
||
provider_detail: "Szolgáltató részletek",
|
||
detail_loading: "Szolgáltató betöltése...",
|
||
detail_not_found: "A szolgáltató nem található.",
|
||
detail_back: "Vissza a szolgáltatókhoz",
|
||
detail_provider_number: "Szolgáltató #{id}",
|
||
detail_raw_data: "Nyers adatok",
|
||
detail_tab_data: "Adatok",
|
||
detail_tab_status: "Státusz",
|
||
detail_tab_validations: "Validációk",
|
||
detail_tab_crawler: "Crawler / Nyers Adatok",
|
||
detail_tab_history: "Előzmények",
|
||
detail_section_basic: "Alapadatok",
|
||
detail_section_address: "Cím adatok",
|
||
detail_section_contact: "Elérhetőség",
|
||
detail_section_services: "Szolgáltatások",
|
||
detail_section_vehicle_classes: "Járműosztályok",
|
||
detail_section_specializations: "Specializációk",
|
||
detail_section_opening_hours: "Nyitvatartás",
|
||
detail_section_evidence: "Bizonyíték kép",
|
||
detail_section_moderation: "Moderációs műveletek",
|
||
detail_section_status_management: "Státusz kezelés",
|
||
detail_section_validation_score: "Validációs Pontszám",
|
||
detail_section_gamification_validations: "Gamification Validációk",
|
||
detail_section_crawler_data: "Crawler / Nyers Adatok",
|
||
detail_section_history: "Állapotváltoztatások előzményei",
|
||
detail_field_name: "Név",
|
||
detail_field_category: "Kategória",
|
||
detail_field_source: "Forrás",
|
||
detail_field_validation_score: "Validációs pontszám",
|
||
detail_field_created: "Létrehozva",
|
||
detail_field_submitted_by: "Beküldő user ID",
|
||
detail_field_full_address: "Teljes cím",
|
||
detail_field_city: "Város",
|
||
detail_field_zip: "Irányítószám",
|
||
detail_field_street: "Utca",
|
||
detail_field_house_number: "Házszám",
|
||
detail_field_plus_code: "Plus Code",
|
||
detail_field_phone: "Telefon",
|
||
detail_field_email: "Email",
|
||
detail_field_website: "Weboldal",
|
||
detail_no_categories: "Nincsenek kategóriák beállítva",
|
||
detail_no_vehicle_classes: "Nincsenek járműosztályok beállítva",
|
||
detail_no_specializations: "Nincsenek specializációk beállítva",
|
||
detail_no_opening_hours: "Nincs beállítva nyitvatartás",
|
||
detail_day_monday: "Hétfő",
|
||
detail_day_tuesday: "Kedd",
|
||
detail_day_wednesday: "Szerda",
|
||
detail_day_thursday: "Csütörtök",
|
||
detail_day_friday: "Péntek",
|
||
detail_day_saturday: "Szombat",
|
||
detail_day_sunday: "Vasárnap",
|
||
detail_day_label: "Nap",
|
||
detail_hours_label: "Nyitva",
|
||
detail_closed: "Zárva",
|
||
detail_specialization_brands: "Márkák",
|
||
detail_specialization_propulsion: "Hajtáslánc",
|
||
detail_status_approved: "Jóváhagyva",
|
||
detail_status_pending: "Függőben",
|
||
detail_status_research: "Kutatás folyamatban",
|
||
detail_status_rejected: "Elutasítva",
|
||
detail_status_unknown: "Ismeretlen",
|
||
detail_status_desc_approved: "A szolgáltató aktív és látható a felhasználók számára.",
|
||
detail_status_desc_pending: "A szolgáltató még nem lett jóváhagyva, moderálásra vár.",
|
||
detail_status_desc_research: "A szolgáltató adatai még feldolgozás alatt állnak, automatikus kutatás folyik.",
|
||
detail_status_desc_rejected: "A szolgáltató elutasításra került, nem látható a felhasználók számára.",
|
||
detail_edit: "Szerkesztés",
|
||
detail_approve: "Jóváhagyás",
|
||
detail_reject: "Elutasítás",
|
||
detail_flag: "Megjelölés (Flag)",
|
||
detail_delete: "Törlés (Soft Delete)",
|
||
detail_restore: "Visszaállítás",
|
||
detail_status_rejected_or_flagged: "A szolgáltató {status} került.",
|
||
detail_status_rejected_text: "elutasításra",
|
||
detail_status_flagged_text: "megjelölésre",
|
||
detail_status_form_label: "Státusz",
|
||
detail_status_form_score: "Validációs pontszám (0-100)",
|
||
detail_status_form_reason: "Indoklás (opcionális)",
|
||
detail_status_form_reason_placeholder: "Add meg a státuszváltoztatás okát...",
|
||
detail_status_form_cancel: "Mégsem",
|
||
detail_status_form_save: "Státusz mentése",
|
||
detail_validation_score_excellent: "Kiváló",
|
||
detail_validation_score_medium: "Közepes",
|
||
detail_validation_score_weak: "Gyenge",
|
||
detail_validation_score_desc: "A szolgáltató megbízhatósági pontszáma a gamification validációk alapján.",
|
||
detail_validation_no_entries: "Nincsenek validációs bejegyzések ehhez a szolgáltatóhoz.",
|
||
detail_validation_voter: "Szavazó:",
|
||
detail_validation_reason: "Indoklás:",
|
||
detail_validation_weight: "súly:",
|
||
detail_crawler_source: "Forrás:",
|
||
detail_crawler_trust_score: "Trust Score:",
|
||
detail_crawler_rejection_reason_title: "Elutasítás indoklása",
|
||
detail_crawler_raw_data: "Nyers adatok (raw_data)",
|
||
detail_crawler_audit_trail: "Audit Trail",
|
||
detail_history_no_entries: "Nincsenek előzmények ehhez a szolgáltatóhoz.",
|
||
detail_history_user: "User #{id}",
|
||
detail_history_status: "Státusz:",
|
||
detail_history_reason: "Indoklás:",
|
||
detail_history_detailed_changes: "Részletes változások",
|
||
detail_history_old_data: "Régi adatok",
|
||
detail_flag_modal_title: "Szolgáltató megjelölése",
|
||
detail_flag_modal_body: "Biztosan megjelölöd a(z) {name} szolgáltatót?",
|
||
detail_flag_reason_label: "Indoklás (opcionális)",
|
||
detail_flag_reason_placeholder: "Add meg a megjelölés okát...",
|
||
detail_flag_submit: "Megjelölés",
|
||
detail_toast_approved: "Szolgáltató jóváhagyva!",
|
||
detail_toast_rejected: "Szolgáltató elutasítva!",
|
||
detail_toast_restored: "Szolgáltató visszaállítva!",
|
||
detail_toast_flagged: "Szolgáltató megjelölve!",
|
||
detail_toast_deleted: "Szolgáltató törölve!",
|
||
detail_toast_status_updated: "Státusz frissítve!",
|
||
detail_toast_error_approve: "Hiba a jóváhagyás során",
|
||
detail_toast_error_reject: "Hiba az elutasítás során",
|
||
detail_toast_error_restore: "Hiba a visszaállítás során",
|
||
detail_toast_error_flag: "Hiba a megjelölés során",
|
||
detail_toast_error_delete: "Hiba a törlés során",
|
||
detail_toast_error_status: "Hiba a státusz mentése során",
|
||
detail_delete_confirm: "Biztosan törlöd ezt a szolgáltatót? Ez a művelet nem visszavonható.",
|
||
detail_vehicle_class_car: "Személyautó",
|
||
detail_vehicle_class_motorcycle: "Motorkerékpár",
|
||
detail_vehicle_class_truck: "Teherautó",
|
||
detail_vehicle_class_hgv: "Nehézgépjármű (HGV)",
|
||
detail_vehicle_class_light_commercial: "Kishaszonjármű",
|
||
detail_vehicle_class_personal: "Személyes",
|
||
detail_vehicle_class_boat: "Csónak/Vízi",
|
||
detail_vehicle_class_other: "Egyéb",
|
||
detail_validation_type_phone_verified: "Telefon igazolt",
|
||
detail_validation_type_email_verified: "Email igazolt",
|
||
detail_validation_type_address_verified: "Cím igazolt",
|
||
detail_validation_type_website_verified: "Weboldal igazolt",
|
||
detail_validation_type_manual_review: "Kézi ellenőrzés",
|
||
detail_validation_type_community_vouch: "Közösségi ajánlás",
|
||
detail_validation_type_business_hours: "Nyitvatartás ellenőrzött",
|
||
detail_validation_type_photo_evidence: "Fénykép bizonyíték",
|
||
detail_history_action_approve: "Jóváhagyás",
|
||
detail_history_action_reject: "Elutasítás",
|
||
detail_history_action_restore: "Visszaállítás",
|
||
detail_history_action_flag: "Megjelölés",
|
||
detail_history_action_update: "Módosítás",
|
||
detail_history_action_delete: "Törlés",
|
||
detail_history_action_create: "Létrehozás",
|
||
pending_title: "Jóváhagyásra váró szolgáltatók",
|
||
pending_subtitle: "A közösség által beküldött szolgáltatók moderációs sora",
|
||
pending_loading: "Függőben lévő szolgáltatók betöltése...",
|
||
rejected_title: "Elutasított szolgáltatók",
|
||
rejected_subtitle: "Elutasított szolgáltatók visszaállítása az aktív kereshető szolgáltatók közé",
|
||
rejected_loading: "Elutasított szolgáltatók betöltése...",
|
||
approve: "Jóváhagyás",
|
||
reject: "Elutasítás",
|
||
restore: "Visszaállítás",
|
||
details: "Részletek",
|
||
reject_modal_title: "Szolgáltató elutasítása",
|
||
reject_modal_body: "Biztosan elutasítod a(z) {name} szolgáltatót?",
|
||
reject_reason_label: "Indoklás (opcionális)",
|
||
reject_reason_placeholder: "Add meg az elutasítás okát...",
|
||
restore_modal_title: "Szolgáltató visszaállítása",
|
||
restore_modal_body: "Biztosan visszaállítod a(z) {name} szolgáltatót? A visszaállítás után a szolgáltató újra elérhető lesz a keresőben és a listákban.",
|
||
restore_reason_label: "Indoklás (opcionális)",
|
||
restore_reason_placeholder: "Add meg a visszaállítás okát...",
|
||
no_pending: "Nincs függőben lévő szolgáltató",
|
||
no_pending_subtitle: "Minden beküldött szolgáltató fel lett dolgozva.",
|
||
no_rejected: "Nincs elutasított szolgáltató",
|
||
no_rejected_subtitle: "Minden szolgáltató jóváhagyott státuszban van.",
|
||
approved_toast: "\"{name}\" sikeresen jóváhagyva",
|
||
rejected_toast: "\"{name}\" elutasítva",
|
||
restored_toast: "\"{name}\" sikeresen visszaállítva",
|
||
error_prefix: "Hiba: {detail}",
|
||
unknown_error: "Ismeretlen hiba",
|
||
label_address: "Cím:",
|
||
label_city: "Város:",
|
||
label_category: "Kategória:",
|
||
label_validation_score: "Validációs pontszám:",
|
||
label_submitted: "Beküldve:",
|
||
label_created: "Létrehozva:",
|
||
edit_title: "Szolgáltató szerkesztése",
|
||
edit_loading: "Szolgáltató betöltése...",
|
||
edit_error: "Hiba történt a szolgáltató betöltése közben.",
|
||
edit_not_found: "A szolgáltató nem található.",
|
||
edit_back: "Vissza a szolgáltatóhoz",
|
||
edit_raw_data: "Nyers adatok",
|
||
edit_tab_basic: "Alapadatok & Kapcsolat",
|
||
edit_tab_matrix: "Szolgáltatások & Járművek",
|
||
edit_tab_location: "Helyszín & Lokáció",
|
||
edit_tab_hours: "Nyitvatartás",
|
||
edit_section_basic: "Alapadatok",
|
||
edit_section_contact: "Elérhetőség",
|
||
edit_section_matrix: "3D Képesség Mátrix",
|
||
edit_section_matrix_desc: "Állítsd be, hogy a szolgáltató milyen járműosztályokhoz, szolgáltatási kategóriákhoz és specializációkhoz tartozik.",
|
||
edit_section_vehicle_classes: "Járműosztályok (Vehicle Classes)",
|
||
edit_section_vehicle_classes_desc: "Mely járműtípusokat szervizeli a szolgáltató?",
|
||
edit_section_expertise_tags: "Szolgáltatási Kategóriák (Expertise Tags)",
|
||
edit_section_expertise_tags_desc: "Válaszd ki a szolgáltatóhoz tartozó kategóriákat a hierarchikus fából.",
|
||
edit_section_specializations: "Specializációk",
|
||
edit_section_specializations_desc: "Adj meg speciális márkákat, hajtáslánc típusokat vagy egyéb címkéket.",
|
||
edit_section_location_extra: "További helyszín adatok",
|
||
edit_section_opening_hours: "Nyitvatartás",
|
||
edit_section_opening_hours_desc: "Állítsd be a szolgáltató nyitvatartási idejét napokra bontva.",
|
||
edit_field_name: "Név *",
|
||
edit_field_category: "Kategória",
|
||
edit_field_category_placeholder: "pl. Autószerviz, Gumiszerviz",
|
||
edit_field_source: "Forrás",
|
||
edit_field_phone: "Telefon",
|
||
edit_field_phone_placeholder: "+36 30 123 4567",
|
||
edit_field_email: "Email",
|
||
edit_field_email_placeholder: "info{'@'}example.com",
|
||
edit_field_website: "Weboldal",
|
||
edit_field_website_placeholder: "https://...",
|
||
edit_field_full_address: "Teljes cím szövege",
|
||
edit_field_full_address_placeholder: "Teljes cím szövege",
|
||
edit_field_plus_code: "Plus Code",
|
||
edit_field_plus_code_placeholder: "8FVC9X8V+XV",
|
||
edit_field_brands: "Márkák (Brands)",
|
||
edit_field_brands_placeholder: "pl. Volvo, Scania",
|
||
edit_field_propulsion: "Hajtáslánc (Propulsion)",
|
||
edit_field_propulsion_placeholder: "pl. EV, Hybrid, Diesel",
|
||
edit_field_add: "Hozzáad",
|
||
edit_always_open: "Folyamatos (0-24) nyitvatartás",
|
||
edit_always_open_desc: "A szolgáltató a hét minden napján 0-24 óráig nyitva van",
|
||
edit_btn_24_7: "24/7 Folyamatos nyitvatartás",
|
||
edit_btn_copy_weekdays: "Hétköznapok másolása (Hétfő → K-P)",
|
||
edit_btn_clear_all: "Összes törlése",
|
||
edit_closed: "Zárva",
|
||
edit_has_changes: "● Módosítások el nem mentve",
|
||
edit_no_changes: "Nincs változás",
|
||
edit_cancel: "Mégse",
|
||
edit_save: "Mentés",
|
||
edit_toast_saved: "Szolgáltató sikeresen frissítve!",
|
||
edit_toast_promoted: "Sikeres előléptetés!",
|
||
edit_toast_error: "Hiba a mentés során: {message}",
|
||
edit_copy_weekdays_open_prompt: "Add meg a nyitási időt (pl. 08:00):",
|
||
edit_copy_weekdays_close_prompt: "Add meg a zárási időt (pl. 17:00):",
|
||
edit_categories_loading: "Kategóriák betöltése...",
|
||
edit_level_label: "(Szint {level})",
|
||
edit_source_label: "Forrás:",
|
||
edit_trust_score_label: "Trust Score:",
|
||
edit_raw_data_title: "Nyers adatok (raw_data)",
|
||
edit_audit_trail_title: "Audit Trail",
|
||
edit_rejection_reason_title: "Elutasítás indoklása"
|
||
};
|
||
const locale_providers_46json_ca903007 = {
|
||
providers: providers$1
|
||
};
|
||
|
||
var garages$1 = {
|
||
title: "Garázsok CRM",
|
||
subtitle: "Garázsok listája, csomagkezelés és státuszmódosítás",
|
||
total_garages: "Összes Garázs",
|
||
private_garages: "Privát Garázsok",
|
||
corporate_garages: "Céges Garázsok",
|
||
search_placeholder: "Keresés név, kapcsolattartó vagy e-mail alapján...",
|
||
all_tiers: "Összes csomag",
|
||
all_types: "Összes típus",
|
||
type_individual: "Privát (Egyéni)",
|
||
type_corporate: "Céges (Vállalati)",
|
||
company_name: "Cégnév",
|
||
email: "E-mail",
|
||
status: "Státusz",
|
||
current_package: "Aktuális Csomag",
|
||
expiration_date: "Lejárat Dátuma",
|
||
actions: "Műveletek",
|
||
active: "Aktív",
|
||
inactive: "Inaktív",
|
||
suspended: "Felfüggesztve",
|
||
change_package: "Csomag Módosítása",
|
||
manage_subscription: "Előfizetés Kezelése",
|
||
view: "Megtekintés",
|
||
activate: "Aktiválás",
|
||
deactivate: "Deaktiválás",
|
||
no_results: "Nincs a keresésnek megfelelő garázs.",
|
||
loading: "Garázsok betöltése...",
|
||
retry: "Újra",
|
||
members: "tag",
|
||
free_fallback: "Ingyenes / Visszaesési",
|
||
expires: "Lejárat",
|
||
select_package: "Csomag Kiválasztása",
|
||
select_package_placeholder: "Válassz egy előfizetési csomagot...",
|
||
custom_expiration: "Egyéni Lejárati Dátum",
|
||
optional: "opcionális",
|
||
custom_expiration_hint: "Hagyd üresen az alapértelmezett időtartamhoz (pl. 30 nap). 2-5 éves B2B deal-eknél adj meg egyedi dátumot!",
|
||
cancel: "Mégse",
|
||
save: "Mentés",
|
||
saving: "Mentés...",
|
||
subscription_updated: "előfizetése sikeresen frissítve!",
|
||
view_details: "Részletek",
|
||
indefinite: "Határozatlan",
|
||
addons_title: "Kiegészítők (Add-ons)",
|
||
addon_vehicles: "Extra Jármű",
|
||
addon_branches: "Extra Telephely",
|
||
addon_users: "Extra Dolgozó",
|
||
active_addons: "Aktív kiegészítők",
|
||
no_active_addons: "Nincsenek aktív kiegészítők",
|
||
addon_vehicles_expiration: "Extra Jármű lejárati dátuma",
|
||
addon_branches_expiration: "Extra Telephely lejárati dátuma",
|
||
addon_users_expiration: "Extra Dolgozó lejárati dátuma",
|
||
addon_expiration_hint: "Ha üres, a meglévő lejárati dátumok megmaradnak.",
|
||
details: {
|
||
loading: "Garázs adatainak betöltése...",
|
||
retry: "Újra",
|
||
back: "Vissza a garázsokhoz",
|
||
company_info: "Cég adatok",
|
||
company_name: "Cégnév",
|
||
display_name: "Megjelenítési név",
|
||
org_type: "Szervezet típusa",
|
||
tax_number: "Adószám",
|
||
reg_number: "Cégjegyzékszám",
|
||
created_at: "Létrehozva",
|
||
address: "Cím",
|
||
subscription_info: "Előfizetés státusza",
|
||
tier_name: "Csomag",
|
||
tier_level: "Szint",
|
||
level_n: "{n}. szint",
|
||
expires_at: "Lejárat",
|
||
asset_limit: "Járműkorlát",
|
||
vehicles: "jármű",
|
||
no_subscription: "Nincs aktív előfizetés",
|
||
contact_info: "Elérhetőség",
|
||
contact_name: "Kapcsolattartó neve",
|
||
contact_role: "Szerepkör",
|
||
contact_department: "Osztály",
|
||
contact_phone: "Kapcsolattartó telefon",
|
||
no_contact: "Nincs elsődleges kapcsolattartó",
|
||
edit_details: "Adatok Szerkesztése",
|
||
save: "Mentés",
|
||
generalTab: "Általános",
|
||
employeesTab: "Dolgozók",
|
||
fleetTab: "Flotta",
|
||
analyticsTab: "Analitika",
|
||
subscriptionTab: "Előfizetés",
|
||
editBasicTab: "Alapadatok",
|
||
editContactTab: "Kapcsolat",
|
||
editAddressTab: "Címek",
|
||
zip: "Irányítószám",
|
||
city: "Város",
|
||
street_name: "Utca",
|
||
street_type: "Utca típusa",
|
||
house_number: "Házszám",
|
||
coming_soon: "Ez a funkció hamarosan elérhető lesz...",
|
||
missing_data_title: "Hiányzó adatok",
|
||
missing_data_desc: "A garázs profilja hiányos. Kérjük, egészítse ki a hiányzó adatokat.",
|
||
missing_data_activation_required: "A garázs aktiválásához az alábbi adatok pótlása kötelező:",
|
||
missing_tax_number: "Adószám",
|
||
missing_billing: "Számlázási cím",
|
||
missing_contact_email: "Kapcsolattartó e-mail",
|
||
missing_contact_phone: "Kapcsolattartó telefon",
|
||
missing_data_count: "{count} mező hiányzik",
|
||
contact_person_name: "Kapcsolattartó neve",
|
||
contact_email: "Kapcsolattartó e-mail",
|
||
billing_address: "Számlázási cím",
|
||
billing_zip: "Irányítószám",
|
||
billing_city: "Város",
|
||
billing_street_name: "Utca",
|
||
billing_street_type: "Utca típusa",
|
||
billing_house_number: "Házszám",
|
||
notification_address: "Értesítési cím",
|
||
notification_zip: "Irányítószám",
|
||
notification_city: "Város",
|
||
notification_street_name: "Utca",
|
||
notification_street_type: "Utca típusa",
|
||
notification_house_number: "Házszám",
|
||
tab_basic: "Alapadatok",
|
||
tab_contact: "Kapcsolat",
|
||
tab_addresses: "Címek",
|
||
basic_info: "Alapadatok",
|
||
contact_section: "Kapcsolattartó",
|
||
addresses_section: "Címek",
|
||
vehicles_used: "Járművek",
|
||
branches_used: "Telephelyek",
|
||
employees_used: "Dolgozók",
|
||
branches: "telephely",
|
||
employees: "dolgozó",
|
||
status: "Státusz",
|
||
subscription_history: "Előfizetési Előzmények",
|
||
history_date: "Dátum",
|
||
history_package: "Csomag",
|
||
history_action: "Művelet",
|
||
history_status: "Státusz",
|
||
no_subscription_history: "Még nincsenek előfizetési előzmények."
|
||
},
|
||
employees: {
|
||
title: "Dolgozók",
|
||
total_count: "Összesen {count} fő",
|
||
name: "Név",
|
||
email_phone: "E-mail / Telefon",
|
||
role: "Szerepkör",
|
||
status: "Státusz",
|
||
actions: "Műveletek",
|
||
edit_role: "Szerepkör szerkesztése",
|
||
remove: "Eltávolítás",
|
||
no_employees: "Még nincsenek tagok ehhez a garázshoz.",
|
||
edit_role_title: "Tag szerepkörének szerkesztése",
|
||
editRoleTitle: "Tag szerepkörének szerkesztése",
|
||
editRoleFor: "{name} szerepkörének módosítása",
|
||
cancel: "Mégse",
|
||
save: "Mentés",
|
||
saveRole: "Szerepkör mentése",
|
||
saving: "Mentés...",
|
||
status_active: "Aktív",
|
||
status_inactive: "Inaktív",
|
||
remove_title: "Tag eltávolítása",
|
||
removeTitle: "Tag eltávolítása",
|
||
remove_confirm: "Biztosan eltávolítod {name} tagot a garázsból?",
|
||
removeConfirm: "Biztosan eltávolítod {name} tagot a garázsból?",
|
||
remove_btn: "Eltávolítás",
|
||
removing: "Eltávolítás...",
|
||
add_employee: "Új dolgozó hozzáadása",
|
||
addTitle: "Új dolgozó hozzáadása",
|
||
email: "E-mail cím",
|
||
emailPlaceholder: "Add meg az e-mail címet...",
|
||
roleMember: "Tag",
|
||
roleManager: "Menedzser",
|
||
roleAdmin: "Admin",
|
||
roleOwner: "Tulajdonos",
|
||
add: "Hozzáadás",
|
||
adding: "Hozzáadás..."
|
||
},
|
||
fleet: {
|
||
title: "Flotta",
|
||
total_vehicles: "Összesen {count} jármű",
|
||
plate: "Rendszám",
|
||
brand: "Márka",
|
||
model: "Modell",
|
||
brand_model: "Márka & Modell",
|
||
year: "Évjárat",
|
||
status: "Státusz",
|
||
vin: "Alvázszám",
|
||
no_vehicles: "Ehhez a garázshoz még nincsenek járművek rendelve.",
|
||
no_fleet_access: "Nincs jogosultságod a flotta adatok megtekintéséhez."
|
||
},
|
||
analytics: {
|
||
ltv: "Élettartam Érték (LTV)",
|
||
mrr: "Havi Bevétel (MRR)",
|
||
monthly_recurring: "Havi ismétlődő bevétel",
|
||
outstanding: "Kintlévőség",
|
||
all_settled: "Minden számla rendezve",
|
||
earned_credits: "Szerzett Kreditek",
|
||
contribution_xp: "Platform építésével gyűjtött XP",
|
||
invited_companies: "Meghívott Cégek",
|
||
companies_joined: "Cég csatlakozott a meghívásodra",
|
||
validated_garages: "Validált Garázsok",
|
||
garages_confirmed: "Garázs sikeresen hitelesítve",
|
||
utilization: "Kihasználtság",
|
||
vehicle_quota: "Jármű Kvóta",
|
||
employee_quota: "Alkalmazotti Kvóta",
|
||
utilized: "kihasználva",
|
||
marketplace_engagement: "Piactér & Aktivitás",
|
||
avg_rating: "Átlagos Értékelés",
|
||
reviews: "Értékelések",
|
||
reviews_count: "értékelés",
|
||
last_activity: "Utolsó Aktivitás",
|
||
last_login_mock: "2 órája",
|
||
services_30d: "Elvégzett Szervizek (30 nap)"
|
||
}
|
||
};
|
||
const locale_garages_46json_a818fc5b = {
|
||
garages: garages$1
|
||
};
|
||
|
||
var users$1 = {
|
||
title: "Felhasználó Kezelés",
|
||
subtitle: "Felhasználói lista, keresés, szűrők és csoportos műveletek",
|
||
loading: "Felhasználók betöltése...",
|
||
retry: "Újra",
|
||
search_placeholder: "Keresés e-mail, név vagy telefonszám alapján...",
|
||
all_statuses: "Összes státusz",
|
||
status_active: "Aktív",
|
||
status_inactive: "Inaktív",
|
||
status_deleted: "Törölt",
|
||
status_banned: "Kitiltva",
|
||
all_roles: "Összes szerepkör",
|
||
role_user: "Felhasználó",
|
||
role_admin: "Admin",
|
||
role_staff: "Munkatárs",
|
||
role_superadmin: "Superadmin",
|
||
all_plans: "Összes csomag",
|
||
plan_free: "Ingyenes",
|
||
plan_premium: "Prémium",
|
||
plan_enterprise: "Vállalati",
|
||
total_users: "Összes Felhasználó",
|
||
active_users: "Aktív Felhasználók",
|
||
deleted_users: "Törölt Felhasználók",
|
||
banned_users: "Kitiltott Felhasználók",
|
||
new_today: "Ma Regisztráltak",
|
||
filtered_results: "Szűrt eredmények",
|
||
selected_count: "{count} felhasználó kiválasztva",
|
||
bulk_activate: "Aktiválás",
|
||
bulk_deactivate: "Deaktiválás",
|
||
clear_selection: "Kijelölés törlése",
|
||
email: "E-mail",
|
||
name: "Név",
|
||
role: "Szerepkör",
|
||
status: "Státusz",
|
||
"package": "Csomag",
|
||
registration: "Regisztráció",
|
||
language: "Nyelv",
|
||
actions: "Műveletek",
|
||
view: "Megtekintés",
|
||
activate: "Aktiválás",
|
||
deactivate: "Deaktiválás",
|
||
no_results: "Nincs a keresésnek megfelelő felhasználó.",
|
||
showing: "Mutató",
|
||
prev: "Előző",
|
||
next: "Következő",
|
||
details: {
|
||
loading: "Felhasználó adatainak betöltése...",
|
||
retry: "Újra",
|
||
back: "Vissza a felhasználókhoz",
|
||
edit: "Felhasználó szerkesztése",
|
||
edit_user: "Felhasználó szerkesztése",
|
||
profile_tab: "Profil",
|
||
memberships_tab: "Tagságok",
|
||
account_info: "Fiók Információk",
|
||
user_id: "Felhasználó ID",
|
||
registration_date: "Regisztráció Dátuma",
|
||
last_login: "Utolsó Belépés",
|
||
ui_mode: "UI Mód",
|
||
region: "Régió",
|
||
currency: "Pénznem",
|
||
subscription_info: "Előfizetés Információk",
|
||
subscription_expires: "Lejárat Dátuma",
|
||
scope_level: "Hatósugár Szint",
|
||
scope_id: "Hatósugár ID",
|
||
max_vehicles: "Max Járművek",
|
||
max_garages: "Max Garázsok",
|
||
personal_info: "Személyes Információk",
|
||
last_name: "Vezetéknév",
|
||
first_name: "Keresztnév",
|
||
phone: "Telefon",
|
||
birth_place: "Születési Hely",
|
||
birth_date: "Születési Dátum",
|
||
mothers_name: "Anyja Neve",
|
||
mothers_first_name: "Anyja Keresztneve",
|
||
address: "Cím",
|
||
zip: "Irányítószám",
|
||
city: "Város",
|
||
street: "Utca",
|
||
house_number: "Házszám",
|
||
no_person_record: "Nem található személyes adat ehhez a felhasználóhoz.",
|
||
memberships: "Szervezeti Tagságok",
|
||
memberships_count: "{count} tagság",
|
||
no_memberships: "Ez a felhasználó nem tagja egyetlen szervezetnek sem.",
|
||
org_name: "Szervezet",
|
||
org_role: "Szerepkör",
|
||
member_status: "Státusz",
|
||
joined_at: "Csatlakozott",
|
||
verified: "Hitelesítve",
|
||
verified_yes: "Igen",
|
||
verified_no: "Nem",
|
||
preferred_language: "Előnyben Részesített Nyelv",
|
||
is_active: "Aktív",
|
||
is_vip: "VIP",
|
||
cancel: "Mégse",
|
||
save: "Változtatások Mentése",
|
||
saving: "Mentés...",
|
||
danger_zone: "Veszélyes Zóna",
|
||
danger_zone_warning: "Ez a művelet visszafordíthatatlan. A felhasználó összes adata véglegesen eltávolításra kerül.",
|
||
danger_zone_button: "Felhasználó végleges törlése",
|
||
danger_zone_confirm_label: "A megerősítéshez gépeld be a felhasználó e-mail címét:",
|
||
danger_zone_confirm_placeholder: "Add meg az e-mail címet...",
|
||
danger_zone_confirm_button: "Megértettem, a felhasználó végleges törlése",
|
||
danger_zone_cancel: "Mégse",
|
||
danger_zone_success: "A felhasználó véglegesen törölve lett.",
|
||
danger_zone_error_financial: "Nem törölhető: A felhasználónak pénzügyi rekordjai vannak.",
|
||
danger_zone_error_not_superadmin: "Csak Superadminok végezhetnek végleges törlést.",
|
||
danger_zone_error_generic: "Sikertelen törlés: {message}"
|
||
},
|
||
persons: {
|
||
title: "Személyek Kezelése",
|
||
subtitle: "Személyek listája, keresés, szűrők és részletek",
|
||
loading: "Személyek betöltése...",
|
||
retry: "Újra",
|
||
search_placeholder: "Keresés név, telefonszám vagy e-mail alapján...",
|
||
all_ghost_statuses: "Összes szellem státusz",
|
||
ghost_no: "Nem szellem",
|
||
ghost_yes: "Szellem",
|
||
all_active_statuses: "Összes aktív státusz",
|
||
active_yes: "Aktív",
|
||
active_no: "Inaktív",
|
||
all_user_statuses: "Összes felhasználói státusz",
|
||
has_user_yes: "Van felhasználó",
|
||
has_user_no: "Nincs felhasználó",
|
||
all_merged_statuses: "Összes egyesítési státusz",
|
||
merged_no: "Nincs egyesítve",
|
||
merged_yes: "Egyesítve",
|
||
total_persons: "Összes Személy",
|
||
active_persons: "Aktív Személyek",
|
||
ghost_persons: "Szellem Személyek",
|
||
merged_persons: "Egyesített Személyek",
|
||
filtered_results: "Szűrt eredmények",
|
||
name: "Név",
|
||
phone: "Telefonszám",
|
||
birth_date: "Születési Dátum",
|
||
status: "Státusz",
|
||
users_count: "Felhasználók",
|
||
active_user: "Aktív Felhasználó",
|
||
address: "Cím",
|
||
actions: "Műveletek",
|
||
active: "Aktív",
|
||
inactive: "Inaktív",
|
||
ghost: "Szellem",
|
||
merged: "Egyesítve",
|
||
view: "Megtekintés",
|
||
no_results: "Nincs a keresésnek megfelelő személy.",
|
||
showing: "Mutató",
|
||
prev: "Előző",
|
||
next: "Következő",
|
||
details: {
|
||
loading: "Személy adatainak betöltése...",
|
||
retry: "Újra",
|
||
back: "Vissza a listához",
|
||
sales_agent: "Értékesítési Ügynök",
|
||
edit: "Szerkesztés",
|
||
personal_info: "Személyes Adatok",
|
||
person_id: "Személy ID",
|
||
uuid: "UUID",
|
||
last_name: "Vezetéknév",
|
||
first_name: "Keresztnév",
|
||
birth_place: "Születési Hely",
|
||
mothers_name: "Anyja Neve",
|
||
mothers_last_name: "Anyja Vezetékneve",
|
||
mothers_first_name: "Anyja Keresztneve",
|
||
address: "Cím",
|
||
zip: "Irányítószám",
|
||
city: "Város",
|
||
street: "Utca",
|
||
house_number: "Házszám",
|
||
stairwell: "Lépcsőház",
|
||
floor: "Emelet",
|
||
door: "Ajtó",
|
||
parcel_id: "Helyrajzi Szám (HRSZ)",
|
||
full_address: "Teljes Cím",
|
||
system_info: "Rendszer Információk",
|
||
is_sales_agent: "Értékesítési Ügynök",
|
||
lifetime_xp: "Élettapasztalat (XP)",
|
||
penalty_points: "Büntetőpontok",
|
||
social_reputation: "Társadalmi Megítélés",
|
||
created_at: "Létrehozva",
|
||
updated_at: "Frissítve",
|
||
deleted_at: "Törölve",
|
||
identity_docs: "Személyazonosító Okmányok",
|
||
ice_contact: "Vészhelyzeti Kapcsolattartó",
|
||
connected_users: "Kapcsolódó Felhasználók",
|
||
users_count: "{count} felhasználó kapcsolódik",
|
||
no_users: "Ehhez a személyhez nem kapcsolódik felhasználó.",
|
||
email: "E-mail",
|
||
role: "Szerepkör",
|
||
plan: "Csomag",
|
||
language: "Nyelv",
|
||
registered_at: "Regisztráció Dátuma",
|
||
memberships: "Tagságok",
|
||
memberships_count: "{count} tagság",
|
||
no_memberships: "Nincs tagság.",
|
||
org_name: "Szervezet Neve",
|
||
org_type: "Típus",
|
||
org_role: "Szerepkör",
|
||
member_status: "Státusz",
|
||
verified: "Ellenőrzött",
|
||
joined_at: "Csatlakozás Dátuma",
|
||
verified_yes: "Igen",
|
||
verified_no: "Nem",
|
||
owned_orgs: "Tulajdonolt Szervezetek",
|
||
owned_orgs_count: "{count} szervezet",
|
||
no_owned_orgs: "Nincs tulajdonolt szervezet.",
|
||
merge_history: "Egyesítési Előzmények",
|
||
no_merge_history: "Nincs egyesítési előzmény.",
|
||
merged_into: "Egyesítve ebbe:",
|
||
merged_at: "Egyesítés Dátuma",
|
||
edit_title: "Személy Szerkesztése",
|
||
status_section: "Státusz",
|
||
is_active: "Aktív",
|
||
is_ghost: "Szellem",
|
||
cancel: "Mégse",
|
||
saving: "Mentés...",
|
||
save: "Mentés"
|
||
}
|
||
}
|
||
};
|
||
const locale_users_46json_304d0127 = {
|
||
users: users$1
|
||
};
|
||
|
||
var gamification$1 = {
|
||
badges: {
|
||
title: "Kitüntetések",
|
||
subtitle: "Badge-ek kezelése — CRUD",
|
||
loading: "Kitüntetések betöltése...",
|
||
error: "Nem sikerült betölteni a kitüntetéseket.",
|
||
retry: "Újrapróbálkozás",
|
||
create: "Új kitüntetés",
|
||
no_items: "Még nincsenek kitüntetések.",
|
||
id: "ID",
|
||
name: "Név",
|
||
description: "Leírás",
|
||
icon: "Ikon",
|
||
actions: "Műveletek",
|
||
edit: "Szerkesztés",
|
||
"delete": "Törlés",
|
||
cancel: "Mégse",
|
||
save: "Mentés",
|
||
create_title: "Kitüntetés létrehozása",
|
||
edit_title: "Kitüntetés szerkesztése",
|
||
name_placeholder: "Kitüntetés neve",
|
||
desc_placeholder: "Kitüntetés leírása",
|
||
icon_placeholder: "Ikon URL",
|
||
icon_hint: "Opcionális. Az ikon URL-je a kitüntetéshez.",
|
||
icon_preview: "Ikon előnézet",
|
||
create_btn: "Létrehozás",
|
||
delete_title: "Kitüntetés törlése",
|
||
delete_confirm: "Biztosan törölni szeretnéd ezt a kitüntetést?",
|
||
delete_btn: "Törlés",
|
||
created: "Kitüntetés létrehozva!",
|
||
updated: "Kitüntetés frissítve!",
|
||
deleted: "Kitüntetés törölve!",
|
||
save_error: "Nem sikerült menteni a kitüntetést.",
|
||
delete_error: "Nem sikerült törölni a kitüntetést.",
|
||
unknown_error: "Ismeretlen hiba"
|
||
},
|
||
levels: {
|
||
title: "Szintek",
|
||
subtitle: "Szint konfigurációk kezelése — CRUD",
|
||
loading: "Szintek betöltése...",
|
||
error: "Nem sikerült betölteni a szint konfigurációkat.",
|
||
retry: "Újrapróbálkozás",
|
||
create: "Új szint",
|
||
no_items: "Még nincsenek szint konfigurációk.",
|
||
level: "Szint",
|
||
rank: "Rang",
|
||
min_points: "Min. Pont",
|
||
type: "Típus",
|
||
actions: "Műveletek",
|
||
penalty: "Büntető",
|
||
normal: "Normál",
|
||
tree_diagram: "Szint Fa Diagram",
|
||
no_tree_data: "Nincsenek szintek megjelenítéshez.",
|
||
points: "pont",
|
||
edit_title: "Szint szerkesztése",
|
||
create_title: "Szint létrehozása",
|
||
level_number: "Szint Száma",
|
||
rank_name: "Rang Neve",
|
||
min_points_label: "Minimum Pont",
|
||
is_penalty: "Büntető szint",
|
||
cancel: "Mégse",
|
||
save: "Mentés",
|
||
saving: "Mentés...",
|
||
updated: "Szint frissítve!",
|
||
created: "Szint létrehozva!",
|
||
duplicate_level: "Ezzel a szint számmal már létezik konfiguráció.",
|
||
save_error: "Hiba történt a mentés során."
|
||
},
|
||
point_rules: {
|
||
title: "Pontszabályok",
|
||
subtitle: "Gamification pontszabályok kezelése — CRUD",
|
||
loading: "Pontszabályok betöltése...",
|
||
error: "Nem sikerült betölteni a pontszabályokat.",
|
||
retry: "Újrapróbálkozás",
|
||
create: "Új pontszabály",
|
||
no_items: "Még nincsenek pontszabályok. Hozz létre egyet a fenti gombbal!",
|
||
id: "ID",
|
||
action_key: "Akció Kulcs",
|
||
points: "Pont",
|
||
description: "Leírás",
|
||
status: "Státusz",
|
||
actions: "Műveletek",
|
||
active: "Aktív",
|
||
inactive: "Inaktív",
|
||
edit: "Szerkesztés",
|
||
"delete": "Törlés (soft-delete)",
|
||
edit_title: "Pontszabály szerkesztése",
|
||
create_title: "Új pontszabály",
|
||
action_key_label: "Akció Kulcs",
|
||
action_key_placeholder: "pl. service_submitted",
|
||
points_label: "Pontérték",
|
||
points_placeholder: "0",
|
||
description_label: "Leírás",
|
||
description_placeholder: "Rövid leírás a szabályról...",
|
||
is_active: "Aktív",
|
||
cancel: "Mégse",
|
||
save: "Mentés",
|
||
saving: "Mentés...",
|
||
updated: "Pontszabály frissítve!",
|
||
created: "Pontszabály létrehozva!",
|
||
deleted: "Pontszabály deaktiválva!",
|
||
duplicate_key: "Egy szabály ezzel a kulccsal már létezik.",
|
||
save_error: "Nem sikerült menteni a pontszabályt.",
|
||
delete_title: "Pontszabály törlése",
|
||
delete_confirm: "Biztosan deaktiválod a következő szabályt:",
|
||
delete_btn: "Törlés",
|
||
deleting: "Törlés..."
|
||
},
|
||
seasons: {
|
||
title: "Szezonok",
|
||
subtitle: "Gamification szezonkezelés",
|
||
loading: "Szezonok betöltése...",
|
||
error: "Nem sikerült betölteni a szezonokat.",
|
||
retry: "Újra",
|
||
create: "Új Szezon",
|
||
no_items: "Még nincsenek szezonok létrehozva.",
|
||
create_first: "Első Szezon Létrehozása",
|
||
active: "Aktív",
|
||
inactive: "Inaktív",
|
||
created_at: "Létrehozva:",
|
||
activate: "Aktiválás",
|
||
edit: "Szerkesztés",
|
||
edit_title: "Szezon szerkesztése",
|
||
create_title: "Új Szezon",
|
||
name: "Név",
|
||
name_placeholder: "pl. 2026 Q1 Szezon",
|
||
start_date: "Kezdő dátum",
|
||
end_date: "Záró dátum",
|
||
activate_on_create: "Aktiválás létrehozáskor",
|
||
cancel: "Mégse",
|
||
save: "Mentés",
|
||
create_btn: "Létrehozás",
|
||
activate_title: "Szezon aktiválása",
|
||
activate_confirm: "Biztosan aktiválni szeretnéd",
|
||
activate_warning: "Ez deaktiválja az összes többi szezont.",
|
||
activating: "Aktiválás...",
|
||
activate_btn: "Aktiválás",
|
||
save_error: "Nem sikerült menteni a szezont."
|
||
},
|
||
competitions: {
|
||
title: "Versenyek",
|
||
subtitle: "Szezonális versenyek kezelése",
|
||
loading: "Versenyek betöltése...",
|
||
error: "Nem sikerült betölteni a versenyeket.",
|
||
retry: "Újrapróbálkozás",
|
||
create: "Új Verseny",
|
||
no_items: "Még nincsenek versenyek létrehozva.",
|
||
create_first: "Első Verseny Létrehozása",
|
||
season_filter: "Szezon szűrő:",
|
||
all_seasons: "Összes szezon",
|
||
active_badge: "(Aktív)",
|
||
status_active: "Aktív",
|
||
status_draft: "Draft",
|
||
status_completed: "Befejezett",
|
||
status_cancelled: "Törölt",
|
||
view_rules: "Szabályok megtekintése",
|
||
edit: "Szerkesztés",
|
||
cancel: "Mégse",
|
||
save: "Mentés",
|
||
create_title: "Verseny létrehozása",
|
||
edit_title: "Verseny szerkesztése",
|
||
name: "Név",
|
||
name_placeholder: "Pl. Q1 Szerviz Beküldő Verseny",
|
||
description: "Leírás",
|
||
desc_placeholder: "Verseny leírása...",
|
||
season: "Szezon",
|
||
select_season: "Válassz szezont",
|
||
start_date: "Kezdő dátum",
|
||
end_date: "Záró dátum",
|
||
status: "Státusz",
|
||
rules: "Szabályok (JSON)",
|
||
rules_placeholder: "type: service_submission, points_multiplier: 1.5",
|
||
invalid_json: "Érvénytelen JSON formátum!",
|
||
create_btn: "Létrehozás",
|
||
season_id_label: "Szezon ID:",
|
||
save_error: "Hiba történt a mentés során."
|
||
},
|
||
leaderboard: {
|
||
title: "Ranglista",
|
||
subtitle: "Gamification ranglista admin nézet",
|
||
search: "Keresés",
|
||
level: "Szint",
|
||
min_xp: "Minimum XP",
|
||
sort: "Rendezés",
|
||
sort_xp: "XP szerint",
|
||
sort_points: "Pontok szerint",
|
||
sort_social: "Szociális pontok szerint",
|
||
sort_level: "Szint szerint",
|
||
filter: "Szűrés",
|
||
reset: "Visszaállítás",
|
||
descending: "Csökkenő",
|
||
ascending: "Növekvő",
|
||
user: "felhasználó",
|
||
loading: "Ranglista betöltése...",
|
||
error: "Nem sikerült betölteni a ranglistát.",
|
||
retry: "Újrapróbálkozás",
|
||
no_results: "Nincs találat a megadott szűrőkkel.",
|
||
no_results_hint: "Próbálj más szűrési feltételeket használni.",
|
||
user_col: "Felhasználó",
|
||
email: "Email",
|
||
xp: "XP",
|
||
points: "Pontok",
|
||
social: "Szociális",
|
||
penalty: "Büntetés",
|
||
restriction: "Restrikció",
|
||
discoveries: "Felfedezések",
|
||
services: "Szolgáltatások",
|
||
updated: "Utolsó módosítás",
|
||
actions: "Műveletek",
|
||
details: "Részletek",
|
||
prev: "Előző",
|
||
next: "Következő",
|
||
page_of: "/ oldal",
|
||
restriction_mild: "Enyhe",
|
||
restriction_moderate: "Közepes",
|
||
restriction_severe: "Súlyos"
|
||
},
|
||
users: {
|
||
title: "Gamification Felhasználók",
|
||
subtitle: "Felhasználói gamification statisztikák kezelése",
|
||
loading: "Felhasználók betöltése...",
|
||
error: "Nem sikerült betölteni a felhasználói statisztikákat.",
|
||
retry: "Újra",
|
||
no_results: "Nincsenek megjeleníthető felhasználói statisztikák.",
|
||
level: "Szint",
|
||
all_levels: "Minden Szint",
|
||
level_n: "{n}. szint",
|
||
min_xp: "Minimum XP",
|
||
max_xp: "Maximum XP",
|
||
penalty: "Büntetés",
|
||
any: "Bármelyik",
|
||
only_penalized: "Csak büntetettek",
|
||
only_clean: "Csak tiszták",
|
||
filter: "Szűrés",
|
||
reset: "Visszaállítás",
|
||
count: "felhasználó",
|
||
user_id: "Felhasználó ID",
|
||
xp: "XP",
|
||
points: "Pontok",
|
||
restriction: "Korlátozás",
|
||
services: "Szolgáltatások",
|
||
discoveries: "Felfedezések",
|
||
updated: "Utolsó frissítés",
|
||
actions: "Műveletek",
|
||
details: "Részletek",
|
||
prev: "Előző",
|
||
next: "Következő",
|
||
none: "Nincs",
|
||
restriction_mild: "Enyhe",
|
||
restriction_moderate: "Mérsékelt",
|
||
restriction_severe: "Súlyos",
|
||
user_detail: {
|
||
back: "Vissza a listához",
|
||
title: "Felhasználó Gamification Részletei",
|
||
id_label: "ID:",
|
||
loading: "Felhasználó betöltése...",
|
||
error: "Nem sikerült betölteni a felhasználói adatokat.",
|
||
retry: "Újra",
|
||
not_found: "Felhasználó nem található.",
|
||
total_xp: "Összes XP",
|
||
level: "Szint",
|
||
total_points: "Összes Pont",
|
||
social_points: "Szociális Pontok",
|
||
penalty_points: "Büntető Pontok",
|
||
restriction_level: "Korlátozás Szintje",
|
||
penalty_quota: "Büntetési Kvóta",
|
||
banned_until: "Kitiltva eddig:",
|
||
no: "Nincs",
|
||
services: "Szolgáltatások",
|
||
discovered_places: "Felfedezett Helyek",
|
||
validated_places: "Validált Helyek",
|
||
added_providers: "Hozzáadott Szolgáltatók",
|
||
penalty_form_title: "Büntetés Kiosztása",
|
||
penalty_points_label: "Büntető Pontok",
|
||
penalty_reason_label: "Indok",
|
||
penalty_reason_placeholder: "Büntetés indoka...",
|
||
penalty_submit: "Büntetés Kiosztása",
|
||
penalty_submitting: "Küldés...",
|
||
penalty_success: "Büntetés sikeresen kiosztva: {amount} pont.",
|
||
penalty_error: "Nem sikerült kiosztani a büntetést.",
|
||
reward_form_title: "Jutalom Kiosztása",
|
||
reward_xp_label: "XP Jutalom",
|
||
reward_social_label: "Szociális Pont Jutalom",
|
||
reward_reason_label: "Indok",
|
||
reward_reason_placeholder: "Jutalom indoka...",
|
||
reward_submit: "Jutalom Kiosztása",
|
||
reward_submitting: "Küldés...",
|
||
reward_success: "Jutalom sikeresen kiosztva: {xp} XP, {social} szociális pont.",
|
||
reward_error: "Nem sikerült kiosztani a jutalmat.",
|
||
ledger_title: "Pont Napló",
|
||
ledger_count: "bejegyzés",
|
||
ledger_loading: "Betöltés...",
|
||
ledger_empty: "Még nincsenek naplóbejegyzések ehhez a felhasználóhoz.",
|
||
ledger_date: "Dátum",
|
||
ledger_points: "Pontok",
|
||
ledger_penalty: "Büntetés",
|
||
ledger_xp: "XP",
|
||
ledger_reason: "Indok",
|
||
ledger_source: "Forrás"
|
||
}
|
||
}
|
||
};
|
||
const locale_gamification_46json_15470408 = {
|
||
gamification: gamification$1
|
||
};
|
||
|
||
var system$1 = {
|
||
logs: {
|
||
subtitle: "Rendszernaplók — auditált események áttekintése",
|
||
placeholder_title: "Rendszernaplók megtekintése",
|
||
placeholder_desc: "Itt jelennek meg a rendszer által auditált események, naplóbejegyzések és rendszerszintű műveletek. A modul még fejlesztés alatt áll."
|
||
},
|
||
config: {
|
||
title: "Rendszer Konfig",
|
||
subtitle: "Gamification master konfiguráció szerkesztése",
|
||
loading: "Konfiguráció betöltése...",
|
||
error: "Nem sikerült betölteni a konfigurációt.",
|
||
last_save: "Utolsó mentés:",
|
||
saving: "Mentés...",
|
||
save: "Konfiguráció mentése",
|
||
section_xp: "XP Logika",
|
||
section_conversion: "Konverziós Logika",
|
||
section_penalty: "Büntetési Logika",
|
||
section_rewards: "Szint Jutalmak",
|
||
calculator: "Hatás Kalkulátor",
|
||
calculator_desc: "Állítsd be a paramétereket a becsült hatás megtekintéséhez",
|
||
estimated_results: "Becsült Eredmények",
|
||
daily_xp: "Napi XP",
|
||
xp_for_level: "Szintlépéshez Szükséges XP",
|
||
social_to_credit: "Social → Credit",
|
||
days_to_level: "Szintlépés Napok Száma",
|
||
raw_json: "Nyers JSON Szerkesztő",
|
||
apply_json: "JSON Alkalmazása",
|
||
updated: "Konfiguráció frissítve!",
|
||
save_error: "Hiba történt a mentés során.",
|
||
json_applied: "JSON alkalmazva a form mezőkre!",
|
||
invalid_json: "Érvénytelen JSON: ",
|
||
inactivity_monitor: "Inaktivitás Figyelő",
|
||
inactivity_desc: "Az inaktivitási küszöbérték konfigurálása automatikus fiók felfüggesztéshez. Az ennyi napja inaktív felhasználók jelölésre kerülnek az MLM Jutalék Motor által.",
|
||
inactivity_threshold: "Inaktivitási Küszöb (nap)",
|
||
inactivity_range: "Tartomány: 30–730 nap (alapértelmezett: 180)",
|
||
inactivity_updated: "Inaktivitási küszöb elmentve!",
|
||
inactivity_save_error: "Nem sikerült elmenteni az inaktivitási küszöböt.",
|
||
effective_threshold: "Hatályos Küszöb",
|
||
last_changed: "Utolsó módosítás",
|
||
never: "soha",
|
||
save_inactivity: "Mentés",
|
||
has_changes: "Változások észlelve"
|
||
},
|
||
params: {
|
||
title: "Rendszerparaméterek",
|
||
subtitle: "Gamification kategóriájú rendszerparaméterek",
|
||
loading: "Paraméterek betöltése...",
|
||
error: "Nem sikerült betölteni a rendszerparamétereket.",
|
||
retry: "Újrapróbálkozás",
|
||
no_items: "Nincsenek gamification rendszerparaméterek.",
|
||
key: "Kulcs",
|
||
value: "Érték",
|
||
category: "Kategória",
|
||
scope: "Hatósugár",
|
||
scope_id: "Scope ID",
|
||
actions: "Műveletek",
|
||
edit: "Szerkesztés",
|
||
edit_title: "Paraméter szerkesztése",
|
||
value_label: "Érték",
|
||
value_placeholder: "Paraméter értéke (JSON vagy sima szöveg)",
|
||
json_detected: "🔹 JSON formátum érzékelve",
|
||
text_value: "🔸 Szöveges érték",
|
||
cancel: "Mégse",
|
||
save: "Mentés",
|
||
saving: "Mentés...",
|
||
invalid_json: "Érvénytelen JSON formátum: ",
|
||
save_error: "Hiba történt a mentés során.",
|
||
updated: "frissítve!"
|
||
},
|
||
ledger: {
|
||
title: "Pontnapló",
|
||
subtitle: "Gamification pontnapló böngészése",
|
||
loading: "Pontnapló betöltése...",
|
||
error: "Nem sikerült betölteni a pontnaplót.",
|
||
user_id: "User ID",
|
||
date_from: "Dátumtól",
|
||
date_to: "Dátumig",
|
||
reason: "Ok",
|
||
search: "Keresés",
|
||
clear: "Törlés",
|
||
csv: "CSV",
|
||
no_results: "Nincs találat a megadott szűrőkkel.",
|
||
no_results_hint: "Próbálj más szűrési feltételeket használni.",
|
||
id: "ID",
|
||
user: "User",
|
||
points: "Pont",
|
||
penalty: "Büntetés",
|
||
xp: "XP",
|
||
source: "Forrás",
|
||
date: "Dátum",
|
||
prev: "Előző",
|
||
next: "Következő",
|
||
of: "/",
|
||
showing: "mutatva",
|
||
filtered: "(szűrve)",
|
||
no_csv_data: "Nincs adat a CSV exportáláshoz.",
|
||
csv_downloaded: "CSV letöltés elindítva."
|
||
},
|
||
permissions: {
|
||
title: "Jogosultság Kezelés",
|
||
subtitle: "Jogosultsági Mátrix — Szerepkör alapú hozzáférés-vezérlés",
|
||
loading: "Jogosultságok betöltése...",
|
||
error_title: "Nem sikerült betölteni a jogosultságokat",
|
||
retry: "Újra",
|
||
save_changes: "Változtatások Mentése",
|
||
discard: "Elvetés",
|
||
modified_count: "{count} módosítás",
|
||
domain_filter: "Tartomány Szűrő (Sorok)",
|
||
role_filter: "Szerepkör Szűrő (Oszlopok)",
|
||
select_all: "Összes kiválasztása",
|
||
deselect_all: "Összes elrejtése",
|
||
all_domains: "Minden",
|
||
permission: "Engedély",
|
||
no_permissions: "Nincsenek engedélyek ebben a tartományban.",
|
||
current_tier: "Aktuális Csomag",
|
||
expires: "Lejárat",
|
||
superadmin: "Superadmin",
|
||
superadmin_desc: "Teljes rendszer hozzáférés — felhasználók, számlázás, robotok és rendszerkonfiguráció.",
|
||
garages: "Garázsok",
|
||
garages_desc: "Garázs szintű hozzáférés — járműkezelés, szervizfoglalás, ügyféladatok.",
|
||
feature_flags: "Feature Flags",
|
||
feature_flags_desc: "Előfizetési funkciók — a jelenlegi csomagod alapján ({tier}).",
|
||
rbac_title: "RBAC Jogosultsági Mátrix",
|
||
rbac_desc: "Szerepkör alapú hozzáférés-vezérlés — mely szerepkörök mely admin műveleteket végezhetik.",
|
||
action: "Művelet"
|
||
}
|
||
};
|
||
var packages$1 = {
|
||
title: "Csomagok Kezelése",
|
||
subtitle: "Előfizetési csomagok és funkciók kezelése — Free, Premium, Enterprise",
|
||
loading: "Csomagok betöltése...",
|
||
retry: "Újra",
|
||
create_new: "Új Csomag",
|
||
no_packages: "Még nincsenek csomagok",
|
||
no_packages_desc: "Hozd létre az első előfizetési csomagot a kezdéshez.",
|
||
create_first: "Első Csomag Létrehozása",
|
||
popular: "Népszerű",
|
||
fallback_badge: "Visszaesési",
|
||
trial_badge: "Próba",
|
||
month: "hó",
|
||
feature_flags: "Elérhető Funkciók",
|
||
edit: "Szerkesztés",
|
||
duplicate: "Másolás",
|
||
"delete": "Törlés",
|
||
set_as_default: "Beállítás alapértelmezettként",
|
||
set_as_default_success: "alapértelmezett csomagként beállítva!",
|
||
edit_title: "Csomag Szerkesztése",
|
||
create_title: "Csomag Létrehozása",
|
||
cancel: "Mégse",
|
||
save: "Változtatások Mentése",
|
||
create: "Létrehozás",
|
||
save_success: "Csomag sikeresen frissítve!",
|
||
delete_title: "Csomag Törlése",
|
||
delete_confirm: "Biztosan törölni szeretnéd a \"{name}\" csomagot?",
|
||
delete_btn: "Törlés",
|
||
allowances: "Korlátok",
|
||
max_vehicles: "Max Jármű",
|
||
max_garages: "Max Garázs",
|
||
max_users: "Max Dolgozó",
|
||
monthly_credits: "Havi Kredit",
|
||
tier_level: "Szint",
|
||
form_name: "Rendszer Név",
|
||
form_name_placeholder: "pl. premium_2024",
|
||
form_display_name: "Megjelenítési Név",
|
||
form_display_name_placeholder: "pl. Premium Plus",
|
||
form_type: "Típus",
|
||
type_private: "Magán",
|
||
type_corporate: "Vállalati",
|
||
form_tier_level: "Szintszám",
|
||
form_tier_level_hint: "Magasabb szám = több funkció és magasabb rang",
|
||
form_monthly_price: "Havi Díj",
|
||
form_yearly_price: "Éves Díj",
|
||
form_currency: "Pénznem",
|
||
form_subtitle: "Felirat / Leírás",
|
||
form_subtitle_placeholder: "pl. Ideális kisvállalkozásoknak",
|
||
form_badge: "Jelvény Szöveg",
|
||
form_badge_placeholder: "pl. Legnépszerűbb",
|
||
form_is_custom: "Egyedi Csomag (nem publikus)",
|
||
singleton_rules: "Egyediségi Szabályok",
|
||
form_is_default_fallback: "Alapértelmezett Visszaesési Csomag — lejárt előfizetés esetén erre vált",
|
||
form_trial_days: "Próba Napok Regisztrációnál",
|
||
form_trial_days_hint: "Az új szervezetek ennyi ingyenes napot kapnak. Csak egy csomagnál lehet > 0.",
|
||
per_region_pricing: "Régiók szerinti árazás",
|
||
smart_calculator: "Okos Árkalkulátor",
|
||
calc_net_price: "Nettó ár",
|
||
calc_vat_rate: "ÁFA kulcs",
|
||
calc_currency: "Pénznem",
|
||
calc_net: "Nettó",
|
||
calc_vat: "ÁFA",
|
||
calc_gross: "Bruttó",
|
||
calc_apply: "Alkalmaz a kiválasztott régióra",
|
||
add_zone: "Új Zóna Hozzáadása",
|
||
add_zone_select: "Válassz országkódot...",
|
||
add_zone_already_exists: "Ez a régió már létezik a csomag árazásában!",
|
||
feature_capabilities: "Funkció Képességek (JSON)",
|
||
feature_capabilities_hint: "JSON formátumban add meg a funkció képességeket. Pl.: ai_analysis: true, priority_support: false",
|
||
singleton_rules_title: "Egyediségi Szabályok",
|
||
form_trial_days_label: "Próba Napok",
|
||
per_region_pricing_title: "Régiók szerinti árazás",
|
||
smart_calculator_title: "Okos Árkalkulátor"
|
||
};
|
||
const locale_system_46json_21da1de8 = {
|
||
system: system$1,
|
||
packages: packages$1
|
||
};
|
||
|
||
var commission_rules$1 = {
|
||
title: "Jutalék Szabályok",
|
||
subtitle: "Fix jutalmak és százalékos jutalékok kezelése a partnerrendszerben",
|
||
create: "Új szabály",
|
||
create_title: "Jutalék Szabály Létrehozása",
|
||
edit_title: "Jutalék Szabály Szerkesztése",
|
||
created: "Jutalék szabály sikeresen létrehozva",
|
||
deactivated: "Jutalék szabály sikeresen deaktiválva",
|
||
no_items: "Nincsenek jutalék szabályok",
|
||
all_types: "Minden típus",
|
||
all_tiers: "Minden szint",
|
||
filter_region: "Régió",
|
||
active_only: "Csak aktív",
|
||
campaign_only: "Csak kampány",
|
||
tier: "Szint",
|
||
region: "Régió",
|
||
region_code: "Régiókód",
|
||
campaign_dates: "Kampány / Dátumok",
|
||
campaign: "Kampány",
|
||
permanent: "Állandó",
|
||
l1_reward: "Fix Összegű Jutalom (Mikrotranzakció)",
|
||
l2_commission: "Százalékos Jutalék (Vásárlás után)",
|
||
is_campaign: "Ez egy kampány szabály",
|
||
rewards_section: "Fix Jutalmak (XP / Kredit)",
|
||
xp_reward: "XP Jutalom",
|
||
credit_reward: "Credit Jutalom",
|
||
commission_section: "Százalékos Jutalékok",
|
||
commission_percent: "Jutalék % (Gen1)",
|
||
upline_commission_percent: "Felső szintű Jutalék % (Gen2)",
|
||
upline_commission_percent_helper: "A felső szintű ajánlónak (Gen2 — az ajánló ajánlója) járó jutalék százaléka minden vásárlás után.",
|
||
renewal_commission_percent: "Megújítási Jutalék %",
|
||
renewal_commission_percent_helper: "A havi/éves előfizetés megújításakor járó jutalék százaléka.",
|
||
commission_max_amount: "Max Összeg (általános)",
|
||
gen1_max_amount: "Gen1 Max Összeg",
|
||
gen1_max_amount_helper: "Gen1 (közvetlen ajánló) maximális jutalék összege. NULL/0 = korlátlan, fallback: Max Összeg.",
|
||
gen2_max_amount: "Gen2 Max Összeg",
|
||
gen2_max_amount_helper: "Gen2 (felső szintű ajánló) maximális jutalék összege. NULL/0 = korlátlan, fallback: Max Összeg.",
|
||
gen1_title: "Közvetlen Ajánló (Gen1)",
|
||
gen2_title: "Felsővonal (Gen2)",
|
||
legacy_fallback: "örökölt mező",
|
||
gen2_renewal_percent: "Gen2 Megújítási Jutalék %",
|
||
gen2_renewal_percent_helper: "Gen2-nek járó megújítási jutalék százaléka (pl. 1.00 = 1%). Fallback: Felső szintű Jutalék %.",
|
||
deactivate_confirm: "Biztosan deaktiválod a következőt: \"{name}\"?",
|
||
showing: "Mutatva",
|
||
xp_reward_helper: "Egyéni meghívások után járó fix jutalom (pl. sikeres regisztráció).",
|
||
credit_reward_helper: "Egyéni meghívások után járó fix jutalom (pl. sikeres regisztráció).",
|
||
commission_percent_helper: "A meghívott cég előfizetési díjából számított százalékos jutalék.",
|
||
commission_max_amount_helper: "A kifizethető maximális jutalék összege ezen a szabályon belül.",
|
||
region_code_label: "Régiókód",
|
||
region_global: "Globális",
|
||
region_hu: "Magyarország",
|
||
region_de: "Németország",
|
||
region_at: "Ausztria",
|
||
region_ro: "Románia",
|
||
region_sk: "Szlovákia",
|
||
id: "Azonosító",
|
||
name: "Név",
|
||
type: "Típus",
|
||
status: "Státusz",
|
||
actions: "Műveletek",
|
||
active: "Aktív",
|
||
inactive: "Inaktív",
|
||
edit: "Szerkesztés",
|
||
deactivate: "Deaktiválás",
|
||
prev: "Előző",
|
||
next: "Következő",
|
||
loading: "Betöltés...",
|
||
error: "Hiba történt",
|
||
retry: "Újra",
|
||
save: "Mentés",
|
||
saving: "Mentés...",
|
||
cancel: "Mégsem",
|
||
name_placeholder: "Add meg a nevet",
|
||
description: "Leírás",
|
||
desc_placeholder: "Add meg a leírást",
|
||
start_date: "Kezdő Dátum",
|
||
end_date: "Befejező Dátum",
|
||
delete_title: "Törlés Megerősítése",
|
||
updated: "Sikeresen frissítve",
|
||
save_error: "Sikertelen mentés",
|
||
tier_standard: "Standard",
|
||
tier_vip: "VIP",
|
||
tier_platinum: "Platinum",
|
||
tier_enterprise: "Enterprise",
|
||
tier_contracted: "Szerződött Üzletkötő",
|
||
conflict_title: "Szabályütközés észlelve",
|
||
conflict_message: "Már létezik egy aktív szabály erre a célcsoportra és régióra. Szeretnéd inaktiválni a régit, és életbe léptetni az újat?",
|
||
conflict_confirm: "Felülírás jóváhagyása",
|
||
conflict_cancel: "Mégsem"
|
||
};
|
||
const locale_commission_46json_2229a18b = {
|
||
commission_rules: commission_rules$1
|
||
};
|
||
|
||
var financial_ledger$1 = {
|
||
title: "Pénzügyi Napló",
|
||
subtitle: "A teljes pénzügyi főkönyv böngészése — tranzakciók, felhasználók és részletek",
|
||
loading: "Napló betöltése...",
|
||
error: "Nem sikerült betölteni a pénzügyi naplót.",
|
||
retry: "Újrapróbálkozás",
|
||
no_results: "Nincsenek pénzügyi napló bejegyzések.",
|
||
no_results_hint: "Próbálj más szűrési feltételeket használni.",
|
||
id: "ID",
|
||
user: "Felhasználó",
|
||
user_id: "User ID",
|
||
amount: "Összeg",
|
||
currency: "Pénznem",
|
||
transaction_type: "Tranzakció Típus",
|
||
entry_type: "Típus",
|
||
wallet_type: "Tárca",
|
||
status: "Státusz",
|
||
created_at: "Dátum",
|
||
details: "Részletek",
|
||
filter: "Szűrés",
|
||
clear: "Törlés",
|
||
prev: "Előző",
|
||
next: "Következő",
|
||
page_info: "{page} / {total} oldal ({count} elem)",
|
||
export_csv: "CSV Export",
|
||
all_types: "Minden típus",
|
||
all_wallets: "Minden tárca",
|
||
all_statuses: "Minden státusz",
|
||
date_from: "Dátumtól",
|
||
date_to: "Dátumig",
|
||
search: "Keresés",
|
||
csv_downloaded: "CSV letöltés elindítva."
|
||
};
|
||
var enums$1 = {
|
||
entry_type: {
|
||
credit: "Jóváírás",
|
||
debit: "Terhelés",
|
||
CREDIT: "Jóváírás",
|
||
DEBIT: "Terhelés"
|
||
},
|
||
wallet_type: {
|
||
earned: "Megszerzett",
|
||
purchased: "Vásárolt",
|
||
service_coins: "Szolgáltatási Coin",
|
||
voucher: "Utalvány",
|
||
EARNED: "Megszerzett",
|
||
PURCHASED: "Vásárolt",
|
||
SERVICE_COINS: "Szolgáltatási Coin",
|
||
VOUCHER: "Utalvány"
|
||
},
|
||
status: {
|
||
pending: "Függőben",
|
||
completed: "Teljesítve",
|
||
success: "Sikeres",
|
||
failed: "Sikertelen",
|
||
cancelled: "Visszavonva",
|
||
refunded: "Visszatérítve",
|
||
refund: "Visszatérítés"
|
||
},
|
||
transaction_type: {
|
||
subscription: "Előfizetés",
|
||
commission: "Jutalék",
|
||
refund: "Visszatérítés",
|
||
manual_adjustment: "Kézi Korrekció",
|
||
purchase: "Vásárlás",
|
||
withdrawal: "Kivét",
|
||
bonus: "Bónusz",
|
||
fee: "Díj",
|
||
reward: "Jutalom"
|
||
}
|
||
};
|
||
const locale_finance_46json_ae59f62d = {
|
||
financial_ledger: financial_ledger$1,
|
||
enums: enums$1
|
||
};
|
||
|
||
var common$5 = {
|
||
loading: "Loading...",
|
||
saving: "Saving...",
|
||
error: "An error occurred",
|
||
retry: "Retry",
|
||
save: "Save",
|
||
saving_data: "Saving data...",
|
||
cancel: "Cancel",
|
||
discard: "Discard",
|
||
"delete": "Delete",
|
||
delete_confirm: "Are you sure you want to delete this item?",
|
||
delete_btn: "Delete",
|
||
delete_title: "Confirm Deletion",
|
||
deleted: "Deleted successfully",
|
||
edit: "Edit",
|
||
edit_title: "Edit Item",
|
||
create: "Create",
|
||
create_btn: "Create",
|
||
create_title: "Create New",
|
||
create_first: "Create your first item to get started",
|
||
search: "Search",
|
||
search_placeholder: "Search...",
|
||
filter: "Filter",
|
||
no_results: "No results found",
|
||
no_results_hint: "Try adjusting your search or filter criteria",
|
||
no_items: "No items available",
|
||
actions: "Actions",
|
||
status: "Status",
|
||
active: "Active",
|
||
inactive: "Inactive",
|
||
activate: "Activate",
|
||
deactivate: "Deactivate",
|
||
name: "Name",
|
||
name_placeholder: "Enter name",
|
||
description: "Description",
|
||
desc_placeholder: "Enter description",
|
||
details: "Details",
|
||
email: "Email",
|
||
id: "ID",
|
||
type: "Type",
|
||
type_corporate: "Corporate",
|
||
view: "View",
|
||
updated: "Updated successfully",
|
||
save_error: "Failed to save",
|
||
invalid_json: "Invalid JSON format",
|
||
prev: "Previous",
|
||
next: "Next",
|
||
none: "None",
|
||
reset: "Reset",
|
||
confirm: "Confirm",
|
||
close: "Close",
|
||
back: "Back",
|
||
"continue": "Continue",
|
||
exit: "Exit",
|
||
all: "All",
|
||
select_all: "Select All",
|
||
deselect_all: "Deselect All",
|
||
expires: "Expires",
|
||
created: "Created",
|
||
start_date: "Start Date",
|
||
end_date: "End Date",
|
||
points: "Points",
|
||
level: "Level",
|
||
user: "User",
|
||
user_id: "User ID",
|
||
services: "Services",
|
||
discoveries: "Discoveries",
|
||
restriction: "Restriction",
|
||
restriction_mild: "Mild",
|
||
restriction_moderate: "Moderate",
|
||
restriction_severe: "Severe",
|
||
min_xp: "Min XP",
|
||
xp: "XP",
|
||
penalty: "Penalty",
|
||
feature_flags: "Feature Flags",
|
||
permission: "Permission",
|
||
role: "Role",
|
||
domain: "Domain",
|
||
action: "Action",
|
||
value: "Value",
|
||
key: "Key",
|
||
enabled: "Enabled",
|
||
disabled: "Disabled",
|
||
yes: "Yes",
|
||
no: "No",
|
||
on: "On",
|
||
off: "Off",
|
||
service_finder: "Service Finder",
|
||
admin: "Admin",
|
||
version: "Version",
|
||
super_administrator: "Super Administrator",
|
||
administrator: "Administrator",
|
||
profile_settings: "Profile Settings",
|
||
sign_out: "Sign Out",
|
||
unknown_user: "Unknown user",
|
||
ascending: "Ascending",
|
||
descending: "Descending"
|
||
};
|
||
const locale_common_46json_364cfaa7 = {
|
||
common: common$5
|
||
};
|
||
|
||
var menu = {
|
||
center: "Center",
|
||
dashboard: "Dashboard",
|
||
providers: "Providers",
|
||
providers_title: "Providers",
|
||
all_providers: "All Providers",
|
||
pending_providers: "Pending Approval",
|
||
users_and_partners: "Users & Partners",
|
||
garages: "Garages",
|
||
garage_list: "Garage List",
|
||
users: "Users",
|
||
user_list: "User List",
|
||
persons: "Persons",
|
||
finance: "Finance",
|
||
finance_management: "Finance Management",
|
||
packages: "Packages",
|
||
commission_rules: "Commission Rules",
|
||
financial_ledger: "Financial Ledger",
|
||
gamification: "Gamification",
|
||
game_settings: "Game Settings",
|
||
point_rules: "Point Rules",
|
||
levels: "Levels",
|
||
badges: "Badges",
|
||
validation_rules: "Validation Rules",
|
||
events_and_seasons: "Events & Seasons",
|
||
seasons: "Seasons",
|
||
competitions: "Competitions",
|
||
user_data: "User Data",
|
||
statistics: "Statistics",
|
||
leaderboard: "Leaderboard",
|
||
points_ledger: "Points Ledger",
|
||
ledger: "Points Ledger",
|
||
gamification_hq: "Gamification HQ",
|
||
system_config: "System Config",
|
||
system_parameters: "System Parameters",
|
||
system: "System",
|
||
permissions: "Permissions",
|
||
system_logs: "System Logs"
|
||
};
|
||
const locale_menu_46json_75789531 = {
|
||
menu: menu
|
||
};
|
||
|
||
var dashboard = {
|
||
title: "Gamification HQ",
|
||
subtitle: "Gamification system overview dashboard",
|
||
loading: "Loading dashboard...",
|
||
error: "Failed to load dashboard data.",
|
||
total_users: "Total Users",
|
||
active_season: "Active Season",
|
||
pending_contributions: "Pending Contributions",
|
||
xp_earned_today: "XP Earned Today",
|
||
none: "None",
|
||
quick_actions: "Quick Actions",
|
||
manage_point_rules: "Manage Point Rules",
|
||
manage_badges: "Manage Badges",
|
||
manage_seasons: "Manage Seasons",
|
||
recent_ledger: "Recent Ledger Entries",
|
||
no_ledger: "No ledger entries yet.",
|
||
top_5: "Top 5 Leaderboard",
|
||
full_leaderboard: "Full Leaderboard →",
|
||
no_leaderboard: "No leaderboard data yet.",
|
||
level: "Level",
|
||
xp: "XP",
|
||
points: "points"
|
||
};
|
||
const locale_dashboard_46json_d9580386 = {
|
||
dashboard: dashboard
|
||
};
|
||
|
||
var providers = {
|
||
title: "Providers",
|
||
subtitle: "Provider listing, search and moderation",
|
||
loading: "Loading providers...",
|
||
error: "An error occurred while loading providers.",
|
||
retry: "Retry",
|
||
stats_total: "Total",
|
||
stats_pending: "Pending",
|
||
stats_approved: "Approved",
|
||
stats_rejected: "Rejected",
|
||
stats_flagged: "Flagged",
|
||
search_placeholder: "Search by name...",
|
||
filter_all_status: "All statuses",
|
||
filter_pending: "Pending",
|
||
filter_approved: "Approved",
|
||
filter_rejected: "Rejected",
|
||
filter_flagged: "Flagged",
|
||
filter_all_sources: "All sources",
|
||
source_manual: "Manual",
|
||
source_ocr: "OCR",
|
||
source_import: "Import",
|
||
source_bot: "Bot (Staging)",
|
||
source_verified_org: "Organization",
|
||
sort_created_at: "Created at",
|
||
sort_name: "Name",
|
||
sort_validation_score: "Validation score",
|
||
col_id: "ID",
|
||
col_name: "Name",
|
||
col_address: "Address",
|
||
col_status: "Status",
|
||
col_source: "Source",
|
||
col_validation: "Validation",
|
||
col_created: "Created",
|
||
col_actions: "Actions",
|
||
no_providers: "No providers to display.",
|
||
results_count: "{count} results (total: {total})",
|
||
page: "Page {page}",
|
||
view_details: "Details",
|
||
status_pending: "Pending",
|
||
status_approved: "Approved",
|
||
status_rejected: "Rejected",
|
||
status_flagged: "Flagged",
|
||
provider_detail: "Provider Details",
|
||
detail_loading: "Loading provider...",
|
||
detail_not_found: "Provider not found.",
|
||
detail_back: "Back to providers",
|
||
detail_provider_number: "Provider #{id}",
|
||
detail_raw_data: "Raw Data",
|
||
detail_tab_data: "Data",
|
||
detail_tab_status: "Status",
|
||
detail_tab_validations: "Validations",
|
||
detail_tab_crawler: "Crawler / Raw Data",
|
||
detail_tab_history: "History",
|
||
detail_section_basic: "Basic Information",
|
||
detail_section_address: "Address Information",
|
||
detail_section_contact: "Contact Information",
|
||
detail_section_services: "Services",
|
||
detail_section_vehicle_classes: "Vehicle Classes",
|
||
detail_section_specializations: "Specializations",
|
||
detail_section_opening_hours: "Opening Hours",
|
||
detail_section_evidence: "Evidence Image",
|
||
detail_section_moderation: "Moderation Actions",
|
||
detail_section_status_management: "Status Management",
|
||
detail_section_validation_score: "Validation Score",
|
||
detail_section_gamification_validations: "Gamification Validations",
|
||
detail_section_crawler_data: "Crawler / Raw Data",
|
||
detail_section_history: "Status Change History",
|
||
detail_field_name: "Name",
|
||
detail_field_category: "Category",
|
||
detail_field_source: "Source",
|
||
detail_field_validation_score: "Validation Score",
|
||
detail_field_created: "Created",
|
||
detail_field_submitted_by: "Submitted by User ID",
|
||
detail_field_full_address: "Full Address",
|
||
detail_field_city: "City",
|
||
detail_field_zip: "ZIP Code",
|
||
detail_field_street: "Street",
|
||
detail_field_house_number: "House Number",
|
||
detail_field_plus_code: "Plus Code",
|
||
detail_field_phone: "Phone",
|
||
detail_field_email: "Email",
|
||
detail_field_website: "Website",
|
||
detail_no_categories: "No categories set",
|
||
detail_no_vehicle_classes: "No vehicle classes set",
|
||
detail_no_specializations: "No specializations set",
|
||
detail_no_opening_hours: "No opening hours set",
|
||
detail_day_monday: "Monday",
|
||
detail_day_tuesday: "Tuesday",
|
||
detail_day_wednesday: "Wednesday",
|
||
detail_day_thursday: "Thursday",
|
||
detail_day_friday: "Friday",
|
||
detail_day_saturday: "Saturday",
|
||
detail_day_sunday: "Sunday",
|
||
detail_day_label: "Day",
|
||
detail_hours_label: "Hours",
|
||
detail_closed: "Closed",
|
||
detail_specialization_brands: "Brands",
|
||
detail_specialization_propulsion: "Propulsion",
|
||
detail_status_approved: "Approved",
|
||
detail_status_pending: "Pending",
|
||
detail_status_research: "Research in progress",
|
||
detail_status_rejected: "Rejected",
|
||
detail_status_unknown: "Unknown",
|
||
detail_status_desc_approved: "The provider is active and visible to users.",
|
||
detail_status_desc_pending: "The provider has not been approved yet, awaiting moderation.",
|
||
detail_status_desc_research: "Provider data is still being processed, automated research in progress.",
|
||
detail_status_desc_rejected: "The provider has been rejected and is not visible to users.",
|
||
detail_edit: "Edit",
|
||
detail_approve: "Approve",
|
||
detail_reject: "Reject",
|
||
detail_flag: "Flag",
|
||
detail_delete: "Delete (Soft Delete)",
|
||
detail_restore: "Restore",
|
||
detail_status_rejected_or_flagged: "The provider has been {status}.",
|
||
detail_status_rejected_text: "rejected",
|
||
detail_status_flagged_text: "flagged",
|
||
detail_status_form_label: "Status",
|
||
detail_status_form_score: "Validation Score (0-100)",
|
||
detail_status_form_reason: "Reason (optional)",
|
||
detail_status_form_reason_placeholder: "Enter the reason for status change...",
|
||
detail_status_form_cancel: "Cancel",
|
||
detail_status_form_save: "Save Status",
|
||
detail_validation_score_excellent: "Excellent",
|
||
detail_validation_score_medium: "Medium",
|
||
detail_validation_score_weak: "Weak",
|
||
detail_validation_score_desc: "Provider reliability score based on gamification validations.",
|
||
detail_validation_no_entries: "No validation entries for this provider.",
|
||
detail_validation_voter: "Voter:",
|
||
detail_validation_reason: "Reason:",
|
||
detail_validation_weight: "weight:",
|
||
detail_crawler_source: "Source:",
|
||
detail_crawler_trust_score: "Trust Score:",
|
||
detail_crawler_rejection_reason_title: "Rejection Reason",
|
||
detail_crawler_raw_data: "Raw Data",
|
||
detail_crawler_audit_trail: "Audit Trail",
|
||
detail_history_no_entries: "No history entries for this provider.",
|
||
detail_history_user: "User #{id}",
|
||
detail_history_status: "Status:",
|
||
detail_history_reason: "Reason:",
|
||
detail_history_detailed_changes: "Detailed Changes",
|
||
detail_history_old_data: "Old Data",
|
||
detail_flag_modal_title: "Flag Provider",
|
||
detail_flag_modal_body: "Are you sure you want to flag {name}?",
|
||
detail_flag_reason_label: "Reason (optional)",
|
||
detail_flag_reason_placeholder: "Enter the reason for flagging...",
|
||
detail_flag_submit: "Flag",
|
||
detail_toast_approved: "Provider approved!",
|
||
detail_toast_rejected: "Provider rejected!",
|
||
detail_toast_restored: "Provider restored!",
|
||
detail_toast_flagged: "Provider flagged!",
|
||
detail_toast_deleted: "Provider deleted!",
|
||
detail_toast_status_updated: "Status updated!",
|
||
detail_toast_error_approve: "Error approving provider",
|
||
detail_toast_error_reject: "Error rejecting provider",
|
||
detail_toast_error_restore: "Error restoring provider",
|
||
detail_toast_error_flag: "Error flagging provider",
|
||
detail_toast_error_delete: "Error deleting provider",
|
||
detail_toast_error_status: "Error saving status",
|
||
detail_delete_confirm: "Are you sure you want to delete this provider? This action cannot be undone.",
|
||
detail_vehicle_class_car: "Car",
|
||
detail_vehicle_class_motorcycle: "Motorcycle",
|
||
detail_vehicle_class_truck: "Truck",
|
||
detail_vehicle_class_hgv: "Heavy Goods Vehicle (HGV)",
|
||
detail_vehicle_class_light_commercial: "Light Commercial Vehicle",
|
||
detail_vehicle_class_personal: "Personal",
|
||
detail_vehicle_class_boat: "Boat/Watercraft",
|
||
detail_vehicle_class_other: "Other",
|
||
detail_validation_type_phone_verified: "Phone Verified",
|
||
detail_validation_type_email_verified: "Email Verified",
|
||
detail_validation_type_address_verified: "Address Verified",
|
||
detail_validation_type_website_verified: "Website Verified",
|
||
detail_validation_type_manual_review: "Manual Review",
|
||
detail_validation_type_community_vouch: "Community Vouch",
|
||
detail_validation_type_business_hours: "Business Hours Verified",
|
||
detail_validation_type_photo_evidence: "Photo Evidence",
|
||
detail_history_action_approve: "Approved",
|
||
detail_history_action_reject: "Rejected",
|
||
detail_history_action_restore: "Restored",
|
||
detail_history_action_flag: "Flagged",
|
||
detail_history_action_update: "Updated",
|
||
detail_history_action_delete: "Deleted",
|
||
detail_history_action_create: "Created",
|
||
pending_title: "Providers Pending Approval",
|
||
pending_subtitle: "Community-submitted providers awaiting moderation",
|
||
pending_loading: "Loading pending providers...",
|
||
rejected_title: "Rejected Providers",
|
||
rejected_subtitle: "Restore rejected providers to active searchable providers",
|
||
rejected_loading: "Loading rejected providers...",
|
||
approve: "Approve",
|
||
reject: "Reject",
|
||
restore: "Restore",
|
||
details: "Details",
|
||
reject_modal_title: "Reject Provider",
|
||
reject_modal_body: "Are you sure you want to reject {name}?",
|
||
reject_reason_label: "Reason (optional)",
|
||
reject_reason_placeholder: "Enter the reason for rejection...",
|
||
restore_modal_title: "Restore Provider",
|
||
restore_modal_body: "Are you sure you want to restore {name}? After restoration, the provider will be available in search and listings again.",
|
||
restore_reason_label: "Reason (optional)",
|
||
restore_reason_placeholder: "Enter the reason for restoration...",
|
||
no_pending: "No pending providers",
|
||
no_pending_subtitle: "All submitted providers have been processed.",
|
||
no_rejected: "No rejected providers",
|
||
no_rejected_subtitle: "All providers are in approved status.",
|
||
approved_toast: "\"{name}\" approved successfully",
|
||
rejected_toast: "\"{name}\" rejected",
|
||
restored_toast: "\"{name}\" restored successfully",
|
||
error_prefix: "Error: {detail}",
|
||
unknown_error: "Unknown error",
|
||
label_address: "Address:",
|
||
label_city: "City:",
|
||
label_category: "Category:",
|
||
label_validation_score: "Validation Score:",
|
||
label_submitted: "Submitted:",
|
||
label_created: "Created:",
|
||
edit_title: "Edit Provider",
|
||
edit_loading: "Loading provider...",
|
||
edit_error: "An error occurred while loading the provider.",
|
||
edit_not_found: "Provider not found.",
|
||
edit_back: "Back to provider",
|
||
edit_raw_data: "Raw Data",
|
||
edit_tab_basic: "Basic & Contact",
|
||
edit_tab_matrix: "Services & Vehicles",
|
||
edit_tab_location: "Location",
|
||
edit_tab_hours: "Opening Hours",
|
||
edit_section_basic: "Basic Information",
|
||
edit_section_contact: "Contact Information",
|
||
edit_section_matrix: "3D Capability Matrix",
|
||
edit_section_matrix_desc: "Configure which vehicle classes, service categories and specializations the provider belongs to.",
|
||
edit_section_vehicle_classes: "Vehicle Classes",
|
||
edit_section_vehicle_classes_desc: "Which vehicle types does the provider service?",
|
||
edit_section_expertise_tags: "Service Categories (Expertise Tags)",
|
||
edit_section_expertise_tags_desc: "Select the categories for the provider from the hierarchical tree.",
|
||
edit_section_specializations: "Specializations",
|
||
edit_section_specializations_desc: "Add special brands, propulsion types or other tags.",
|
||
edit_section_location_extra: "Additional Location Data",
|
||
edit_section_opening_hours: "Opening Hours",
|
||
edit_section_opening_hours_desc: "Set the provider's opening hours broken down by day.",
|
||
edit_field_name: "Name *",
|
||
edit_field_category: "Category",
|
||
edit_field_category_placeholder: "e.g. Auto Repair, Tire Service",
|
||
edit_field_source: "Source",
|
||
edit_field_phone: "Phone",
|
||
edit_field_phone_placeholder: "+36 30 123 4567",
|
||
edit_field_email: "Email",
|
||
edit_field_email_placeholder: "info{'@'}example.com",
|
||
edit_field_website: "Website",
|
||
edit_field_website_placeholder: "https://...",
|
||
edit_field_full_address: "Full Address",
|
||
edit_field_full_address_placeholder: "Full address text",
|
||
edit_field_plus_code: "Plus Code",
|
||
edit_field_plus_code_placeholder: "8FVC9X8V+XV",
|
||
edit_field_brands: "Brands",
|
||
edit_field_brands_placeholder: "e.g. Volvo, Scania",
|
||
edit_field_propulsion: "Propulsion",
|
||
edit_field_propulsion_placeholder: "e.g. EV, Hybrid, Diesel",
|
||
edit_field_add: "Add",
|
||
edit_always_open: "24/7 opening hours",
|
||
edit_always_open_desc: "The provider is open 24 hours every day of the week",
|
||
edit_btn_24_7: "24/7 Continuous Hours",
|
||
edit_btn_copy_weekdays: "Copy Weekdays (Mon → Fri)",
|
||
edit_btn_clear_all: "Clear All",
|
||
edit_closed: "Closed",
|
||
edit_has_changes: "● Unsaved changes",
|
||
edit_no_changes: "No changes",
|
||
edit_cancel: "Cancel",
|
||
edit_save: "Save",
|
||
edit_toast_saved: "Provider updated successfully!",
|
||
edit_toast_promoted: "Promoted successfully!",
|
||
edit_toast_error: "Error saving: {message}",
|
||
edit_copy_weekdays_open_prompt: "Enter opening time (e.g. 08:00):",
|
||
edit_copy_weekdays_close_prompt: "Enter closing time (e.g. 17:00):",
|
||
edit_categories_loading: "Loading categories...",
|
||
edit_level_label: "(Level {level})",
|
||
edit_source_label: "Source:",
|
||
edit_trust_score_label: "Trust Score:",
|
||
edit_raw_data_title: "Raw Data",
|
||
edit_audit_trail_title: "Audit Trail",
|
||
edit_rejection_reason_title: "Rejection Reason"
|
||
};
|
||
const locale_providers_46json_03440ec5 = {
|
||
providers: providers
|
||
};
|
||
|
||
var garages = {
|
||
title: "Garages CRM",
|
||
subtitle: "Garage list, package management and status changes",
|
||
total_garages: "Total Garages",
|
||
private_garages: "Private Garages",
|
||
corporate_garages: "Corporate Garages",
|
||
search_placeholder: "Search by name, contact or email...",
|
||
all_tiers: "All packages",
|
||
all_types: "All types",
|
||
type_individual: "Private (Individual)",
|
||
type_corporate: "Corporate",
|
||
company_name: "Company Name",
|
||
email: "Email",
|
||
status: "Status",
|
||
current_package: "Current Package",
|
||
expiration_date: "Expiration Date",
|
||
actions: "Actions",
|
||
active: "Active",
|
||
inactive: "Inactive",
|
||
suspended: "Suspended",
|
||
change_package: "Change Package",
|
||
manage_subscription: "Manage Subscription",
|
||
view: "View",
|
||
activate: "Activate",
|
||
deactivate: "Deactivate",
|
||
no_results: "No garages match your search.",
|
||
loading: "Loading garages...",
|
||
retry: "Retry",
|
||
members: "members",
|
||
free_fallback: "Free / Fallback",
|
||
expires: "Expires",
|
||
select_package: "Select Package",
|
||
select_package_placeholder: "Select a subscription package...",
|
||
custom_expiration: "Custom Expiration Date",
|
||
optional: "optional",
|
||
custom_expiration_hint: "Leave empty for default duration (e.g. 30 days). For 2-5 year B2B deals, set a custom date!",
|
||
cancel: "Cancel",
|
||
save: "Save",
|
||
saving: "Saving...",
|
||
subscription_updated: "subscription updated successfully!",
|
||
view_details: "Details",
|
||
indefinite: "Indefinite",
|
||
addons_title: "Add-ons",
|
||
addon_vehicles: "Extra Vehicle",
|
||
addon_branches: "Extra Branch",
|
||
addon_users: "Extra Employee",
|
||
active_addons: "Active Add-ons",
|
||
no_active_addons: "No active add-ons",
|
||
addon_vehicles_expiration: "Extra Vehicle Expiration",
|
||
addon_branches_expiration: "Extra Branch Expiration",
|
||
addon_users_expiration: "Extra Employee Expiration",
|
||
addon_expiration_hint: "If empty, existing expiration dates remain.",
|
||
details: {
|
||
loading: "Loading garage details...",
|
||
retry: "Retry",
|
||
back: "Back to garages",
|
||
company_info: "Company Info",
|
||
company_name: "Company Name",
|
||
display_name: "Display Name",
|
||
org_type: "Organization Type",
|
||
tax_number: "Tax Number",
|
||
reg_number: "Registration Number",
|
||
created_at: "Created At",
|
||
address: "Address",
|
||
subscription_info: "Subscription Status",
|
||
tier_name: "Package",
|
||
tier_level: "Level",
|
||
level_n: "Level {n}",
|
||
expires_at: "Expires",
|
||
asset_limit: "Vehicle Limit",
|
||
vehicles: "vehicles",
|
||
no_subscription: "No active subscription",
|
||
contact_info: "Contact Info",
|
||
contact_name: "Contact Name",
|
||
contact_role: "Role",
|
||
contact_department: "Department",
|
||
contact_phone: "Contact Phone",
|
||
no_contact: "No primary contact person",
|
||
edit_details: "Edit Details",
|
||
save: "Save",
|
||
generalTab: "General",
|
||
employeesTab: "Employees",
|
||
fleetTab: "Fleet",
|
||
analyticsTab: "Analytics",
|
||
subscriptionTab: "Subscription",
|
||
editBasicTab: "Basic Info",
|
||
editContactTab: "Contact",
|
||
editAddressTab: "Addresses",
|
||
zip: "ZIP Code",
|
||
city: "City",
|
||
street_name: "Street",
|
||
street_type: "Street Type",
|
||
house_number: "House Number",
|
||
coming_soon: "This feature will be available soon...",
|
||
missing_data_title: "Missing Data",
|
||
missing_data_desc: "The garage profile is incomplete. Please fill in the missing fields.",
|
||
missing_data_activation_required: "To activate the garage, the following data must be provided:",
|
||
missing_tax_number: "Tax Number",
|
||
missing_billing: "Billing Address",
|
||
missing_contact_email: "Contact Email",
|
||
missing_contact_phone: "Contact Phone",
|
||
missing_data_count: "{count} fields missing",
|
||
contact_person_name: "Contact Person Name",
|
||
contact_email: "Contact Email",
|
||
billing_address: "Billing Address",
|
||
billing_zip: "ZIP Code",
|
||
billing_city: "City",
|
||
billing_street_name: "Street",
|
||
billing_street_type: "Street Type",
|
||
billing_house_number: "House Number",
|
||
notification_address: "Notification Address",
|
||
notification_zip: "ZIP Code",
|
||
notification_city: "City",
|
||
notification_street_name: "Street",
|
||
notification_street_type: "Street Type",
|
||
notification_house_number: "House Number",
|
||
tab_basic: "Basic Info",
|
||
tab_contact: "Contact",
|
||
tab_addresses: "Addresses",
|
||
basic_info: "Basic Info",
|
||
contact_section: "Contact Person",
|
||
addresses_section: "Addresses",
|
||
vehicles_used: "Vehicles",
|
||
branches_used: "Branches",
|
||
employees_used: "Employees",
|
||
branches: "branches",
|
||
employees: "employees",
|
||
status: "Status",
|
||
subscription_history: "Subscription History",
|
||
history_date: "Date",
|
||
history_package: "Package",
|
||
history_action: "Action",
|
||
history_status: "Status",
|
||
no_subscription_history: "No subscription history yet."
|
||
},
|
||
employees: {
|
||
title: "Employees",
|
||
total_count: "{count} employees",
|
||
name: "Name",
|
||
email_phone: "Email / Phone",
|
||
role: "Role",
|
||
status: "Status",
|
||
actions: "Actions",
|
||
edit_role: "Edit",
|
||
remove: "Remove",
|
||
no_employees: "No employees assigned to this garage.",
|
||
edit_role_title: "Edit Employee Role",
|
||
editRoleTitle: "Edit Employee Role",
|
||
editRoleFor: "Change role for {name}",
|
||
cancel: "Cancel",
|
||
save: "Save Changes",
|
||
saveRole: "Save Role",
|
||
saving: "Saving...",
|
||
status_active: "Active",
|
||
status_inactive: "Inactive",
|
||
remove_title: "Remove Employee",
|
||
removeTitle: "Remove Employee",
|
||
remove_confirm: "Are you sure you want to remove \"{name}\" from this garage?",
|
||
removeConfirm: "Are you sure you want to remove \"{name}\" from this garage?",
|
||
remove_btn: "Remove",
|
||
removing: "Removing...",
|
||
add_employee: "Add Employee",
|
||
addTitle: "Add New Employee",
|
||
email: "Email Address",
|
||
emailPlaceholder: "Enter email address...",
|
||
roleMember: "Member",
|
||
roleManager: "Manager",
|
||
roleAdmin: "Admin",
|
||
roleOwner: "Owner",
|
||
add: "Add Employee",
|
||
adding: "Adding..."
|
||
},
|
||
fleet: {
|
||
title: "Fleet",
|
||
total_vehicles: "{count} vehicles total",
|
||
plate: "Plate",
|
||
brand: "Brand",
|
||
model: "Model",
|
||
brand_model: "Brand & Model",
|
||
year: "Year",
|
||
status: "Status",
|
||
vin: "VIN",
|
||
no_vehicles: "No vehicles assigned to this garage yet.",
|
||
no_fleet_access: "You don't have permission to view fleet data."
|
||
},
|
||
analytics: {
|
||
ltv: "Lifetime Value (LTV)",
|
||
mrr: "Monthly Revenue (MRR)",
|
||
monthly_recurring: "Monthly recurring revenue",
|
||
outstanding: "Outstanding",
|
||
all_settled: "All invoices settled",
|
||
earned_credits: "Earned Credits",
|
||
contribution_xp: "XP earned from platform contributions",
|
||
invited_companies: "Invited Companies",
|
||
companies_joined: "Companies joined via your invite",
|
||
validated_garages: "Validated Garages",
|
||
garages_confirmed: "Garages successfully verified",
|
||
utilization: "Utilization",
|
||
vehicle_quota: "Vehicle Quota",
|
||
employee_quota: "Employee Quota",
|
||
utilized: "utilized",
|
||
marketplace_engagement: "Marketplace & Engagement",
|
||
avg_rating: "Average Rating",
|
||
reviews: "Reviews",
|
||
reviews_count: "reviews",
|
||
last_activity: "Last Activity",
|
||
last_login_mock: "2 hours ago",
|
||
services_30d: "Services Completed (30 days)"
|
||
}
|
||
};
|
||
const locale_garages_46json_57a15a2c = {
|
||
garages: garages
|
||
};
|
||
|
||
var users = {
|
||
title: "User Management",
|
||
subtitle: "User list, search, filters and bulk actions",
|
||
loading: "Loading users...",
|
||
retry: "Retry",
|
||
search_placeholder: "Search by email, name or phone...",
|
||
all_statuses: "All statuses",
|
||
status_active: "Active",
|
||
status_inactive: "Inactive",
|
||
status_deleted: "Deleted",
|
||
status_banned: "Banned",
|
||
all_roles: "All roles",
|
||
role_user: "User",
|
||
role_admin: "Admin",
|
||
role_staff: "Staff",
|
||
role_superadmin: "Superadmin",
|
||
all_plans: "All plans",
|
||
plan_free: "Free",
|
||
plan_premium: "Premium",
|
||
plan_enterprise: "Enterprise",
|
||
total_users: "Total Users",
|
||
active_users: "Active Users",
|
||
deleted_users: "Deleted Users",
|
||
banned_users: "Banned Users",
|
||
new_today: "New Today",
|
||
filtered_results: "Filtered results",
|
||
selected_count: "{count} user(s) selected",
|
||
bulk_activate: "Activate",
|
||
bulk_deactivate: "Deactivate",
|
||
clear_selection: "Clear",
|
||
email: "Email",
|
||
name: "Name",
|
||
role: "Role",
|
||
status: "Status",
|
||
"package": "Package",
|
||
registration: "Registration",
|
||
language: "Language",
|
||
actions: "Actions",
|
||
view: "View",
|
||
activate: "Activate",
|
||
deactivate: "Deactivate",
|
||
no_results: "No users match your search.",
|
||
showing: "Showing",
|
||
prev: "Previous",
|
||
next: "Next",
|
||
details: {
|
||
loading: "Loading user details...",
|
||
retry: "Retry",
|
||
back: "Back to Users",
|
||
edit: "Edit User",
|
||
edit_user: "Edit User",
|
||
profile_tab: "Profile",
|
||
memberships_tab: "Memberships",
|
||
account_info: "Account Information",
|
||
user_id: "User ID",
|
||
registration_date: "Registration Date",
|
||
last_login: "Last Login",
|
||
ui_mode: "UI Mode",
|
||
region: "Region",
|
||
currency: "Currency",
|
||
subscription_info: "Subscription Information",
|
||
subscription_expires: "Expires At",
|
||
scope_level: "Scope Level",
|
||
scope_id: "Scope ID",
|
||
max_vehicles: "Max Vehicles",
|
||
max_garages: "Max Garages",
|
||
personal_info: "Personal Information",
|
||
last_name: "Last Name",
|
||
first_name: "First Name",
|
||
phone: "Phone",
|
||
birth_place: "Birth Place",
|
||
birth_date: "Birth Date",
|
||
mothers_name: "Mother's Name",
|
||
mothers_first_name: "Mother's First Name",
|
||
address: "Address",
|
||
zip: "ZIP Code",
|
||
city: "City",
|
||
street: "Street",
|
||
house_number: "House Number",
|
||
no_person_record: "No personal information record found for this user.",
|
||
memberships: "Organization Memberships",
|
||
memberships_count: "{count} membership(s)",
|
||
no_memberships: "This user is not a member of any organization.",
|
||
org_name: "Organization",
|
||
org_role: "Role",
|
||
member_status: "Status",
|
||
joined_at: "Joined",
|
||
verified: "Verified",
|
||
verified_yes: "Yes",
|
||
verified_no: "No",
|
||
preferred_language: "Preferred Language",
|
||
is_active: "Active",
|
||
is_vip: "VIP",
|
||
cancel: "Cancel",
|
||
save: "Save Changes",
|
||
saving: "Saving...",
|
||
danger_zone: "Danger Zone",
|
||
danger_zone_warning: "This action is irreversible. Once you delete this user, all their data will be permanently removed.",
|
||
danger_zone_button: "Delete User Permanently",
|
||
danger_zone_confirm_label: "Type the user's email to confirm:",
|
||
danger_zone_confirm_placeholder: "Enter email address...",
|
||
danger_zone_confirm_button: "I understand, permanently delete this user",
|
||
danger_zone_cancel: "Cancel",
|
||
danger_zone_success: "User has been permanently deleted.",
|
||
danger_zone_error_financial: "Cannot delete: User has financial or production records.",
|
||
danger_zone_error_not_superadmin: "Only Superadmins can perform hard delete operations.",
|
||
danger_zone_error_generic: "Failed to delete user: {message}"
|
||
},
|
||
persons: {
|
||
title: "Person Management",
|
||
subtitle: "Person list, search, filters and details",
|
||
loading: "Loading persons...",
|
||
retry: "Retry",
|
||
search_placeholder: "Search by name, phone or email...",
|
||
all_ghost_statuses: "All ghost statuses",
|
||
ghost_no: "Not ghost",
|
||
ghost_yes: "Ghost",
|
||
all_active_statuses: "All active statuses",
|
||
active_yes: "Active",
|
||
active_no: "Inactive",
|
||
all_user_statuses: "All user statuses",
|
||
has_user_yes: "Has user",
|
||
has_user_no: "No user",
|
||
all_merged_statuses: "All merged statuses",
|
||
merged_no: "Not merged",
|
||
merged_yes: "Merged",
|
||
total_persons: "Total Persons",
|
||
active_persons: "Active Persons",
|
||
ghost_persons: "Ghost Persons",
|
||
merged_persons: "Merged Persons",
|
||
filtered_results: "Filtered results",
|
||
name: "Name",
|
||
phone: "Phone",
|
||
birth_date: "Birth Date",
|
||
status: "Status",
|
||
users_count: "Users",
|
||
active_user: "Active User",
|
||
address: "Address",
|
||
actions: "Actions",
|
||
active: "Active",
|
||
inactive: "Inactive",
|
||
ghost: "Ghost",
|
||
merged: "Merged",
|
||
view: "View",
|
||
no_results: "No persons match your search.",
|
||
showing: "Showing",
|
||
prev: "Previous",
|
||
next: "Next",
|
||
details: {
|
||
loading: "Loading person details...",
|
||
retry: "Retry",
|
||
back: "Back to list",
|
||
sales_agent: "Sales Agent",
|
||
edit: "Edit",
|
||
personal_info: "Personal Information",
|
||
person_id: "Person ID",
|
||
uuid: "UUID",
|
||
last_name: "Last Name",
|
||
first_name: "First Name",
|
||
birth_place: "Place of Birth",
|
||
mothers_name: "Mother's Name",
|
||
mothers_last_name: "Mother's Last Name",
|
||
mothers_first_name: "Mother's First Name",
|
||
address: "Address",
|
||
zip: "ZIP Code",
|
||
city: "City",
|
||
street: "Street",
|
||
house_number: "House Number",
|
||
stairwell: "Stairwell",
|
||
floor: "Floor",
|
||
door: "Door",
|
||
parcel_id: "Parcel ID (HRSZ)",
|
||
full_address: "Full Address",
|
||
system_info: "System Information",
|
||
is_sales_agent: "Sales Agent",
|
||
lifetime_xp: "Lifetime XP",
|
||
penalty_points: "Penalty Points",
|
||
social_reputation: "Social Reputation",
|
||
created_at: "Created At",
|
||
updated_at: "Updated At",
|
||
deleted_at: "Deleted At",
|
||
identity_docs: "Identity Documents",
|
||
ice_contact: "ICE Contact",
|
||
connected_users: "Connected Users",
|
||
users_count: "{count} user(s) connected",
|
||
no_users: "No users connected to this person.",
|
||
email: "Email",
|
||
role: "Role",
|
||
plan: "Plan",
|
||
language: "Language",
|
||
registered_at: "Registered At",
|
||
memberships: "Memberships",
|
||
memberships_count: "{count} membership(s)",
|
||
no_memberships: "No memberships.",
|
||
org_name: "Organization Name",
|
||
org_type: "Type",
|
||
org_role: "Role",
|
||
member_status: "Status",
|
||
verified: "Verified",
|
||
joined_at: "Joined At",
|
||
verified_yes: "Yes",
|
||
verified_no: "No",
|
||
owned_orgs: "Owned Organizations",
|
||
owned_orgs_count: "{count} organization(s)",
|
||
no_owned_orgs: "No owned organizations.",
|
||
merge_history: "Merge History",
|
||
no_merge_history: "No merge history.",
|
||
merged_into: "Merged into",
|
||
merged_at: "Merged At",
|
||
edit_title: "Edit Person",
|
||
status_section: "Status",
|
||
is_active: "Active",
|
||
is_ghost: "Ghost",
|
||
cancel: "Cancel",
|
||
saving: "Saving...",
|
||
save: "Save"
|
||
}
|
||
}
|
||
};
|
||
const locale_users_46json_4a4a26a3 = {
|
||
users: users
|
||
};
|
||
|
||
var gamification = {
|
||
badges: {
|
||
title: "Badges",
|
||
subtitle: "Badge Management — CRUD",
|
||
loading: "Loading badges...",
|
||
error: "Failed to load badges.",
|
||
retry: "Retry",
|
||
create: "New Badge",
|
||
no_items: "No badges yet.",
|
||
id: "ID",
|
||
name: "Name",
|
||
description: "Description",
|
||
icon: "Icon",
|
||
actions: "Actions",
|
||
edit: "Edit",
|
||
"delete": "Delete",
|
||
cancel: "Cancel",
|
||
save: "Save",
|
||
create_title: "Create Badge",
|
||
edit_title: "Edit Badge",
|
||
name_placeholder: "Badge name",
|
||
desc_placeholder: "Badge description",
|
||
icon_placeholder: "Icon URL",
|
||
icon_hint: "Optional. The icon URL for the badge.",
|
||
icon_preview: "Icon preview",
|
||
create_btn: "Create",
|
||
delete_title: "Delete Badge",
|
||
delete_confirm: "Are you sure you want to delete this badge?",
|
||
delete_btn: "Delete",
|
||
created: "Badge created!",
|
||
updated: "Badge updated!",
|
||
deleted: "Badge deleted!",
|
||
save_error: "Failed to save badge.",
|
||
delete_error: "Failed to delete badge.",
|
||
unknown_error: "Unknown error"
|
||
},
|
||
levels: {
|
||
title: "Levels",
|
||
subtitle: "Level configuration management — CRUD",
|
||
loading: "Loading levels...",
|
||
error: "Failed to load level configurations.",
|
||
retry: "Retry",
|
||
create: "New Level",
|
||
no_items: "No level configurations yet.",
|
||
level: "Level",
|
||
rank: "Rank",
|
||
min_points: "Min Points",
|
||
type: "Type",
|
||
actions: "Actions",
|
||
penalty: "Penalty",
|
||
normal: "Normal",
|
||
tree_diagram: "Level Tree Diagram",
|
||
no_tree_data: "No levels to display.",
|
||
points: "points",
|
||
edit_title: "Edit Level",
|
||
create_title: "Create Level",
|
||
level_number: "Level Number",
|
||
rank_name: "Rank Name",
|
||
min_points_label: "Minimum Points",
|
||
is_penalty: "Penalty Level",
|
||
cancel: "Cancel",
|
||
save: "Save",
|
||
saving: "Saving...",
|
||
updated: "Level updated!",
|
||
created: "Level created!",
|
||
duplicate_level: "A configuration with this level number already exists.",
|
||
save_error: "Failed to save level."
|
||
},
|
||
point_rules: {
|
||
title: "Point Rules",
|
||
subtitle: "Gamification point rules management — CRUD",
|
||
loading: "Loading point rules...",
|
||
error: "Failed to load point rules.",
|
||
retry: "Retry",
|
||
create: "New Point Rule",
|
||
no_items: "No point rules yet. Create one with the button above!",
|
||
id: "ID",
|
||
action_key: "Action Key",
|
||
points: "Points",
|
||
description: "Description",
|
||
status: "Status",
|
||
actions: "Actions",
|
||
active: "Active",
|
||
inactive: "Inactive",
|
||
edit: "Edit",
|
||
"delete": "Delete (soft-delete)",
|
||
edit_title: "Edit Point Rule",
|
||
create_title: "New Point Rule",
|
||
action_key_label: "Action Key",
|
||
action_key_placeholder: "e.g. service_submitted",
|
||
points_label: "Point Value",
|
||
points_placeholder: "0",
|
||
description_label: "Description",
|
||
description_placeholder: "Short description of the rule...",
|
||
is_active: "Active",
|
||
cancel: "Cancel",
|
||
save: "Save",
|
||
saving: "Saving...",
|
||
updated: "Point rule updated!",
|
||
created: "Point rule created!",
|
||
deleted: "Point rule deactivated!",
|
||
duplicate_key: "A rule with this action key already exists.",
|
||
save_error: "Failed to save point rule.",
|
||
delete_title: "Delete Point Rule",
|
||
delete_confirm: "Are you sure you want to deactivate the rule",
|
||
delete_btn: "Delete",
|
||
deleting: "Deleting..."
|
||
},
|
||
seasons: {
|
||
title: "Seasons",
|
||
subtitle: "Gamification season management",
|
||
loading: "Loading seasons...",
|
||
error: "Failed to load seasons.",
|
||
retry: "Retry",
|
||
create: "New Season",
|
||
no_items: "No seasons created yet.",
|
||
create_first: "Create First Season",
|
||
active: "Active",
|
||
inactive: "Inactive",
|
||
created_at: "Created:",
|
||
activate: "Activate",
|
||
edit: "Edit",
|
||
edit_title: "Edit Season",
|
||
create_title: "New Season",
|
||
name: "Name",
|
||
name_placeholder: "e.g. 2026 Q1 Season",
|
||
start_date: "Start Date",
|
||
end_date: "End Date",
|
||
activate_on_create: "Activate on creation",
|
||
cancel: "Cancel",
|
||
save: "Save",
|
||
create_btn: "Create",
|
||
activate_title: "Activate Season",
|
||
activate_confirm: "Are you sure you want to activate",
|
||
activate_warning: "This will deactivate all other seasons.",
|
||
activating: "Activating...",
|
||
activate_btn: "Activate",
|
||
save_error: "Failed to save season."
|
||
},
|
||
competitions: {
|
||
title: "Competitions",
|
||
subtitle: "Seasonal competition management",
|
||
loading: "Loading competitions...",
|
||
error: "Failed to load competitions.",
|
||
retry: "Retry",
|
||
create: "New Competition",
|
||
no_items: "No competitions created yet.",
|
||
create_first: "Create First Competition",
|
||
season_filter: "Season Filter:",
|
||
all_seasons: "All Seasons",
|
||
active_badge: "(Active)",
|
||
status_active: "Active",
|
||
status_draft: "Draft",
|
||
status_completed: "Completed",
|
||
status_cancelled: "Cancelled",
|
||
view_rules: "View Rules",
|
||
edit: "Edit",
|
||
cancel: "Cancel",
|
||
save: "Save",
|
||
create_title: "Create Competition",
|
||
edit_title: "Edit Competition",
|
||
name: "Name",
|
||
name_placeholder: "e.g. Q1 Service Submission Contest",
|
||
description: "Description",
|
||
desc_placeholder: "Competition description...",
|
||
season: "Season",
|
||
select_season: "Select a season",
|
||
start_date: "Start Date",
|
||
end_date: "End Date",
|
||
status: "Status",
|
||
rules: "Rules (JSON)",
|
||
rules_placeholder: "type: service_submission, points_multiplier: 1.5",
|
||
invalid_json: "Invalid JSON format!",
|
||
create_btn: "Create",
|
||
season_id_label: "Season ID:",
|
||
save_error: "Failed to save competition."
|
||
},
|
||
leaderboard: {
|
||
title: "Leaderboard",
|
||
subtitle: "Gamification leaderboard admin view",
|
||
search: "Search",
|
||
level: "Level",
|
||
min_xp: "Min XP",
|
||
sort: "Sort",
|
||
sort_xp: "By XP",
|
||
sort_points: "By Points",
|
||
sort_social: "By Social Points",
|
||
sort_level: "By Level",
|
||
filter: "Filter",
|
||
reset: "Reset",
|
||
descending: "Descending",
|
||
ascending: "Ascending",
|
||
user: "user",
|
||
loading: "Loading leaderboard...",
|
||
error: "Failed to load leaderboard.",
|
||
retry: "Retry",
|
||
no_results: "No results match your filters.",
|
||
no_results_hint: "Try different filter criteria.",
|
||
user_col: "User",
|
||
email: "Email",
|
||
xp: "XP",
|
||
points: "Points",
|
||
social: "Social",
|
||
penalty: "Penalty",
|
||
restriction: "Restriction",
|
||
discoveries: "Discoveries",
|
||
services: "Services",
|
||
updated: "Last Updated",
|
||
actions: "Actions",
|
||
details: "Details",
|
||
prev: "Previous",
|
||
next: "Next",
|
||
page_of: "/ page",
|
||
restriction_mild: "Mild",
|
||
restriction_moderate: "Moderate",
|
||
restriction_severe: "Severe"
|
||
},
|
||
users: {
|
||
title: "Gamification Users",
|
||
subtitle: "User gamification statistics management",
|
||
loading: "Loading users...",
|
||
error: "Failed to load user statistics.",
|
||
retry: "Retry",
|
||
no_results: "No user statistics to display.",
|
||
level: "Level",
|
||
all_levels: "All Levels",
|
||
level_n: "Level {n}",
|
||
min_xp: "Minimum XP",
|
||
max_xp: "Maximum XP",
|
||
penalty: "Penalty",
|
||
any: "Any",
|
||
only_penalized: "Only penalized",
|
||
only_clean: "Only clean",
|
||
filter: "Filter",
|
||
reset: "Reset",
|
||
count: "users",
|
||
user_id: "User ID",
|
||
xp: "XP",
|
||
points: "Points",
|
||
restriction: "Restriction",
|
||
services: "Services",
|
||
discoveries: "Discoveries",
|
||
updated: "Last Updated",
|
||
actions: "Actions",
|
||
details: "Details",
|
||
prev: "Previous",
|
||
next: "Next",
|
||
none: "None",
|
||
restriction_mild: "Mild",
|
||
restriction_moderate: "Moderate",
|
||
restriction_severe: "Severe",
|
||
user_detail: {
|
||
back: "Back to list",
|
||
title: "User Gamification Details",
|
||
id_label: "ID:",
|
||
loading: "Loading user...",
|
||
error: "Failed to load user data.",
|
||
retry: "Retry",
|
||
not_found: "User not found.",
|
||
total_xp: "Total XP",
|
||
level: "Level",
|
||
total_points: "Total Points",
|
||
social_points: "Social Points",
|
||
penalty_points: "Penalty Points",
|
||
restriction_level: "Restriction Level",
|
||
penalty_quota: "Penalty Quota",
|
||
banned_until: "Banned Until",
|
||
no: "No",
|
||
services: "Services",
|
||
discovered_places: "Discovered Places",
|
||
validated_places: "Validated Places",
|
||
added_providers: "Added Providers",
|
||
penalty_form_title: "Assign Penalty",
|
||
penalty_points_label: "Penalty Points",
|
||
penalty_reason_label: "Reason",
|
||
penalty_reason_placeholder: "Reason for penalty...",
|
||
penalty_submit: "Assign Penalty",
|
||
penalty_submitting: "Submitting...",
|
||
penalty_success: "Penalty successfully assigned: {amount} points.",
|
||
penalty_error: "Failed to assign penalty.",
|
||
reward_form_title: "Assign Reward",
|
||
reward_xp_label: "XP Reward",
|
||
reward_social_label: "Social Points Reward",
|
||
reward_reason_label: "Reason",
|
||
reward_reason_placeholder: "Reason for reward...",
|
||
reward_submit: "Assign Reward",
|
||
reward_submitting: "Submitting...",
|
||
reward_success: "Reward successfully assigned: {xp} XP, {social} social points.",
|
||
reward_error: "Failed to assign reward.",
|
||
ledger_title: "Points Ledger",
|
||
ledger_count: "entries",
|
||
ledger_loading: "Loading...",
|
||
ledger_empty: "No ledger entries for this user yet.",
|
||
ledger_date: "Date",
|
||
ledger_points: "Points",
|
||
ledger_penalty: "Penalty",
|
||
ledger_xp: "XP",
|
||
ledger_reason: "Reason",
|
||
ledger_source: "Source"
|
||
}
|
||
}
|
||
};
|
||
const locale_gamification_46json_111ebf57 = {
|
||
gamification: gamification
|
||
};
|
||
|
||
var system = {
|
||
logs: {
|
||
subtitle: "System Logs — audited event overview",
|
||
placeholder_title: "System Logs Viewer",
|
||
placeholder_desc: "This section will display audited system events, log entries, and system-wide operations. Module is under development."
|
||
},
|
||
config: {
|
||
title: "System Config",
|
||
subtitle: "Gamification master configuration editor",
|
||
loading: "Loading configuration...",
|
||
error: "Failed to load configuration.",
|
||
last_save: "Last saved:",
|
||
saving: "Saving...",
|
||
save: "Save Configuration",
|
||
section_xp: "XP Logic",
|
||
section_conversion: "Conversion Logic",
|
||
section_penalty: "Penalty Logic",
|
||
section_rewards: "Level Rewards",
|
||
calculator: "Impact Calculator",
|
||
calculator_desc: "Adjust parameters to see estimated impact",
|
||
estimated_results: "Estimated Results",
|
||
daily_xp: "Daily XP",
|
||
xp_for_level: "XP Needed for Level Up",
|
||
social_to_credit: "Social → Credit",
|
||
days_to_level: "Days to Level Up",
|
||
raw_json: "Raw JSON Editor",
|
||
apply_json: "Apply JSON",
|
||
updated: "Configuration updated!",
|
||
save_error: "Failed to save configuration.",
|
||
json_applied: "JSON applied to form fields!",
|
||
invalid_json: "Invalid JSON: ",
|
||
inactivity_monitor: "Inactivity Monitor",
|
||
inactivity_desc: "Configure the inactivity threshold for automatic account suspension. Users inactive for this many days will be flagged by the MLM Commission Engine.",
|
||
inactivity_threshold: "Inactivity Threshold (days)",
|
||
inactivity_range: "Range: 30–730 days (default: 180)",
|
||
inactivity_updated: "Inactivity threshold saved!",
|
||
inactivity_save_error: "Failed to save inactivity threshold.",
|
||
effective_threshold: "Effective Threshold",
|
||
last_changed: "Last changed",
|
||
never: "never",
|
||
save_inactivity: "Save",
|
||
has_changes: "Changes detected"
|
||
},
|
||
params: {
|
||
title: "System Parameters",
|
||
subtitle: "Gamification category system parameters",
|
||
loading: "Loading parameters...",
|
||
error: "Failed to load system parameters.",
|
||
retry: "Retry",
|
||
no_items: "No gamification system parameters.",
|
||
key: "Key",
|
||
value: "Value",
|
||
category: "Category",
|
||
scope: "Scope",
|
||
scope_id: "Scope ID",
|
||
actions: "Actions",
|
||
edit: "Edit",
|
||
edit_title: "Edit Parameter",
|
||
value_label: "Value",
|
||
value_placeholder: "Parameter value (JSON or plain text)",
|
||
json_detected: "🔹 JSON format detected",
|
||
text_value: "🔸 Text value",
|
||
cancel: "Cancel",
|
||
save: "Save",
|
||
saving: "Saving...",
|
||
invalid_json: "Invalid JSON format: ",
|
||
save_error: "Failed to save parameter.",
|
||
updated: "updated!"
|
||
},
|
||
ledger: {
|
||
title: "Points Ledger",
|
||
subtitle: "Gamification points ledger browser",
|
||
loading: "Loading ledger...",
|
||
error: "Failed to load ledger.",
|
||
user_id: "User ID",
|
||
date_from: "Date From",
|
||
date_to: "Date To",
|
||
reason: "Reason",
|
||
search: "Search",
|
||
clear: "Clear",
|
||
csv: "CSV",
|
||
no_results: "No results match your filters.",
|
||
no_results_hint: "Try different filter criteria.",
|
||
id: "ID",
|
||
user: "User",
|
||
points: "Points",
|
||
penalty: "Penalty",
|
||
xp: "XP",
|
||
source: "Source",
|
||
date: "Date",
|
||
prev: "Previous",
|
||
next: "Next",
|
||
of: "of",
|
||
showing: "showing",
|
||
filtered: "(filtered)",
|
||
no_csv_data: "No data for CSV export.",
|
||
csv_downloaded: "CSV download started."
|
||
},
|
||
permissions: {
|
||
title: "Permissions Management",
|
||
subtitle: "Permission Matrix — Role-based access control",
|
||
loading: "Loading permissions...",
|
||
error_title: "Failed to load permissions",
|
||
retry: "Retry",
|
||
save_changes: "Save Changes",
|
||
discard: "Discard",
|
||
modified_count: "{count} changes",
|
||
domain_filter: "Domain Filter (Rows)",
|
||
role_filter: "Role Filter (Columns)",
|
||
select_all: "Select All",
|
||
deselect_all: "Deselect All",
|
||
all_domains: "All",
|
||
permission: "Permission",
|
||
no_permissions: "No permissions in this domain.",
|
||
current_tier: "Current Package",
|
||
expires: "Expires",
|
||
superadmin: "Superadmin",
|
||
superadmin_desc: "Full system access — users, billing, robots and system configuration.",
|
||
garages: "Garages",
|
||
garages_desc: "Garage-level access — vehicle management, service booking, customer data.",
|
||
feature_flags: "Feature Flags",
|
||
feature_flags_desc: "Subscription features — based on your current plan ({tier}).",
|
||
rbac_title: "RBAC Permission Matrix",
|
||
rbac_desc: "Role-based access control — which roles can perform which admin actions.",
|
||
action: "Action"
|
||
}
|
||
};
|
||
var packages = {
|
||
title: "Package Management",
|
||
subtitle: "Manage subscription packages and features — Free, Premium, Enterprise",
|
||
loading: "Loading packages...",
|
||
retry: "Retry",
|
||
create_new: "New Package",
|
||
no_packages: "No packages yet",
|
||
no_packages_desc: "Create your first subscription package to get started.",
|
||
create_first: "Create First Package",
|
||
popular: "Popular",
|
||
fallback_badge: "Fallback",
|
||
trial_badge: "Trial",
|
||
month: "mo",
|
||
feature_flags: "Available Features",
|
||
edit: "Edit",
|
||
duplicate: "Duplicate",
|
||
"delete": "Delete",
|
||
set_as_default: "Set as Default",
|
||
set_as_default_success: "set as default package!",
|
||
edit_title: "Edit Package",
|
||
create_title: "Create Package",
|
||
cancel: "Cancel",
|
||
save: "Save Changes",
|
||
create: "Create",
|
||
save_success: "Package updated successfully!",
|
||
delete_title: "Delete Package",
|
||
delete_confirm: "Are you sure you want to delete \"{name}\"?",
|
||
delete_btn: "Delete",
|
||
allowances: "Allowances",
|
||
max_vehicles: "Max Vehicles",
|
||
max_garages: "Max Garages",
|
||
max_users: "Max Users",
|
||
monthly_credits: "Monthly Credits",
|
||
tier_level: "Level",
|
||
form_name: "System Name",
|
||
form_name_placeholder: "e.g. premium_2024",
|
||
form_display_name: "Display Name",
|
||
form_display_name_placeholder: "e.g. Premium Plus",
|
||
form_type: "Type",
|
||
type_private: "Private",
|
||
type_corporate: "Corporate",
|
||
form_tier_level: "Tier Level",
|
||
form_tier_level_hint: "Higher number = more features and higher rank",
|
||
form_monthly_price: "Monthly Price",
|
||
form_yearly_price: "Yearly Price",
|
||
form_currency: "Currency",
|
||
form_subtitle: "Subtitle / Description",
|
||
form_subtitle_placeholder: "e.g. Ideal for small businesses",
|
||
form_badge: "Badge Text",
|
||
form_badge_placeholder: "e.g. Most Popular",
|
||
form_is_custom: "Custom Package (not public)",
|
||
singleton_rules: "Singleton Rules",
|
||
form_is_default_fallback: "Default Fallback Package — expired subscriptions fall back to this",
|
||
form_trial_days: "Trial Days on Signup",
|
||
form_trial_days_hint: "New organizations get this many free days. Only one package can have > 0.",
|
||
per_region_pricing: "Per-Region Pricing",
|
||
smart_calculator: "Smart Price Calculator",
|
||
calc_net_price: "Net Price",
|
||
calc_vat_rate: "VAT Rate",
|
||
calc_currency: "Currency",
|
||
calc_net: "Net",
|
||
calc_vat: "VAT",
|
||
calc_gross: "Gross",
|
||
calc_apply: "Apply to selected region",
|
||
add_zone: "Add New Zone",
|
||
add_zone_select: "Select country code...",
|
||
add_zone_already_exists: "This region already exists in the package pricing!",
|
||
feature_capabilities: "Feature Capabilities (JSON)",
|
||
feature_capabilities_hint: "Enter feature capabilities in JSON format. E.g.: ai_analysis: true, priority_support: false",
|
||
singleton_rules_title: "Singleton Rules",
|
||
form_trial_days_label: "Trial Days",
|
||
per_region_pricing_title: "Per-Region Pricing",
|
||
smart_calculator_title: "Smart Price Calculator"
|
||
};
|
||
const locale_system_46json_cff5800c = {
|
||
system: system,
|
||
packages: packages
|
||
};
|
||
|
||
var commission_rules = {
|
||
title: "Commission Rules",
|
||
subtitle: "Manage fixed rewards and percentage commissions for the referral system",
|
||
create: "New Rule",
|
||
create_title: "Create Commission Rule",
|
||
edit_title: "Edit Commission Rule",
|
||
created: "Commission rule created successfully",
|
||
deactivated: "Commission rule deactivated successfully",
|
||
no_items: "No commission rules found",
|
||
all_types: "All Types",
|
||
all_tiers: "All Tiers",
|
||
filter_region: "Region",
|
||
active_only: "Active only",
|
||
campaign_only: "Campaign only",
|
||
tier: "Tier",
|
||
region: "Region",
|
||
region_code: "Region Code",
|
||
campaign_dates: "Campaign / Dates",
|
||
campaign: "Campaign",
|
||
permanent: "Permanent",
|
||
l1_reward: "Fixed Amount Reward (Microtransaction)",
|
||
l2_commission: "Percentage Commission (Post-Purchase)",
|
||
is_campaign: "This is a campaign rule",
|
||
rewards_section: "Fixed Rewards (XP / Credit)",
|
||
xp_reward: "XP Reward",
|
||
credit_reward: "Credit Reward",
|
||
commission_section: "Percentage Commissions",
|
||
commission_percent: "Commission % (Gen1)",
|
||
upline_commission_percent: "Upline Commission % (Gen2)",
|
||
upline_commission_percent_helper: "Percentage paid to the upline (Gen2 — the referrer's referrer) on each purchase.",
|
||
renewal_commission_percent: "Renewal Commission %",
|
||
renewal_commission_percent_helper: "Percentage paid on monthly/yearly subscription renewals.",
|
||
commission_max_amount: "Max Amount (global)",
|
||
gen1_max_amount: "Gen1 Max Amount",
|
||
gen1_max_amount_helper: "Gen1 (direct referrer) maximum commission amount. NULL/0 = unlimited, fallback: Max Amount.",
|
||
gen2_max_amount: "Gen2 Max Amount",
|
||
gen2_max_amount_helper: "Gen2 (upline) maximum commission amount. NULL/0 = unlimited, fallback: Max Amount.",
|
||
gen1_title: "Direct Referrer (Gen1)",
|
||
gen2_title: "Upline (Gen2)",
|
||
legacy_fallback: "legacy fallback",
|
||
gen2_renewal_percent: "Gen2 Renewal %",
|
||
gen2_renewal_percent_helper: "Gen2 renewal commission percentage (e.g. 1.00 = 1%). Fallback: Upline Commission %.",
|
||
deactivate_confirm: "Are you sure you want to deactivate \"{name}\"?",
|
||
showing: "Showing",
|
||
xp_reward_helper: "Fixed reward given to the user for successful individual referrals (e.g., successful registration via invite code).",
|
||
credit_reward_helper: "Fixed reward given to the user for successful individual referrals (e.g., successful registration via invite code).",
|
||
commission_percent_helper: "Percentage calculated from the invited company's subscription fee.",
|
||
commission_max_amount_helper: "Maximum payable limit for this specific commission rule.",
|
||
region_code_label: "Region Code",
|
||
region_global: "Global",
|
||
region_hu: "Hungary",
|
||
region_de: "Germany",
|
||
region_at: "Austria",
|
||
region_ro: "Romania",
|
||
region_sk: "Slovakia",
|
||
id: "ID",
|
||
name: "Name",
|
||
type: "Type",
|
||
status: "Status",
|
||
actions: "Actions",
|
||
active: "Active",
|
||
inactive: "Inactive",
|
||
edit: "Edit",
|
||
deactivate: "Deactivate",
|
||
prev: "Previous",
|
||
next: "Next",
|
||
loading: "Loading...",
|
||
error: "An error occurred",
|
||
retry: "Retry",
|
||
save: "Save",
|
||
saving: "Saving...",
|
||
cancel: "Cancel",
|
||
name_placeholder: "Enter name",
|
||
description: "Description",
|
||
desc_placeholder: "Enter description",
|
||
start_date: "Start Date",
|
||
end_date: "End Date",
|
||
delete_title: "Confirm Deletion",
|
||
updated: "Updated successfully",
|
||
save_error: "Failed to save",
|
||
tier_standard: "Standard",
|
||
tier_vip: "VIP",
|
||
tier_platinum: "Platinum",
|
||
tier_enterprise: "Enterprise",
|
||
tier_contracted: "Contracted Agent",
|
||
conflict_title: "Rule Conflict Detected",
|
||
conflict_message: "An active rule already exists for this target group and region. Do you want to deactivate the old rule and activate the new one?",
|
||
conflict_confirm: "Confirm Override",
|
||
conflict_cancel: "Cancel"
|
||
};
|
||
const locale_commission_46json_ea60861a = {
|
||
commission_rules: commission_rules
|
||
};
|
||
|
||
var financial_ledger = {
|
||
title: "Financial Ledger",
|
||
subtitle: "Browse the complete financial ledger — transactions, users and details",
|
||
loading: "Loading ledger...",
|
||
error: "Failed to load financial ledger.",
|
||
retry: "Retry",
|
||
no_results: "No financial ledger entries found.",
|
||
no_results_hint: "Try different filter criteria.",
|
||
id: "ID",
|
||
user: "User",
|
||
user_id: "User ID",
|
||
amount: "Amount",
|
||
currency: "Currency",
|
||
transaction_type: "Transaction Type",
|
||
entry_type: "Type",
|
||
wallet_type: "Wallet",
|
||
status: "Status",
|
||
created_at: "Date",
|
||
details: "Details",
|
||
filter: "Filter",
|
||
clear: "Clear",
|
||
prev: "Previous",
|
||
next: "Next",
|
||
page_info: "{page} / {total} pages ({count} items)",
|
||
export_csv: "Export CSV",
|
||
all_types: "All Types",
|
||
all_wallets: "All Wallets",
|
||
all_statuses: "All Statuses",
|
||
date_from: "Date From",
|
||
date_to: "Date To",
|
||
search: "Search",
|
||
csv_downloaded: "CSV download started."
|
||
};
|
||
var enums = {
|
||
entry_type: {
|
||
credit: "Credit",
|
||
debit: "Debit",
|
||
CREDIT: "Credit",
|
||
DEBIT: "Debit"
|
||
},
|
||
wallet_type: {
|
||
earned: "Earned",
|
||
purchased: "Purchased",
|
||
service_coins: "Service Coins",
|
||
voucher: "Voucher",
|
||
EARNED: "Earned",
|
||
PURCHASED: "Purchased",
|
||
SERVICE_COINS: "Service Coins",
|
||
VOUCHER: "Voucher"
|
||
},
|
||
status: {
|
||
pending: "Pending",
|
||
completed: "Completed",
|
||
success: "Success",
|
||
failed: "Failed",
|
||
cancelled: "Cancelled",
|
||
refunded: "Refunded",
|
||
refund: "Refund"
|
||
},
|
||
transaction_type: {
|
||
subscription: "Subscription",
|
||
commission: "Commission",
|
||
refund: "Refund",
|
||
manual_adjustment: "Manual Adjustment",
|
||
purchase: "Purchase",
|
||
withdrawal: "Withdrawal",
|
||
bonus: "Bonus",
|
||
fee: "Fee",
|
||
reward: "Reward"
|
||
}
|
||
};
|
||
const locale_finance_46json_5597e160 = {
|
||
financial_ledger: financial_ledger,
|
||
enums: enums
|
||
};
|
||
|
||
var common$4 = {
|
||
loading: "Wird geladen...",
|
||
saving: "Wird gespeichert...",
|
||
error: "Ein Fehler ist aufgetreten",
|
||
retry: "Wiederholen",
|
||
save: "Speichern",
|
||
saving_data: "Daten werden gespeichert...",
|
||
cancel: "Abbrechen",
|
||
discard: "Verwerfen",
|
||
"delete": "Löschen",
|
||
delete_confirm: "Sind Sie sicher, dass Sie dieses Element löschen möchten?",
|
||
delete_btn: "Löschen",
|
||
delete_title: "Löschen bestätigen",
|
||
deleted: "Erfolgreich gelöscht",
|
||
edit: "Bearbeiten",
|
||
edit_title: "Element bearbeiten",
|
||
create: "Erstellen",
|
||
create_btn: "Erstellen",
|
||
create_title: "Neu erstellen",
|
||
create_first: "Erstellen Sie Ihr erstes Element, um zu beginnen",
|
||
search: "Suchen",
|
||
search_placeholder: "Suchen...",
|
||
filter: "Filter",
|
||
no_results: "Keine Ergebnisse gefunden",
|
||
no_results_hint: "Versuchen Sie, Ihre Such- oder Filterkriterien anzupassen",
|
||
no_items: "Keine Elemente verfügbar",
|
||
actions: "Aktionen",
|
||
status: "Status",
|
||
active: "Aktiv",
|
||
inactive: "Inaktiv",
|
||
activate: "Aktivieren",
|
||
deactivate: "Deaktivieren",
|
||
name: "Name",
|
||
name_placeholder: "Namen eingeben",
|
||
description: "Beschreibung",
|
||
desc_placeholder: "Beschreibung eingeben",
|
||
details: "Details",
|
||
email: "E-Mail",
|
||
id: "ID",
|
||
type: "Typ",
|
||
type_corporate: "Unternehmen",
|
||
view: "Ansehen",
|
||
updated: "Erfolgreich aktualisiert",
|
||
save_error: "Speichern fehlgeschlagen",
|
||
invalid_json: "Ungültiges JSON-Format",
|
||
prev: "Vorherige",
|
||
next: "Nächste",
|
||
none: "Keine",
|
||
reset: "Zurücksetzen",
|
||
confirm: "Bestätigen",
|
||
close: "Schließen",
|
||
back: "Zurück",
|
||
"continue": "Fortfahren",
|
||
exit: "Beenden",
|
||
all: "Alle",
|
||
select_all: "Alle auswählen",
|
||
deselect_all: "Alle abwählen",
|
||
expires: "Läuft ab",
|
||
created: "Erstellt",
|
||
start_date: "Startdatum",
|
||
end_date: "Enddatum",
|
||
points: "Punkte",
|
||
level: "Stufe",
|
||
user: "Benutzer",
|
||
user_id: "Benutzer-ID",
|
||
services: "Dienstleistungen",
|
||
discoveries: "Entdeckungen",
|
||
restriction: "Einschränkung",
|
||
restriction_mild: "Mild",
|
||
restriction_moderate: "Moderat",
|
||
restriction_severe: "Schwer",
|
||
min_xp: "Min. XP",
|
||
xp: "XP",
|
||
penalty: "Strafe",
|
||
feature_flags: "Funktionsschalter",
|
||
permission: "Berechtigung",
|
||
role: "Rolle",
|
||
domain: "Domäne",
|
||
action: "Aktion",
|
||
value: "Wert",
|
||
key: "Schlüssel",
|
||
enabled: "Aktiviert",
|
||
disabled: "Deaktiviert",
|
||
yes: "Ja",
|
||
no: "Nein",
|
||
on: "Ein",
|
||
off: "Aus"
|
||
};
|
||
const locale_de_46json_165a3efe = {
|
||
common: common$4
|
||
};
|
||
|
||
var common$3 = {
|
||
loading: "Chargement...",
|
||
saving: "Enregistrement...",
|
||
error: "Une erreur est survenue",
|
||
retry: "Réessayer",
|
||
save: "Enregistrer",
|
||
saving_data: "Enregistrement des données...",
|
||
cancel: "Annuler",
|
||
discard: "Abandonner",
|
||
"delete": "Supprimer",
|
||
delete_confirm: "Êtes-vous sûr de vouloir supprimer cet élément ?",
|
||
delete_btn: "Supprimer",
|
||
delete_title: "Confirmer la suppression",
|
||
deleted: "Supprimé avec succès",
|
||
edit: "Modifier",
|
||
edit_title: "Modifier l'élément",
|
||
create: "Créer",
|
||
create_btn: "Créer",
|
||
create_title: "Créer nouveau",
|
||
create_first: "Créez votre premier élément pour commencer",
|
||
search: "Rechercher",
|
||
search_placeholder: "Rechercher...",
|
||
filter: "Filtrer",
|
||
no_results: "Aucun résultat trouvé",
|
||
no_results_hint: "Essayez d'ajuster vos critères de recherche ou de filtre",
|
||
no_items: "Aucun élément disponible",
|
||
actions: "Actions",
|
||
status: "Statut",
|
||
active: "Actif",
|
||
inactive: "Inactif",
|
||
activate: "Activer",
|
||
deactivate: "Désactiver",
|
||
name: "Nom",
|
||
name_placeholder: "Entrez le nom",
|
||
description: "Description",
|
||
desc_placeholder: "Entrez la description",
|
||
details: "Détails",
|
||
email: "E-mail",
|
||
id: "ID",
|
||
type: "Type",
|
||
type_corporate: "Entreprise",
|
||
view: "Voir",
|
||
updated: "Mis à jour avec succès",
|
||
save_error: "Échec de l'enregistrement",
|
||
invalid_json: "Format JSON invalide",
|
||
prev: "Précédent",
|
||
next: "Suivant",
|
||
none: "Aucun",
|
||
reset: "Réinitialiser",
|
||
confirm: "Confirmer",
|
||
close: "Fermer",
|
||
back: "Retour",
|
||
"continue": "Continuer",
|
||
exit: "Quitter",
|
||
all: "Tout",
|
||
select_all: "Tout sélectionner",
|
||
deselect_all: "Tout désélectionner",
|
||
expires: "Expire",
|
||
created: "Créé",
|
||
start_date: "Date de début",
|
||
end_date: "Date de fin",
|
||
points: "Points",
|
||
level: "Niveau",
|
||
user: "Utilisateur",
|
||
user_id: "ID utilisateur",
|
||
services: "Services",
|
||
discoveries: "Découvertes",
|
||
restriction: "Restriction",
|
||
restriction_mild: "Légère",
|
||
restriction_moderate: "Modérée",
|
||
restriction_severe: "Sévère",
|
||
min_xp: "XP min",
|
||
xp: "XP",
|
||
penalty: "Pénalité",
|
||
feature_flags: "Indicateurs de fonctionnalités",
|
||
permission: "Permission",
|
||
role: "Rôle",
|
||
domain: "Domaine",
|
||
action: "Action",
|
||
value: "Valeur",
|
||
key: "Clé",
|
||
enabled: "Activé",
|
||
disabled: "Désactivé",
|
||
yes: "Oui",
|
||
no: "Non",
|
||
on: "On",
|
||
off: "Off"
|
||
};
|
||
const locale_fr_46json_3676bfd9 = {
|
||
common: common$3
|
||
};
|
||
|
||
var common$2 = {
|
||
loading: "Se încarcă...",
|
||
saving: "Se salvează...",
|
||
error: "A apărut o eroare",
|
||
retry: "Reîncercare",
|
||
save: "Salvează",
|
||
saving_data: "Se salvează datele...",
|
||
cancel: "Anulează",
|
||
discard: "Renunță",
|
||
"delete": "Șterge",
|
||
delete_confirm: "Ești sigur că vrei să ștergi acest element?",
|
||
delete_btn: "Șterge",
|
||
delete_title: "Confirmă Ștergerea",
|
||
deleted: "Șters cu succes",
|
||
edit: "Editează",
|
||
edit_title: "Editează Elementul",
|
||
create: "Creează",
|
||
create_btn: "Creează",
|
||
create_title: "Creează Nou",
|
||
create_first: "Creează primul tău element pentru a începe",
|
||
search: "Caută",
|
||
search_placeholder: "Caută...",
|
||
filter: "Filtru",
|
||
no_results: "Niciun rezultat găsit",
|
||
no_results_hint: "Încearcă să ajustezi criteriile de căutare sau filtru",
|
||
no_items: "Niciun element disponibil",
|
||
actions: "Acțiuni",
|
||
status: "Status",
|
||
active: "Activ",
|
||
inactive: "Inactiv",
|
||
activate: "Activează",
|
||
deactivate: "Dezactivează",
|
||
name: "Nume",
|
||
name_placeholder: "Introdu numele",
|
||
description: "Descriere",
|
||
desc_placeholder: "Introdu descrierea",
|
||
details: "Detalii",
|
||
email: "Email",
|
||
id: "ID",
|
||
type: "Tip",
|
||
type_corporate: "Corporativ",
|
||
view: "Vizualizează",
|
||
updated: "Actualizat cu succes",
|
||
save_error: "Salvarea a eșuat",
|
||
invalid_json: "Format JSON invalid",
|
||
prev: "Anterior",
|
||
next: "Următor",
|
||
none: "Niciunul",
|
||
reset: "Resetează",
|
||
confirm: "Confirmă",
|
||
close: "Închide",
|
||
back: "Înapoi",
|
||
"continue": "Continuă",
|
||
exit: "Ieșire",
|
||
all: "Toate",
|
||
select_all: "Selectează Tot",
|
||
deselect_all: "Deselectează Tot",
|
||
expires: "Expiră",
|
||
created: "Creat",
|
||
start_date: "Data Începerii",
|
||
end_date: "Data Încheierii",
|
||
points: "Puncte",
|
||
level: "Nivel",
|
||
user: "Utilizator",
|
||
user_id: "ID Utilizator",
|
||
services: "Servicii",
|
||
discoveries: "Descoperiri",
|
||
restriction: "Restricție",
|
||
restriction_mild: "Ușoară",
|
||
restriction_moderate: "Moderată",
|
||
restriction_severe: "Severă",
|
||
min_xp: "XP Min",
|
||
xp: "XP",
|
||
penalty: "Penalizare",
|
||
feature_flags: "Funcții",
|
||
permission: "Permisiune",
|
||
role: "Rol",
|
||
domain: "Domeniu",
|
||
action: "Acțiune",
|
||
value: "Valoare",
|
||
key: "Cheie",
|
||
enabled: "Activat",
|
||
disabled: "Dezactivat",
|
||
yes: "Da",
|
||
no: "Nu",
|
||
on: "Pornit",
|
||
off: "Oprit"
|
||
};
|
||
const locale_ro_46json_ac7b2969 = {
|
||
common: common$2
|
||
};
|
||
|
||
var common$1 = {
|
||
loading: "Načítání...",
|
||
saving: "Ukládání...",
|
||
error: "Došlo k chybě",
|
||
retry: "Opakovat",
|
||
save: "Uložit",
|
||
saving_data: "Ukládání dat...",
|
||
cancel: "Zrušit",
|
||
discard: "Zahodit",
|
||
"delete": "Smazat",
|
||
delete_confirm: "Opravdu chcete smazat tuto položku?",
|
||
delete_btn: "Smazat",
|
||
delete_title: "Potvrdit Smazání",
|
||
deleted: "Úspěšně smazáno",
|
||
edit: "Upravit",
|
||
edit_title: "Upravit Položku",
|
||
create: "Vytvořit",
|
||
create_btn: "Vytvořit",
|
||
create_title: "Vytvořit Nové",
|
||
create_first: "Vytvořte svou první položku pro začátek",
|
||
search: "Hledat",
|
||
search_placeholder: "Hledat...",
|
||
filter: "Filtr",
|
||
no_results: "Nebyly nalezeny žádné výsledky",
|
||
no_results_hint: "Zkuste upravit kritéria vyhledávání nebo filtru",
|
||
no_items: "Žádné položky k dispozici",
|
||
actions: "Akce",
|
||
status: "Stav",
|
||
active: "Aktivní",
|
||
inactive: "Neaktivní",
|
||
activate: "Aktivovat",
|
||
deactivate: "Deaktivovat",
|
||
name: "Název",
|
||
name_placeholder: "Zadejte název",
|
||
description: "Popis",
|
||
desc_placeholder: "Zadejte popis",
|
||
details: "Detaily",
|
||
email: "Email",
|
||
id: "ID",
|
||
type: "Typ",
|
||
type_corporate: "Firemní",
|
||
view: "Zobrazit",
|
||
updated: "Úspěšně aktualizováno",
|
||
save_error: "Uložení selhalo",
|
||
invalid_json: "Neplatný formát JSON",
|
||
prev: "Předchozí",
|
||
next: "Další",
|
||
none: "Žádné",
|
||
reset: "Reset",
|
||
confirm: "Potvrdit",
|
||
close: "Zavřít",
|
||
back: "Zpět",
|
||
"continue": "Pokračovat",
|
||
exit: "Ukončit",
|
||
all: "Vše",
|
||
select_all: "Vybrat Vše",
|
||
deselect_all: "Odznačit Vše",
|
||
expires: "Vyprší",
|
||
created: "Vytvořeno",
|
||
start_date: "Datum Zahájení",
|
||
end_date: "Datum Ukončení",
|
||
points: "Body",
|
||
level: "Úroveň",
|
||
user: "Uživatel",
|
||
user_id: "ID Uživatele",
|
||
services: "Služby",
|
||
discoveries: "Objevy",
|
||
restriction: "Omezení",
|
||
restriction_mild: "Mírné",
|
||
restriction_moderate: "Střední",
|
||
restriction_severe: "Přísné",
|
||
min_xp: "Min XP",
|
||
xp: "XP",
|
||
penalty: "Trest",
|
||
feature_flags: "Funkce",
|
||
permission: "Oprávnění",
|
||
role: "Role",
|
||
domain: "Doména",
|
||
action: "Akce",
|
||
value: "Hodnota",
|
||
key: "Klíč",
|
||
enabled: "Povoleno",
|
||
disabled: "Zakázáno",
|
||
yes: "Ano",
|
||
no: "Ne",
|
||
on: "Zapnuto",
|
||
off: "Vypnuto"
|
||
};
|
||
const locale_cz_46json_c099cec5 = {
|
||
common: common$1
|
||
};
|
||
|
||
var common = {
|
||
loading: "Načítavanie...",
|
||
saving: "Ukladanie...",
|
||
error: "Došlo k chybe",
|
||
retry: "Opakovať",
|
||
save: "Uložiť",
|
||
saving_data: "Ukladanie údajov...",
|
||
cancel: "Zrušiť",
|
||
discard: "Zahodiť",
|
||
"delete": "Zmazať",
|
||
delete_confirm: "Naozaj chcete zmazať túto položku?",
|
||
delete_btn: "Zmazať",
|
||
delete_title: "Potvrdiť Zmazanie",
|
||
deleted: "Úspešne zmazané",
|
||
edit: "Upraviť",
|
||
edit_title: "Upraviť Položku",
|
||
create: "Vytvoriť",
|
||
create_btn: "Vytvoriť",
|
||
create_title: "Vytvoriť Nové",
|
||
create_first: "Vytvorte svoju prvú položku pre začiatok",
|
||
search: "Hľadať",
|
||
search_placeholder: "Hľadať...",
|
||
filter: "Filter",
|
||
no_results: "Nenašli sa žiadne výsledky",
|
||
no_results_hint: "Skúste upraviť kritériá vyhľadávania alebo filtra",
|
||
no_items: "Žiadne položky k dispozícii",
|
||
actions: "Akcie",
|
||
status: "Stav",
|
||
active: "Aktívny",
|
||
inactive: "Neaktívny",
|
||
activate: "Aktivovať",
|
||
deactivate: "Deaktivovať",
|
||
name: "Názov",
|
||
name_placeholder: "Zadajte názov",
|
||
description: "Popis",
|
||
desc_placeholder: "Zadajte popis",
|
||
details: "Detaily",
|
||
email: "Email",
|
||
id: "ID",
|
||
type: "Typ",
|
||
type_corporate: "Firemný",
|
||
view: "Zobraziť",
|
||
updated: "Úspešne aktualizované",
|
||
save_error: "Uloženie zlyhalo",
|
||
invalid_json: "Neplatný formát JSON",
|
||
prev: "Predchádzajúci",
|
||
next: "Ďalší",
|
||
none: "Žiadne",
|
||
reset: "Reset",
|
||
confirm: "Potvrdiť",
|
||
close: "Zavrieť",
|
||
back: "Späť",
|
||
"continue": "Pokračovať",
|
||
exit: "Ukončiť",
|
||
all: "Všetky",
|
||
select_all: "Vybrať Všetky",
|
||
deselect_all: "Odznačiť Všetky",
|
||
expires: "Vyprší",
|
||
created: "Vytvorené",
|
||
start_date: "Dátum Začiatku",
|
||
end_date: "Dátum Ukončenia",
|
||
points: "Body",
|
||
level: "Úroveň",
|
||
user: "Používateľ",
|
||
user_id: "ID Používateľa",
|
||
services: "Služby",
|
||
discoveries: "Objavy",
|
||
restriction: "Obmedzenie",
|
||
restriction_mild: "Mierne",
|
||
restriction_moderate: "Stredné",
|
||
restriction_severe: "Prísne",
|
||
min_xp: "Min XP",
|
||
xp: "XP",
|
||
penalty: "Trest",
|
||
feature_flags: "Funkcie",
|
||
permission: "Oprávnenie",
|
||
role: "Rola",
|
||
domain: "Doména",
|
||
action: "Akcia",
|
||
value: "Hodnota",
|
||
key: "Kľúč",
|
||
enabled: "Povolené",
|
||
disabled: "Zakázané",
|
||
yes: "Áno",
|
||
no: "Nie",
|
||
on: "Zapnuté",
|
||
off: "Vypnuté"
|
||
};
|
||
const locale_sk_46json_c30fede5 = {
|
||
common: common
|
||
};
|
||
|
||
// @ts-nocheck
|
||
const localeCodes = [
|
||
"hu",
|
||
"en",
|
||
"de",
|
||
"fr",
|
||
"ro",
|
||
"cz",
|
||
"sk"
|
||
];
|
||
const localeLoaders = {
|
||
hu: [
|
||
{
|
||
key: "locale_common_46json_68c48c8a",
|
||
load: () => Promise.resolve(locale_common_46json_68c48c8a),
|
||
cache: true
|
||
},
|
||
{
|
||
key: "locale_menu_46json_d8dcbc3e",
|
||
load: () => Promise.resolve(locale_menu_46json_d8dcbc3e),
|
||
cache: true
|
||
},
|
||
{
|
||
key: "locale_dashboard_46json_d0703406",
|
||
load: () => Promise.resolve(locale_dashboard_46json_d0703406),
|
||
cache: true
|
||
},
|
||
{
|
||
key: "locale_providers_46json_ca903007",
|
||
load: () => Promise.resolve(locale_providers_46json_ca903007),
|
||
cache: true
|
||
},
|
||
{
|
||
key: "locale_garages_46json_a818fc5b",
|
||
load: () => Promise.resolve(locale_garages_46json_a818fc5b),
|
||
cache: true
|
||
},
|
||
{
|
||
key: "locale_users_46json_304d0127",
|
||
load: () => Promise.resolve(locale_users_46json_304d0127),
|
||
cache: true
|
||
},
|
||
{
|
||
key: "locale_gamification_46json_15470408",
|
||
load: () => Promise.resolve(locale_gamification_46json_15470408),
|
||
cache: true
|
||
},
|
||
{
|
||
key: "locale_system_46json_21da1de8",
|
||
load: () => Promise.resolve(locale_system_46json_21da1de8),
|
||
cache: true
|
||
},
|
||
{
|
||
key: "locale_commission_46json_2229a18b",
|
||
load: () => Promise.resolve(locale_commission_46json_2229a18b),
|
||
cache: true
|
||
},
|
||
{
|
||
key: "locale_finance_46json_ae59f62d",
|
||
load: () => Promise.resolve(locale_finance_46json_ae59f62d),
|
||
cache: true
|
||
}
|
||
],
|
||
en: [
|
||
{
|
||
key: "locale_common_46json_364cfaa7",
|
||
load: () => Promise.resolve(locale_common_46json_364cfaa7),
|
||
cache: true
|
||
},
|
||
{
|
||
key: "locale_menu_46json_75789531",
|
||
load: () => Promise.resolve(locale_menu_46json_75789531),
|
||
cache: true
|
||
},
|
||
{
|
||
key: "locale_dashboard_46json_d9580386",
|
||
load: () => Promise.resolve(locale_dashboard_46json_d9580386),
|
||
cache: true
|
||
},
|
||
{
|
||
key: "locale_providers_46json_03440ec5",
|
||
load: () => Promise.resolve(locale_providers_46json_03440ec5),
|
||
cache: true
|
||
},
|
||
{
|
||
key: "locale_garages_46json_57a15a2c",
|
||
load: () => Promise.resolve(locale_garages_46json_57a15a2c),
|
||
cache: true
|
||
},
|
||
{
|
||
key: "locale_users_46json_4a4a26a3",
|
||
load: () => Promise.resolve(locale_users_46json_4a4a26a3),
|
||
cache: true
|
||
},
|
||
{
|
||
key: "locale_gamification_46json_111ebf57",
|
||
load: () => Promise.resolve(locale_gamification_46json_111ebf57),
|
||
cache: true
|
||
},
|
||
{
|
||
key: "locale_system_46json_cff5800c",
|
||
load: () => Promise.resolve(locale_system_46json_cff5800c),
|
||
cache: true
|
||
},
|
||
{
|
||
key: "locale_commission_46json_ea60861a",
|
||
load: () => Promise.resolve(locale_commission_46json_ea60861a),
|
||
cache: true
|
||
},
|
||
{
|
||
key: "locale_finance_46json_5597e160",
|
||
load: () => Promise.resolve(locale_finance_46json_5597e160),
|
||
cache: true
|
||
}
|
||
],
|
||
de: [
|
||
{
|
||
key: "locale_de_46json_165a3efe",
|
||
load: () => Promise.resolve(locale_de_46json_165a3efe),
|
||
cache: true
|
||
}
|
||
],
|
||
fr: [
|
||
{
|
||
key: "locale_fr_46json_3676bfd9",
|
||
load: () => Promise.resolve(locale_fr_46json_3676bfd9),
|
||
cache: true
|
||
}
|
||
],
|
||
ro: [
|
||
{
|
||
key: "locale_ro_46json_ac7b2969",
|
||
load: () => Promise.resolve(locale_ro_46json_ac7b2969),
|
||
cache: true
|
||
}
|
||
],
|
||
cz: [
|
||
{
|
||
key: "locale_cz_46json_c099cec5",
|
||
load: () => Promise.resolve(locale_cz_46json_c099cec5),
|
||
cache: true
|
||
}
|
||
],
|
||
sk: [
|
||
{
|
||
key: "locale_sk_46json_c30fede5",
|
||
load: () => Promise.resolve(locale_sk_46json_c30fede5),
|
||
cache: true
|
||
}
|
||
]
|
||
};
|
||
const vueI18nConfigs = [];
|
||
const normalizedLocales = [
|
||
{
|
||
code: "hu",
|
||
iso: "hu-HU",
|
||
name: "Magyar",
|
||
language: undefined
|
||
},
|
||
{
|
||
code: "en",
|
||
iso: "en-GB",
|
||
name: "English",
|
||
language: undefined
|
||
},
|
||
{
|
||
code: "de",
|
||
iso: "de-DE",
|
||
name: "Deutsch",
|
||
language: undefined
|
||
},
|
||
{
|
||
code: "fr",
|
||
iso: "fr-FR",
|
||
name: "Français",
|
||
language: undefined
|
||
},
|
||
{
|
||
code: "ro",
|
||
iso: "ro-RO",
|
||
name: "Română",
|
||
language: undefined
|
||
},
|
||
{
|
||
code: "cz",
|
||
iso: "cs-CZ",
|
||
name: "Čeština",
|
||
language: undefined
|
||
},
|
||
{
|
||
code: "sk",
|
||
iso: "sk-SK",
|
||
name: "Slovenčina",
|
||
language: undefined
|
||
}
|
||
];
|
||
|
||
const setupVueI18nOptions = async (defaultLocale) => {
|
||
const options = await loadVueI18nOptions(vueI18nConfigs);
|
||
options.locale = defaultLocale || options.locale || "en-US";
|
||
options.defaultLocale = defaultLocale;
|
||
options.fallbackLocale ??= false;
|
||
options.messages ??= {};
|
||
for (const locale of localeCodes) {
|
||
options.messages[locale] ??= {};
|
||
}
|
||
return options;
|
||
};
|
||
|
||
function defineNitroPlugin(def) {
|
||
return def;
|
||
}
|
||
|
||
function defineRenderHandler(render) {
|
||
const runtimeConfig = useRuntimeConfig();
|
||
return eventHandler(async (event) => {
|
||
const nitroApp = useNitroApp();
|
||
const ctx = { event, render, response: void 0 };
|
||
await nitroApp.hooks.callHook("render:before", ctx);
|
||
if (!ctx.response) {
|
||
if (event.path === `${runtimeConfig.app.baseURL}favicon.ico`) {
|
||
setResponseHeader(event, "Content-Type", "image/x-icon");
|
||
return send(
|
||
event,
|
||
"data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7"
|
||
);
|
||
}
|
||
ctx.response = await ctx.render(event);
|
||
if (!ctx.response) {
|
||
const _currentStatus = getResponseStatus(event);
|
||
setResponseStatus(event, _currentStatus === 200 ? 500 : _currentStatus);
|
||
return send(
|
||
event,
|
||
"No response returned from render handler: " + event.path
|
||
);
|
||
}
|
||
}
|
||
await nitroApp.hooks.callHook("render:response", ctx.response, ctx);
|
||
if (ctx.response.headers) {
|
||
setResponseHeaders(event, ctx.response.headers);
|
||
}
|
||
if (ctx.response.statusCode || ctx.response.statusMessage) {
|
||
setResponseStatus(
|
||
event,
|
||
ctx.response.statusCode,
|
||
ctx.response.statusMessage
|
||
);
|
||
}
|
||
return ctx.response.body;
|
||
});
|
||
}
|
||
|
||
const scheduledTasks = false;
|
||
|
||
const tasks = {
|
||
|
||
};
|
||
|
||
const __runningTasks__ = {};
|
||
async function runTask(name, {
|
||
payload = {},
|
||
context = {}
|
||
} = {}) {
|
||
if (__runningTasks__[name]) {
|
||
return __runningTasks__[name];
|
||
}
|
||
if (!(name in tasks)) {
|
||
throw createError({
|
||
message: `Task \`${name}\` is not available!`,
|
||
statusCode: 404
|
||
});
|
||
}
|
||
if (!tasks[name].resolve) {
|
||
throw createError({
|
||
message: `Task \`${name}\` is not implemented!`,
|
||
statusCode: 501
|
||
});
|
||
}
|
||
const handler = await tasks[name].resolve();
|
||
const taskEvent = { name, payload, context };
|
||
__runningTasks__[name] = handler.run(taskEvent);
|
||
try {
|
||
const res = await __runningTasks__[name];
|
||
return res;
|
||
} finally {
|
||
delete __runningTasks__[name];
|
||
}
|
||
}
|
||
|
||
function buildAssetsDir() {
|
||
|
||
return useRuntimeConfig().app.buildAssetsDir;
|
||
}
|
||
function buildAssetsURL(...path) {
|
||
return joinRelativeURL(publicAssetsURL(), buildAssetsDir(), ...path);
|
||
}
|
||
function publicAssetsURL(...path) {
|
||
|
||
const app = useRuntimeConfig().app;
|
||
const publicBase = app.cdnURL || app.baseURL;
|
||
return path.length ? joinRelativeURL(publicBase, ...path) : publicBase;
|
||
}
|
||
|
||
function parseAcceptLanguage(value) {
|
||
return value.split(",").map((tag) => tag.split(";")[0]).filter(
|
||
(tag) => !(tag === "*" || tag === "")
|
||
);
|
||
}
|
||
function createPathIndexLanguageParser(index = 0) {
|
||
return (path) => {
|
||
const rawPath = typeof path === "string" ? path : path.pathname;
|
||
const normalizedPath = rawPath.split("?")[0];
|
||
const parts = normalizedPath.split("/");
|
||
if (parts[0] === "") {
|
||
parts.shift();
|
||
}
|
||
return parts.length > index ? parts[index] || "" : "";
|
||
};
|
||
}
|
||
|
||
function useRuntimeI18n(nuxtApp, event) {
|
||
{
|
||
return useRuntimeConfig(event).public.i18n;
|
||
}
|
||
}
|
||
function useI18nDetection(nuxtApp) {
|
||
const detectBrowserLanguage = useRuntimeI18n().detectBrowserLanguage;
|
||
const detect = detectBrowserLanguage || {};
|
||
return {
|
||
...detect,
|
||
enabled: !!detectBrowserLanguage,
|
||
cookieKey: detect.cookieKey || "i18n_redirected"
|
||
};
|
||
}
|
||
function resolveRootRedirect(config) {
|
||
if (!config) {
|
||
return void 0;
|
||
}
|
||
return {
|
||
path: "/" + (isString(config) ? config : config.path).replace(/^\//, ""),
|
||
code: !isString(config) && config.statusCode || 302
|
||
};
|
||
}
|
||
function toArray(value) {
|
||
return Array.isArray(value) ? value : [value];
|
||
}
|
||
|
||
function createLocaleConfigs(fallbackLocale) {
|
||
const localeConfigs = {};
|
||
for (const locale of localeCodes) {
|
||
const fallbacks = getFallbackLocaleCodes(fallbackLocale, [locale]);
|
||
const cacheable = isLocaleWithFallbacksCacheable(locale, fallbacks);
|
||
localeConfigs[locale] = { fallbacks, cacheable };
|
||
}
|
||
return localeConfigs;
|
||
}
|
||
function getFallbackLocaleCodes(fallback, locales) {
|
||
if (fallback === false) {
|
||
return [];
|
||
}
|
||
if (isArray(fallback)) {
|
||
return fallback;
|
||
}
|
||
let fallbackLocales = [];
|
||
if (isString(fallback)) {
|
||
if (locales.every((locale) => locale !== fallback)) {
|
||
fallbackLocales.push(fallback);
|
||
}
|
||
return fallbackLocales;
|
||
}
|
||
const targets = [...locales, "default"];
|
||
for (const locale of targets) {
|
||
if (locale in fallback == false) {
|
||
continue;
|
||
}
|
||
fallbackLocales = [...fallbackLocales, ...fallback[locale].filter(Boolean)];
|
||
}
|
||
return fallbackLocales;
|
||
}
|
||
function isLocaleCacheable(locale) {
|
||
return localeLoaders[locale] != null && localeLoaders[locale].every((loader) => loader.cache !== false);
|
||
}
|
||
function isLocaleWithFallbacksCacheable(locale, fallbackLocales) {
|
||
return isLocaleCacheable(locale) && fallbackLocales.every((fallbackLocale) => isLocaleCacheable(fallbackLocale));
|
||
}
|
||
function getDefaultLocaleForDomain(host) {
|
||
return normalizedLocales.find((l) => !!l.defaultForDomains?.includes(host))?.code;
|
||
}
|
||
const isSupportedLocale = (locale) => localeCodes.includes(locale || "");
|
||
|
||
function useI18nContext(event) {
|
||
if (event.context.nuxtI18n == null) {
|
||
throw new Error("Nuxt I18n server context has not been set up yet.");
|
||
}
|
||
return event.context.nuxtI18n;
|
||
}
|
||
function tryUseI18nContext(event) {
|
||
return event.context.nuxtI18n;
|
||
}
|
||
const getHost = (event) => getRequestURL(event, { xForwardedHost: true }).host;
|
||
async function initializeI18nContext(event) {
|
||
const runtimeI18n = useRuntimeI18n(void 0, event);
|
||
const defaultLocale = runtimeI18n.defaultLocale || "";
|
||
const options = await setupVueI18nOptions(getDefaultLocaleForDomain(getHost(event)) || defaultLocale);
|
||
const localeConfigs = createLocaleConfigs(options.fallbackLocale);
|
||
const ctx = createI18nContext();
|
||
ctx.vueI18nOptions = options;
|
||
ctx.localeConfigs = localeConfigs;
|
||
event.context.nuxtI18n = ctx;
|
||
return ctx;
|
||
}
|
||
function createI18nContext() {
|
||
return {
|
||
messages: {},
|
||
slp: {},
|
||
localeConfigs: {},
|
||
trackMap: {},
|
||
vueI18nOptions: void 0,
|
||
trackKey(key, locale) {
|
||
this.trackMap[locale] ??= /* @__PURE__ */ new Set();
|
||
this.trackMap[locale].add(key);
|
||
}
|
||
};
|
||
}
|
||
|
||
function matchBrowserLocale(locales, browserLocales) {
|
||
const matchedLocales = [];
|
||
for (const [index, browserCode] of browserLocales.entries()) {
|
||
const matchedLocale = locales.find((l) => l.language?.toLowerCase() === browserCode.toLowerCase());
|
||
if (matchedLocale) {
|
||
matchedLocales.push({ code: matchedLocale.code, score: 1 - index / browserLocales.length });
|
||
break;
|
||
}
|
||
}
|
||
for (const [index, browserCode] of browserLocales.entries()) {
|
||
const languageCode = browserCode.split("-")[0].toLowerCase();
|
||
const matchedLocale = locales.find((l) => l.language?.split("-")[0].toLowerCase() === languageCode);
|
||
if (matchedLocale) {
|
||
matchedLocales.push({ code: matchedLocale.code, score: 0.999 - index / browserLocales.length });
|
||
break;
|
||
}
|
||
}
|
||
return matchedLocales;
|
||
}
|
||
function compareBrowserLocale(a, b) {
|
||
if (a.score === b.score) {
|
||
return b.code.length - a.code.length;
|
||
}
|
||
return b.score - a.score;
|
||
}
|
||
function findBrowserLocale(locales, browserLocales) {
|
||
const matchedLocales = matchBrowserLocale(
|
||
locales.map((l) => ({ code: l.code, language: l.language || l.code })),
|
||
browserLocales
|
||
);
|
||
return matchedLocales.sort(compareBrowserLocale).at(0)?.code ?? "";
|
||
}
|
||
|
||
const appHead = {"meta":[{"name":"viewport","content":"width=device-width, initial-scale=1"},{"charset":"utf-8"}],"link":[],"style":[],"script":[],"noscript":[]};
|
||
|
||
const appRootTag = "div";
|
||
|
||
const appRootAttrs = {"id":"__nuxt"};
|
||
|
||
const appTeleportTag = "div";
|
||
|
||
const appTeleportAttrs = {"id":"teleports"};
|
||
|
||
const appId = "nuxt-app";
|
||
|
||
const separator = "___";
|
||
const pathLanguageParser = createPathIndexLanguageParser(0);
|
||
const getLocaleFromRoutePath = (path) => pathLanguageParser(path);
|
||
const getLocaleFromRouteName = (name) => name.split(separator).at(1) ?? "";
|
||
function normalizeInput(input) {
|
||
return typeof input !== "object" ? String(input) : String(input?.name || input?.path || "");
|
||
}
|
||
function getLocaleFromRoute(route) {
|
||
const input = normalizeInput(route);
|
||
if (input[0] === "/") {
|
||
return getLocaleFromRoutePath(input);
|
||
}
|
||
const fromName = getLocaleFromRouteName(input);
|
||
if (fromName) {
|
||
return fromName;
|
||
}
|
||
if (typeof route === "object" && route?.path) {
|
||
return getLocaleFromRoutePath(String(route.path));
|
||
}
|
||
return "";
|
||
}
|
||
|
||
function matchDomainLocale(locales, host, pathLocale) {
|
||
const normalizeDomain = (domain = "") => domain.replace(/https?:\/\//, "");
|
||
const matches = locales.filter(
|
||
(locale) => normalizeDomain(locale.domain) === host || toArray(locale.domains).includes(host)
|
||
);
|
||
if (matches.length <= 1) {
|
||
return matches[0]?.code;
|
||
}
|
||
return (
|
||
// match by current path locale
|
||
matches.find((l) => l.code === pathLocale)?.code || matches.find((l) => l.defaultForDomains?.includes(host) ?? l.domainDefault)?.code
|
||
);
|
||
}
|
||
|
||
const getCookieLocale = (event, cookieName) => (getCookie(event, cookieName)) || void 0;
|
||
const getRouteLocale = (event, route) => getLocaleFromRoute(route);
|
||
const getHeaderLocale = (event) => findBrowserLocale(normalizedLocales, parseAcceptLanguage(getRequestHeader(event, "accept-language") || ""));
|
||
const getHostLocale = (event, path, domainLocales) => {
|
||
const host = getRequestURL(event, { xForwardedHost: true }).host;
|
||
const locales = normalizedLocales.map((l) => ({
|
||
...l,
|
||
domain: domainLocales[l.code]?.domain ?? l.domain
|
||
}));
|
||
return matchDomainLocale(locales, host, getLocaleFromRoutePath(path));
|
||
};
|
||
const useDetectors = (event, config, nuxtApp) => {
|
||
if (!event) {
|
||
throw new Error("H3Event is required for server-side locale detection");
|
||
}
|
||
const runtimeI18n = useRuntimeI18n();
|
||
return {
|
||
cookie: () => getCookieLocale(event, config.cookieKey),
|
||
header: () => getHeaderLocale(event) ,
|
||
navigator: () => void 0,
|
||
host: (path) => getHostLocale(event, path, runtimeI18n.domainLocales),
|
||
route: (path) => getRouteLocale(event, path)
|
||
};
|
||
};
|
||
|
||
// Generated by @nuxtjs/i18n
|
||
const pathToI18nConfig = {};
|
||
const i18nPathToPath = {};
|
||
const disabledI18nPathToPath = {};
|
||
|
||
const formatTrailingSlash = withoutTrailingSlash;
|
||
const matcher = createRouterMatcher([], {});
|
||
for (const path of Object.keys(i18nPathToPath)) {
|
||
matcher.addRoute({ path, component: () => "", meta: {} });
|
||
}
|
||
const disabledI18nMatcher = createRouterMatcher([], {});
|
||
for (const path of Object.keys(disabledI18nPathToPath)) {
|
||
disabledI18nMatcher.addRoute({ path, component: () => "", meta: {} });
|
||
}
|
||
const getI18nPathToI18nPath = (path, locale) => {
|
||
if (!path || !locale) {
|
||
return;
|
||
}
|
||
const plainPath = i18nPathToPath[path];
|
||
const i18nConfig = pathToI18nConfig[plainPath];
|
||
if (i18nConfig && i18nConfig[locale]) {
|
||
return i18nConfig[locale] === true ? plainPath : i18nConfig[locale];
|
||
}
|
||
};
|
||
function isExistingNuxtRoute(path) {
|
||
if (path === "") {
|
||
return;
|
||
}
|
||
if (path.endsWith("/__nuxt_error")) {
|
||
return;
|
||
}
|
||
const disabledI18nResolvedMatch = disabledI18nMatcher.resolve({ path }, { path: "/", name: "", matched: [], params: {}, meta: {} });
|
||
if (disabledI18nResolvedMatch.matched.length > 0) {
|
||
return;
|
||
}
|
||
const resolvedMatch = matcher.resolve({ path }, { path: "/", name: "", matched: [], params: {}, meta: {} });
|
||
return resolvedMatch.matched.length > 0 ? resolvedMatch : void 0;
|
||
}
|
||
function matchLocalized(path, locale, defaultLocale) {
|
||
if (path === "") {
|
||
return;
|
||
}
|
||
const parsed = parsePath(path);
|
||
const resolvedMatch = matcher.resolve(
|
||
{ path: parsed.pathname || "/" },
|
||
{ path: "/", name: "", matched: [], params: {}, meta: {} }
|
||
);
|
||
if (resolvedMatch.matched.length > 0) {
|
||
const alternate = getI18nPathToI18nPath(resolvedMatch.matched[0].path, locale);
|
||
const match = matcher.resolve(
|
||
{ params: resolvedMatch.params },
|
||
{ path: alternate || "/", name: "", matched: [], params: {}, meta: {} }
|
||
);
|
||
return formatTrailingSlash(withLeadingSlash(joinURL("", match.path)), true);
|
||
}
|
||
}
|
||
|
||
function* detect(detectors, detection, path) {
|
||
if (detection.enabled) {
|
||
yield { locale: detectors.cookie(), source: "cookie" };
|
||
yield { locale: detectors.header(), source: "header" };
|
||
}
|
||
yield { locale: detection.fallbackLocale, source: "fallback" };
|
||
}
|
||
function createRedirectResponse(event, dest, code) {
|
||
event.node.res.setHeader("location", dest);
|
||
event.node.res.statusCode = sanitizeStatusCode(code, event.node.res.statusCode);
|
||
return {
|
||
headers: event.node.res.getHeaders(),
|
||
statusCode: event.node.res.statusCode,
|
||
body: `<!DOCTYPE html><html><head><meta http-equiv="refresh" content="0; url=${dest.replace(/"/g, "%22")}"></head></html>`
|
||
};
|
||
}
|
||
const _HSLR6LVYB6Jxg8OzRp1aUz6fuSwaQ2FVuwBtHNuoR0w = defineNitroPlugin(async (nitro) => {
|
||
const runtimeI18n = useRuntimeI18n();
|
||
const rootRedirect = resolveRootRedirect(runtimeI18n.rootRedirect);
|
||
runtimeI18n.defaultLocale || "";
|
||
try {
|
||
const cacheStorage = useStorage("cache");
|
||
const cachedKeys = await cacheStorage.getKeys("nitro:handlers:i18n");
|
||
await Promise.all(cachedKeys.map((key) => cacheStorage.removeItem(key)));
|
||
} catch {
|
||
}
|
||
const detection = useI18nDetection();
|
||
const cookieOptions = {
|
||
path: "/",
|
||
domain: detection.cookieDomain || void 0,
|
||
maxAge: 60 * 60 * 24 * 365,
|
||
sameSite: "lax",
|
||
secure: detection.cookieSecure
|
||
};
|
||
const createBaseUrlGetter = () => {
|
||
isFunction(runtimeI18n.baseUrl) ? "" : runtimeI18n.baseUrl || "";
|
||
if (isFunction(runtimeI18n.baseUrl)) {
|
||
console.warn("[nuxt-i18n] Configuring baseUrl as a function is deprecated and will be removed in v11.");
|
||
return () => "";
|
||
}
|
||
return (event, defaultLocale) => {
|
||
return "";
|
||
};
|
||
};
|
||
function resolveRedirectPath(event, path, pathLocale, defaultLocale, detector) {
|
||
let locale = "";
|
||
for (const detected of detect(detector, detection, event.path)) {
|
||
if (detected.locale && isSupportedLocale(detected.locale)) {
|
||
locale = detected.locale;
|
||
break;
|
||
}
|
||
}
|
||
locale ||= defaultLocale;
|
||
function getLocalizedMatch(locale2) {
|
||
const res = matchLocalized(path || "/", locale2);
|
||
if (res && res !== event.path) {
|
||
return res;
|
||
}
|
||
}
|
||
let resolvedPath = void 0;
|
||
let redirectCode = 302;
|
||
const requestURL = getRequestURL(event);
|
||
if (rootRedirect && requestURL.pathname === "/") {
|
||
locale = detection.enabled && locale || defaultLocale;
|
||
resolvedPath = isSupportedLocale(detector.route(rootRedirect.path)) && rootRedirect.path || matchLocalized(rootRedirect.path, locale);
|
||
redirectCode = rootRedirect.code;
|
||
} else if (runtimeI18n.redirectStatusCode) {
|
||
redirectCode = runtimeI18n.redirectStatusCode;
|
||
}
|
||
switch (detection.redirectOn) {
|
||
case "root":
|
||
if (requestURL.pathname !== "/") {
|
||
break;
|
||
}
|
||
// fallthrough (root has no prefix)
|
||
case "no prefix":
|
||
if (pathLocale) {
|
||
break;
|
||
}
|
||
// fallthrough to resolve
|
||
case "all":
|
||
resolvedPath ??= getLocalizedMatch(locale);
|
||
break;
|
||
}
|
||
if (requestURL.pathname === "/" && "no_prefix" === "prefix") ;
|
||
return { path: resolvedPath, code: redirectCode, locale };
|
||
}
|
||
const baseUrlGetter = createBaseUrlGetter();
|
||
nitro.hooks.hook("request", async (event) => {
|
||
await initializeI18nContext(event);
|
||
});
|
||
nitro.hooks.hook("render:before", async (context) => {
|
||
const { event } = context;
|
||
const ctx = useI18nContext(event);
|
||
const url = getRequestURL(event);
|
||
const detector = useDetectors(event, detection);
|
||
const localeSegment = detector.route(event.path);
|
||
const pathLocale = isSupportedLocale(localeSegment) && localeSegment || void 0;
|
||
const path = (pathLocale && url.pathname.slice(pathLocale.length + 1)) ?? url.pathname;
|
||
if (!url.pathname.includes("/_i18n") && !isExistingNuxtRoute(path)) {
|
||
return;
|
||
}
|
||
const resolved = resolveRedirectPath(event, path, pathLocale, ctx.vueI18nOptions.defaultLocale, detector);
|
||
if (resolved.path && resolved.path !== url.pathname) {
|
||
ctx.detectLocale = resolved.locale;
|
||
detection.useCookie && setCookie(event, detection.cookieKey, resolved.locale, cookieOptions);
|
||
context.response = createRedirectResponse(
|
||
event,
|
||
joinURL(baseUrlGetter(event, ctx.vueI18nOptions.defaultLocale), resolved.path + url.search),
|
||
resolved.code
|
||
);
|
||
return;
|
||
}
|
||
});
|
||
nitro.hooks.hook("render:html", (htmlContext, { event }) => {
|
||
tryUseI18nContext(event);
|
||
});
|
||
});
|
||
|
||
const rootDir = "/app";
|
||
|
||
const devReducers = {
|
||
VNode: (data) => isVNode(data) ? {
|
||
type: data.type,
|
||
props: data.props
|
||
} : undefined,
|
||
URL: (data) => data instanceof URL ? data.toString() : undefined,
|
||
Symbol: (data) => typeof data === "symbol" ? data.description ?? "" : undefined
|
||
};
|
||
const asyncContext = getContext("nuxt-dev", {
|
||
asyncContext: true,
|
||
AsyncLocalStorage
|
||
});
|
||
const _1xyvuM2CQDhMlDxE8qY1t3Wi66ocgNUNDNce4pREOrU = (nitroApp) => {
|
||
const handler = nitroApp.h3App.handler;
|
||
nitroApp.h3App.handler = (event) => {
|
||
return asyncContext.callAsync({
|
||
logs: [],
|
||
event
|
||
}, () => handler(event));
|
||
};
|
||
onConsoleLog((_log) => {
|
||
const ctx = asyncContext.tryUse();
|
||
if (!ctx) {
|
||
return;
|
||
}
|
||
const rawStack = captureRawStackTrace();
|
||
if (!rawStack || rawStack.includes("runtime/vite-node.mjs")) {
|
||
return;
|
||
}
|
||
const trace = [];
|
||
let filename = "";
|
||
for (const entry of parseRawStackTrace(rawStack)) {
|
||
if (entry.source === globalThis._importMeta_.url) {
|
||
continue;
|
||
}
|
||
if (EXCLUDE_TRACE_RE.test(entry.source)) {
|
||
continue;
|
||
}
|
||
filename ||= entry.source.replace(withTrailingSlash(rootDir), "");
|
||
trace.push({
|
||
...entry,
|
||
source: entry.source.startsWith("file://") ? entry.source.replace("file://", "") : entry.source
|
||
});
|
||
}
|
||
const log = {
|
||
..._log,
|
||
|
||
filename,
|
||
|
||
stack: trace
|
||
};
|
||
|
||
ctx.logs.push(log);
|
||
});
|
||
nitroApp.hooks.hook("afterResponse", () => {
|
||
const ctx = asyncContext.tryUse();
|
||
if (!ctx) {
|
||
return;
|
||
}
|
||
return nitroApp.hooks.callHook("dev:ssr-logs", {
|
||
logs: ctx.logs,
|
||
path: ctx.event.path
|
||
});
|
||
});
|
||
|
||
nitroApp.hooks.hook("render:html", (htmlContext) => {
|
||
const ctx = asyncContext.tryUse();
|
||
if (!ctx) {
|
||
return;
|
||
}
|
||
try {
|
||
const reducers = Object.assign(Object.create(null), devReducers, ctx.event.context["~payloadReducers"]);
|
||
htmlContext.bodyAppend.unshift(`<script type="application/json" data-nuxt-logs="${appId}">${stringify(ctx.logs, reducers)}<\/script>`);
|
||
} catch (e) {
|
||
const shortError = e instanceof Error && "toString" in e ? ` Received \`${e.toString()}\`.` : "";
|
||
console.warn(`[nuxt] Failed to stringify dev server logs.${shortError} You can define your own reducer/reviver for rich types following the instructions in https://nuxt.com/docs/api/composables/use-nuxt-app#payload.`);
|
||
}
|
||
});
|
||
};
|
||
const EXCLUDE_TRACE_RE = /\/node_modules\/(?:.*\/)?(?:nuxt|nuxt-nightly|nuxt-edge|nuxt3|consola|@vue)\/|core\/runtime\/nitro/;
|
||
function onConsoleLog(callback) {
|
||
consola$1.addReporter({ log(logObj) {
|
||
callback(logObj);
|
||
} });
|
||
consola$1.wrapConsole();
|
||
}
|
||
|
||
const plugins = [
|
||
_FMnHxsRb1XnhSkgrcxwDEP1elfSPjrP7Wr27yXkb3Aw,
|
||
_HSLR6LVYB6Jxg8OzRp1aUz6fuSwaQ2FVuwBtHNuoR0w,
|
||
_1xyvuM2CQDhMlDxE8qY1t3Wi66ocgNUNDNce4pREOrU,
|
||
_wH6JrtIxmaSoA8lCPWFnE9z4lQeXW6H5z3l5aymEQw
|
||
];
|
||
|
||
const assets = {};
|
||
|
||
function readAsset (id) {
|
||
const serverDir = dirname$1(fileURLToPath(globalThis._importMeta_.url));
|
||
return promises.readFile(resolve$1(serverDir, assets[id].path))
|
||
}
|
||
|
||
const publicAssetBases = {"/_nuxt/builds/meta/":{"maxAge":31536000},"/_nuxt/builds/":{"maxAge":1}};
|
||
|
||
function isPublicAssetURL(id = '') {
|
||
if (assets[id]) {
|
||
return true
|
||
}
|
||
for (const base in publicAssetBases) {
|
||
if (id.startsWith(base)) { return true }
|
||
}
|
||
return false
|
||
}
|
||
|
||
function getAsset (id) {
|
||
return assets[id]
|
||
}
|
||
|
||
const METHODS = /* @__PURE__ */ new Set(["HEAD", "GET"]);
|
||
const EncodingMap = { gzip: ".gz", br: ".br" };
|
||
const _oStzCE = eventHandler((event) => {
|
||
if (event.method && !METHODS.has(event.method)) {
|
||
return;
|
||
}
|
||
let id = decodePath(
|
||
withLeadingSlash(withoutTrailingSlash(parseURL(event.path).pathname))
|
||
);
|
||
let asset;
|
||
const encodingHeader = String(
|
||
getRequestHeader(event, "accept-encoding") || ""
|
||
);
|
||
const encodings = [
|
||
...encodingHeader.split(",").map((e) => EncodingMap[e.trim()]).filter(Boolean).sort(),
|
||
""
|
||
];
|
||
for (const encoding of encodings) {
|
||
for (const _id of [id + encoding, joinURL(id, "index.html" + encoding)]) {
|
||
const _asset = getAsset(_id);
|
||
if (_asset) {
|
||
asset = _asset;
|
||
id = _id;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (!asset) {
|
||
if (isPublicAssetURL(id)) {
|
||
removeResponseHeader(event, "Cache-Control");
|
||
throw createError({ statusCode: 404 });
|
||
}
|
||
return;
|
||
}
|
||
if (asset.encoding !== void 0) {
|
||
appendResponseHeader(event, "Vary", "Accept-Encoding");
|
||
}
|
||
const ifNotMatch = getRequestHeader(event, "if-none-match") === asset.etag;
|
||
if (ifNotMatch) {
|
||
setResponseStatus(event, 304, "Not Modified");
|
||
return "";
|
||
}
|
||
const ifModifiedSinceH = getRequestHeader(event, "if-modified-since");
|
||
const mtimeDate = new Date(asset.mtime);
|
||
if (ifModifiedSinceH && asset.mtime && new Date(ifModifiedSinceH) >= mtimeDate) {
|
||
setResponseStatus(event, 304, "Not Modified");
|
||
return "";
|
||
}
|
||
if (asset.type && !getResponseHeader(event, "Content-Type")) {
|
||
setResponseHeader(event, "Content-Type", asset.type);
|
||
}
|
||
if (asset.etag && !getResponseHeader(event, "ETag")) {
|
||
setResponseHeader(event, "ETag", asset.etag);
|
||
}
|
||
if (asset.mtime && !getResponseHeader(event, "Last-Modified")) {
|
||
setResponseHeader(event, "Last-Modified", mtimeDate.toUTCString());
|
||
}
|
||
if (asset.encoding && !getResponseHeader(event, "Content-Encoding")) {
|
||
setResponseHeader(event, "Content-Encoding", asset.encoding);
|
||
}
|
||
if (asset.size > 0 && !getResponseHeader(event, "Content-Length")) {
|
||
setResponseHeader(event, "Content-Length", asset.size);
|
||
}
|
||
return readAsset(id);
|
||
});
|
||
|
||
const storage = prefixStorage(useStorage(), "i18n");
|
||
function cachedFunctionI18n(fn, opts) {
|
||
opts = { maxAge: 1, ...opts };
|
||
const pending = {};
|
||
async function get(key, resolver) {
|
||
const isPending = pending[key];
|
||
if (!isPending) {
|
||
pending[key] = Promise.resolve(resolver());
|
||
}
|
||
try {
|
||
return await pending[key];
|
||
} finally {
|
||
delete pending[key];
|
||
}
|
||
}
|
||
return async (...args) => {
|
||
const key = [opts.name, opts.getKey(...args)].join(":").replace(/:\/$/, ":index");
|
||
const maxAge = opts.maxAge ?? 1;
|
||
const isCacheable = !opts.shouldBypassCache(...args) && maxAge >= 0;
|
||
const cache = isCacheable && await storage.getItemRaw(key);
|
||
if (!cache || cache.ttl < Date.now()) {
|
||
pending[key] = Promise.resolve(fn(...args));
|
||
const value = await get(key, () => fn(...args));
|
||
if (isCacheable) {
|
||
await storage.setItemRaw(key, { ttl: Date.now() + maxAge * 1e3, value, mtime: Date.now() });
|
||
}
|
||
return value;
|
||
}
|
||
return cache.value;
|
||
};
|
||
}
|
||
|
||
const _getMessages = async (locale) => {
|
||
return { [locale]: await getLocaleMessagesMerged(locale, localeLoaders[locale]) };
|
||
};
|
||
cachedFunctionI18n(_getMessages, {
|
||
name: "messages",
|
||
maxAge: -1 ,
|
||
getKey: (locale) => locale,
|
||
shouldBypassCache: (locale) => !isLocaleCacheable(locale)
|
||
});
|
||
const getMessages = _getMessages ;
|
||
const _getMergedMessages = async (locale, fallbackLocales) => {
|
||
const merged = {};
|
||
try {
|
||
if (fallbackLocales.length > 0) {
|
||
const messages = await Promise.all(fallbackLocales.map(getMessages));
|
||
for (const message2 of messages) {
|
||
deepCopy(message2, merged);
|
||
}
|
||
}
|
||
const message = await getMessages(locale);
|
||
deepCopy(message, merged);
|
||
return merged;
|
||
} catch (e) {
|
||
throw new Error("Failed to merge messages: " + e.message);
|
||
}
|
||
};
|
||
const getMergedMessages = cachedFunctionI18n(_getMergedMessages, {
|
||
name: "merged-single",
|
||
maxAge: -1 ,
|
||
getKey: (locale, fallbackLocales) => `${locale}-[${[...new Set(fallbackLocales)].sort().join("-")}]`,
|
||
shouldBypassCache: (locale, fallbackLocales) => !isLocaleWithFallbacksCacheable(locale, fallbackLocales)
|
||
});
|
||
const _getAllMergedMessages = async (locales) => {
|
||
const merged = {};
|
||
try {
|
||
const messages = await Promise.all(locales.map(getMessages));
|
||
for (const message of messages) {
|
||
deepCopy(message, merged);
|
||
}
|
||
return merged;
|
||
} catch (e) {
|
||
throw new Error("Failed to merge messages: " + e.message);
|
||
}
|
||
};
|
||
cachedFunctionI18n(_getAllMergedMessages, {
|
||
name: "merged-all",
|
||
maxAge: -1 ,
|
||
getKey: (locales) => locales.join("-"),
|
||
shouldBypassCache: (locales) => !locales.every((locale) => isLocaleCacheable(locale))
|
||
});
|
||
|
||
const _messagesHandler = defineEventHandler(async (event) => {
|
||
const locale = getRouterParam(event, "locale");
|
||
if (!locale) {
|
||
throw createError({ status: 400, message: "Locale not specified." });
|
||
}
|
||
const ctx = useI18nContext(event);
|
||
if (ctx.localeConfigs && locale in ctx.localeConfigs === false) {
|
||
throw createError({ status: 404, message: `Locale '${locale}' not found.` });
|
||
}
|
||
const messages = await getMergedMessages(locale, ctx.localeConfigs?.[locale]?.fallbacks ?? []);
|
||
deepCopy(messages, ctx.messages);
|
||
return ctx.messages;
|
||
});
|
||
const _cachedMessageLoader = defineCachedFunction(_messagesHandler, {
|
||
name: "i18n:messages-internal",
|
||
maxAge: -1 ,
|
||
getKey: (event) => [getRouterParam(event, "locale") ?? "null", getRouterParam(event, "hash") ?? "null"].join("-"),
|
||
async shouldBypassCache(event) {
|
||
const locale = getRouterParam(event, "locale");
|
||
if (locale == null) {
|
||
return false;
|
||
}
|
||
const ctx = tryUseI18nContext(event) || await initializeI18nContext(event);
|
||
return !ctx.localeConfigs?.[locale]?.cacheable;
|
||
}
|
||
});
|
||
defineCachedEventHandler(_cachedMessageLoader, {
|
||
name: "i18n:messages",
|
||
maxAge: -1 ,
|
||
swr: false,
|
||
getKey: (event) => [getRouterParam(event, "locale") ?? "null", getRouterParam(event, "hash") ?? "null"].join("-")
|
||
});
|
||
const _cSDLJw = _messagesHandler ;
|
||
|
||
const VueResolver = (_, value) => {
|
||
return isRef(value) ? toValue(value) : value;
|
||
};
|
||
|
||
const headSymbol = "usehead";
|
||
// @__NO_SIDE_EFFECTS__
|
||
function vueInstall(head) {
|
||
const plugin = {
|
||
install(app) {
|
||
app.config.globalProperties.$unhead = head;
|
||
app.config.globalProperties.$head = head;
|
||
app.provide(headSymbol, head);
|
||
}
|
||
};
|
||
return plugin.install;
|
||
}
|
||
|
||
// @__NO_SIDE_EFFECTS__
|
||
function resolveUnrefHeadInput(input) {
|
||
return walkResolver(input, VueResolver);
|
||
}
|
||
|
||
function filterIslandProps(props) {
|
||
if (!props) {
|
||
return {};
|
||
}
|
||
const out = {};
|
||
for (const key in props) {
|
||
if (!key.startsWith("data-v-")) {
|
||
out[key] = props[key];
|
||
}
|
||
}
|
||
return out;
|
||
}
|
||
function computeIslandHash(name, filteredProps, context, source) {
|
||
return hash$1([name, filteredProps, context, source]).replace(/[-_]/g, "");
|
||
}
|
||
|
||
const NUXT_RUNTIME_PAYLOAD_EXTRACTION = false;
|
||
|
||
// @__NO_SIDE_EFFECTS__
|
||
function createHead(options = {}) {
|
||
const head = createHead$1({
|
||
...options,
|
||
propResolvers: [VueResolver]
|
||
});
|
||
head.install = vueInstall(head);
|
||
return head;
|
||
}
|
||
|
||
const unheadOptions = {
|
||
disableDefaults: true,
|
||
disableCapoSorting: false,
|
||
plugins: [DeprecationsPlugin, PromisesPlugin, TemplateParamsPlugin, AliasSortingPlugin],
|
||
};
|
||
|
||
function encodeEventPath(path) {
|
||
const queryIndex = path.indexOf("?");
|
||
if (queryIndex === -1) {
|
||
return encodePath(path);
|
||
}
|
||
return encodePath(path.slice(0, queryIndex)) + path.slice(queryIndex);
|
||
}
|
||
function createSSRContext(event) {
|
||
const url = encodeEventPath(event.path);
|
||
const ssrContext = {
|
||
url,
|
||
event,
|
||
runtimeConfig: useRuntimeConfig(event),
|
||
noSSR: event.context.nuxt?.noSSR || (false),
|
||
head: createHead(unheadOptions),
|
||
error: false,
|
||
nuxt: undefined,
|
||
payload: {},
|
||
["~payloadReducers"]: Object.create(null),
|
||
modules: new Set()
|
||
};
|
||
return ssrContext;
|
||
}
|
||
function setSSRError(ssrContext, error) {
|
||
ssrContext.error = true;
|
||
ssrContext.payload = { error };
|
||
ssrContext.url = error.url;
|
||
}
|
||
|
||
// @ts-expect-error private property consumed by vite-generated url helpers
|
||
globalThis.__buildAssetsURL = buildAssetsURL;
|
||
// @ts-expect-error private property consumed by vite-generated url helpers
|
||
globalThis.__publicAssetsURL = publicAssetsURL;
|
||
const APP_ROOT_OPEN_TAG = `<${appRootTag}${propsToString(appRootAttrs)}>`;
|
||
const APP_ROOT_CLOSE_TAG = `</${appRootTag}>`;
|
||
// @ts-expect-error file will be produced after app build
|
||
const getServerEntry = () => Promise.resolve().then(function () { return server; }).then((r) => r.default || r);
|
||
// @ts-expect-error file will be produced after app build
|
||
const getClientManifest = () => Promise.resolve().then(function () { return client_manifest$1; }).then((r) => r.default || r).then((r) => typeof r === "function" ? r() : r);
|
||
|
||
const getSSRRenderer = lazyCachedFunction(async () => {
|
||
|
||
const createSSRApp = await getServerEntry();
|
||
if (!createSSRApp) {
|
||
throw new Error("Server bundle is not available");
|
||
}
|
||
|
||
const precomputed = undefined ;
|
||
|
||
const renderer = createRenderer(createSSRApp, {
|
||
precomputed,
|
||
manifest: await getClientManifest() ,
|
||
renderToString: renderToString$1,
|
||
buildAssetsURL
|
||
});
|
||
async function renderToString$1(input, context) {
|
||
const html = await renderToString(input, context);
|
||
|
||
|
||
if (process.env.NUXT_VITE_NODE_OPTIONS) {
|
||
renderer.rendererContext.updateManifest(await getClientManifest());
|
||
}
|
||
return APP_ROOT_OPEN_TAG + html + APP_ROOT_CLOSE_TAG;
|
||
}
|
||
return renderer;
|
||
});
|
||
|
||
const getSPARenderer = lazyCachedFunction(async () => {
|
||
const precomputed = undefined ;
|
||
// @ts-expect-error virtual file
|
||
const spaTemplate = await Promise.resolve().then(function () { return _virtual__spaTemplate; }).then((r) => r.template).catch(() => "").then((r) => {
|
||
{
|
||
return APP_ROOT_OPEN_TAG + r + APP_ROOT_CLOSE_TAG;
|
||
}
|
||
});
|
||
|
||
const renderer = createRenderer(() => () => {}, {
|
||
precomputed,
|
||
manifest: await getClientManifest() ,
|
||
renderToString: () => spaTemplate,
|
||
buildAssetsURL
|
||
});
|
||
const result = await renderer.renderToString({});
|
||
const renderToString = (ssrContext) => {
|
||
const config = useRuntimeConfig(ssrContext.event);
|
||
ssrContext.modules ||= new Set();
|
||
ssrContext.payload.serverRendered = false;
|
||
ssrContext.config = {
|
||
public: config.public,
|
||
app: config.app
|
||
};
|
||
return Promise.resolve(result);
|
||
};
|
||
return {
|
||
rendererContext: renderer.rendererContext,
|
||
renderToString
|
||
};
|
||
});
|
||
function lazyCachedFunction(fn) {
|
||
let res = null;
|
||
return () => {
|
||
if (res === null) {
|
||
res = fn().catch((err) => {
|
||
res = null;
|
||
throw err;
|
||
});
|
||
}
|
||
return res;
|
||
};
|
||
}
|
||
function getRenderer(ssrContext) {
|
||
return ssrContext.noSSR ? getSPARenderer() : getSSRRenderer();
|
||
}
|
||
// @ts-expect-error file will be produced after app build
|
||
const getSSRStyles = lazyCachedFunction(() => Promise.resolve().then(function () { return styles$1; }).then((r) => r.default || r));
|
||
|
||
async function renderInlineStyles(usedModules) {
|
||
const styleMap = await getSSRStyles();
|
||
const inlinedStyles = new Set();
|
||
for (const mod of usedModules) {
|
||
if (mod in styleMap && styleMap[mod]) {
|
||
for (const style of await styleMap[mod]()) {
|
||
inlinedStyles.add(style);
|
||
}
|
||
}
|
||
}
|
||
return Array.from(inlinedStyles).map((style) => ({ innerHTML: style }));
|
||
}
|
||
|
||
// @ts-expect-error virtual file
|
||
const ROOT_NODE_REGEX = new RegExp(`^<${appRootTag}[^>]*>([\\s\\S]*)<\\/${appRootTag}>$`);
|
||
|
||
function getServerComponentHTML(body) {
|
||
const match = body.match(ROOT_NODE_REGEX);
|
||
return match?.[1] || body;
|
||
}
|
||
const SSR_SLOT_TELEPORT_MARKER = /^uid=([^;]*);slot=(.*)$/;
|
||
const SSR_CLIENT_TELEPORT_MARKER = /^uid=([^;]*);client=(.*)$/;
|
||
const SSR_CLIENT_SLOT_MARKER = /^island-slot=([^;]*);(.*)$/;
|
||
function getSlotIslandResponse(ssrContext) {
|
||
if (!ssrContext.islandContext || !Object.keys(ssrContext.islandContext.slots).length) {
|
||
return undefined;
|
||
}
|
||
const response = {};
|
||
for (const [name, slot] of Object.entries(ssrContext.islandContext.slots)) {
|
||
response[name] = {
|
||
...slot,
|
||
fallback: ssrContext.teleports?.[`island-fallback=${name}`]
|
||
};
|
||
}
|
||
return response;
|
||
}
|
||
function getClientIslandResponse(ssrContext) {
|
||
if (!ssrContext.islandContext || !Object.keys(ssrContext.islandContext.components).length) {
|
||
return undefined;
|
||
}
|
||
const response = {};
|
||
for (const [clientUid, component] of Object.entries(ssrContext.islandContext.components)) {
|
||
|
||
const html = ssrContext.teleports?.[clientUid]?.replaceAll("<!--teleport start anchor-->", "") || "";
|
||
response[clientUid] = {
|
||
...component,
|
||
html,
|
||
slots: getComponentSlotTeleport(clientUid, ssrContext.teleports ?? {})
|
||
};
|
||
}
|
||
return response;
|
||
}
|
||
function getComponentSlotTeleport(clientUid, teleports) {
|
||
const entries = Object.entries(teleports);
|
||
const slots = {};
|
||
for (const [key, value] of entries) {
|
||
const match = key.match(SSR_CLIENT_SLOT_MARKER);
|
||
if (match) {
|
||
const [, id, slot] = match;
|
||
if (!slot || clientUid !== id) {
|
||
continue;
|
||
}
|
||
slots[slot] = value;
|
||
}
|
||
}
|
||
return slots;
|
||
}
|
||
function replaceIslandTeleports(ssrContext, html) {
|
||
const { teleports, islandContext } = ssrContext;
|
||
if (islandContext || !teleports) {
|
||
return html;
|
||
}
|
||
for (const key in teleports) {
|
||
const matchClientComp = key.match(SSR_CLIENT_TELEPORT_MARKER);
|
||
if (matchClientComp) {
|
||
const [, uid, clientId] = matchClientComp;
|
||
if (!uid || !clientId) {
|
||
continue;
|
||
}
|
||
html = html.replace(new RegExp(` data-island-uid="${uid}" data-island-component="${clientId}"[^>]*>`), (full) => {
|
||
return full + teleports[key];
|
||
});
|
||
continue;
|
||
}
|
||
const matchSlot = key.match(SSR_SLOT_TELEPORT_MARKER);
|
||
if (matchSlot) {
|
||
const [, uid, slot] = matchSlot;
|
||
if (!uid || !slot) {
|
||
continue;
|
||
}
|
||
html = html.replace(new RegExp(` data-island-uid="${uid}" data-island-slot="${slot}"[^>]*>`), (full) => {
|
||
return full + teleports[key];
|
||
});
|
||
}
|
||
}
|
||
return html;
|
||
}
|
||
|
||
const ISLAND_SUFFIX_RE = /\.json(?:\?.*)?$/;
|
||
const handler$1 = defineEventHandler(async (event) => {
|
||
const nitroApp = useNitroApp();
|
||
setResponseHeaders(event, {
|
||
"content-type": "application/json;charset=utf-8",
|
||
"x-powered-by": "Nuxt"
|
||
});
|
||
const islandContext = await getIslandContext(event);
|
||
const ssrContext = {
|
||
...createSSRContext(event),
|
||
islandContext,
|
||
noSSR: false,
|
||
url: islandContext.url
|
||
};
|
||
|
||
const renderer = await getSSRRenderer();
|
||
const renderResult = await renderer.renderToString(ssrContext).catch(async (err) => {
|
||
if (ssrContext["~renderResponse"] && err?.message === "skipping render") {
|
||
return {};
|
||
}
|
||
await ssrContext.nuxt?.hooks.callHook("app:error", err);
|
||
throw err;
|
||
});
|
||
|
||
|
||
await ssrContext.nuxt?.hooks.callHook("app:rendered", {
|
||
ssrContext,
|
||
renderResult
|
||
});
|
||
if (ssrContext["~renderResponse"]) {
|
||
const response = ssrContext["~renderResponse"];
|
||
if (response.statusCode && response.statusCode >= 400) {
|
||
throw createError({
|
||
statusCode: response.statusCode,
|
||
statusMessage: response.statusMessage
|
||
});
|
||
}
|
||
return returnIslandResponse(event, response);
|
||
}
|
||
|
||
if (ssrContext.payload?.error) {
|
||
throw ssrContext.payload.error;
|
||
}
|
||
const inlinedStyles = await renderInlineStyles(ssrContext.modules ?? []);
|
||
if (inlinedStyles.length) {
|
||
ssrContext.head.push({ style: inlinedStyles });
|
||
}
|
||
{
|
||
const { styles } = getRequestDependencies(ssrContext, renderer.rendererContext);
|
||
const link = [];
|
||
for (const resource of Object.values(styles)) {
|
||
|
||
if ("inline" in getQuery(resource.file)) {
|
||
continue;
|
||
}
|
||
|
||
|
||
if (resource.file.includes("scoped") && !resource.file.includes("pages/")) {
|
||
link.push({
|
||
rel: "stylesheet",
|
||
href: renderer.rendererContext.buildAssetsURL(resource.file),
|
||
crossorigin: ""
|
||
});
|
||
}
|
||
}
|
||
if (link.length) {
|
||
ssrContext.head.push({ link }, { mode: "server" });
|
||
}
|
||
}
|
||
const islandHead = {};
|
||
for (const entry of ssrContext.head.entries.values()) {
|
||
|
||
for (const [key, value] of Object.entries(resolveUnrefHeadInput(entry.input))) {
|
||
const currentValue = islandHead[key];
|
||
if (Array.isArray(currentValue)) {
|
||
currentValue.push(...value);
|
||
} else {
|
||
islandHead[key] = value;
|
||
}
|
||
}
|
||
}
|
||
|
||
islandHead.link ||= [];
|
||
islandHead.style ||= [];
|
||
const islandResponse = {
|
||
id: islandContext.id,
|
||
head: islandHead,
|
||
html: getServerComponentHTML(renderResult.html),
|
||
components: getClientIslandResponse(ssrContext),
|
||
slots: getSlotIslandResponse(ssrContext)
|
||
};
|
||
await nitroApp.hooks.callHook("render:island", islandResponse, {
|
||
event,
|
||
islandContext
|
||
});
|
||
return islandResponse;
|
||
});
|
||
function returnIslandResponse(event, response) {
|
||
for (const header in response.headers || {}) {
|
||
setResponseHeader(event, header, response.headers[header]);
|
||
}
|
||
if (response.statusCode) {
|
||
setResponseStatus(event, response.statusCode, response.statusMessage);
|
||
}
|
||
return response.body;
|
||
}
|
||
const ISLAND_PATH_PREFIX = "/__nuxt_island/";
|
||
const VALID_COMPONENT_NAME_RE = /^[a-z][\w.-]*$/i;
|
||
async function getIslandContext(event) {
|
||
let url = event.path || "";
|
||
url.replace(/\?.*$/, "");
|
||
if (!url.startsWith(ISLAND_PATH_PREFIX)) {
|
||
throw createError({
|
||
statusCode: 400,
|
||
statusMessage: "Invalid island request path"
|
||
});
|
||
}
|
||
const componentParts = url.substring(ISLAND_PATH_PREFIX.length).replace(ISLAND_SUFFIX_RE, "").split("_");
|
||
const hashId = componentParts.length > 1 ? componentParts.pop() : undefined;
|
||
const componentName = componentParts.join("_");
|
||
if (!componentName || !VALID_COMPONENT_NAME_RE.test(componentName)) {
|
||
throw createError({
|
||
statusCode: 400,
|
||
statusMessage: "Invalid island component name"
|
||
});
|
||
}
|
||
const rawContext = event.method === "GET" ? getQuery$1(event) : await readBody(event);
|
||
const rawProps = destr$1(rawContext?.props) || {};
|
||
const filteredProps = filterIslandProps(rawProps);
|
||
|
||
|
||
const clientContext = {};
|
||
if (rawContext && typeof rawContext === "object") {
|
||
for (const key in rawContext) {
|
||
if (key !== "props") {
|
||
clientContext[key] = rawContext[key];
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
const expectedHash = computeIslandHash(componentName, filteredProps, clientContext, undefined);
|
||
if (!hashId || hashId !== expectedHash) {
|
||
throw createError({
|
||
statusCode: 400,
|
||
statusMessage: "Invalid island request hash"
|
||
});
|
||
}
|
||
return {
|
||
url: typeof rawContext?.url === "string" ? rawContext.url : "/",
|
||
id: hashId,
|
||
name: componentName,
|
||
props: rawProps,
|
||
slots: {},
|
||
components: {}
|
||
};
|
||
}
|
||
|
||
const _lazy_0XwxzV = () => Promise.resolve().then(function () { return renderer; });
|
||
|
||
const handlers = [
|
||
{ route: '', handler: _oStzCE, lazy: false, middleware: true, method: undefined },
|
||
{ route: '/__nuxt_error', handler: _lazy_0XwxzV, lazy: true, middleware: false, method: undefined },
|
||
{ route: '/_i18n/:hash/:locale/messages.json', handler: _cSDLJw, lazy: false, middleware: false, method: undefined },
|
||
{ route: '/__nuxt_island/**', handler: handler$1, lazy: false, middleware: false, method: undefined },
|
||
{ route: '/**', handler: _lazy_0XwxzV, lazy: true, middleware: false, method: undefined }
|
||
];
|
||
|
||
function createNitroApp() {
|
||
const config = useRuntimeConfig();
|
||
const hooks = createHooks();
|
||
const captureError = (error, context = {}) => {
|
||
const promise = hooks.callHookParallel("error", error, context).catch((error_) => {
|
||
console.error("Error while capturing another error", error_);
|
||
});
|
||
if (context.event && isEvent(context.event)) {
|
||
const errors = context.event.context.nitro?.errors;
|
||
if (errors) {
|
||
errors.push({ error, context });
|
||
}
|
||
if (context.event.waitUntil) {
|
||
context.event.waitUntil(promise);
|
||
}
|
||
}
|
||
};
|
||
const h3App = createApp({
|
||
debug: destr(true),
|
||
onError: (error, event) => {
|
||
captureError(error, { event, tags: ["request"] });
|
||
return errorHandler(error, event);
|
||
},
|
||
onRequest: async (event) => {
|
||
event.context.nitro = event.context.nitro || { errors: [] };
|
||
const fetchContext = event.node.req?.__unenv__;
|
||
if (fetchContext?._platform) {
|
||
event.context = {
|
||
_platform: fetchContext?._platform,
|
||
// #3335
|
||
...fetchContext._platform,
|
||
...event.context
|
||
};
|
||
}
|
||
if (!event.context.waitUntil && fetchContext?.waitUntil) {
|
||
event.context.waitUntil = fetchContext.waitUntil;
|
||
}
|
||
event.fetch = (req, init) => fetchWithEvent(event, req, init, { fetch: localFetch });
|
||
event.$fetch = (req, init) => fetchWithEvent(event, req, init, {
|
||
fetch: $fetch
|
||
});
|
||
event.waitUntil = (promise) => {
|
||
if (!event.context.nitro._waitUntilPromises) {
|
||
event.context.nitro._waitUntilPromises = [];
|
||
}
|
||
event.context.nitro._waitUntilPromises.push(promise);
|
||
if (event.context.waitUntil) {
|
||
event.context.waitUntil(promise);
|
||
}
|
||
};
|
||
event.captureError = (error, context) => {
|
||
captureError(error, { event, ...context });
|
||
};
|
||
await nitroApp$1.hooks.callHook("request", event).catch((error) => {
|
||
captureError(error, { event, tags: ["request"] });
|
||
});
|
||
},
|
||
onBeforeResponse: async (event, response) => {
|
||
await nitroApp$1.hooks.callHook("beforeResponse", event, response).catch((error) => {
|
||
captureError(error, { event, tags: ["request", "response"] });
|
||
});
|
||
},
|
||
onAfterResponse: async (event, response) => {
|
||
await nitroApp$1.hooks.callHook("afterResponse", event, response).catch((error) => {
|
||
captureError(error, { event, tags: ["request", "response"] });
|
||
});
|
||
}
|
||
});
|
||
const router = createRouter$1({
|
||
preemptive: true
|
||
});
|
||
const nodeHandler = toNodeListener(h3App);
|
||
const localCall = (aRequest) => callNodeRequestHandler(
|
||
nodeHandler,
|
||
aRequest
|
||
);
|
||
const localFetch = (input, init) => {
|
||
if (!input.toString().startsWith("/")) {
|
||
return globalThis.fetch(input, init);
|
||
}
|
||
return fetchNodeRequestHandler(
|
||
nodeHandler,
|
||
input,
|
||
init
|
||
).then((response) => normalizeFetchResponse(response));
|
||
};
|
||
const $fetch = createFetch({
|
||
fetch: localFetch,
|
||
Headers: Headers$1,
|
||
defaults: { baseURL: config.app.baseURL }
|
||
});
|
||
globalThis.$fetch = $fetch;
|
||
h3App.use(createRouteRulesHandler({ localFetch }));
|
||
for (const h of handlers) {
|
||
let handler = h.lazy ? lazyEventHandler(h.handler) : h.handler;
|
||
if (h.middleware || !h.route) {
|
||
const middlewareBase = (config.app.baseURL + (h.route || "/")).replace(
|
||
/\/+/g,
|
||
"/"
|
||
);
|
||
h3App.use(middlewareBase, handler);
|
||
} else {
|
||
const routeRules = getRouteRulesForPath(
|
||
h.route.replace(/:\w+|\*\*/g, "_")
|
||
);
|
||
if (routeRules.cache) {
|
||
handler = cachedEventHandler(handler, {
|
||
group: "nitro/routes",
|
||
...routeRules.cache
|
||
});
|
||
}
|
||
router.use(h.route, handler, h.method);
|
||
}
|
||
}
|
||
h3App.use(config.app.baseURL, router.handler);
|
||
const app = {
|
||
hooks,
|
||
h3App,
|
||
router,
|
||
localCall,
|
||
localFetch,
|
||
captureError
|
||
};
|
||
return app;
|
||
}
|
||
function runNitroPlugins(nitroApp2) {
|
||
for (const plugin of plugins) {
|
||
try {
|
||
plugin(nitroApp2);
|
||
} catch (error) {
|
||
nitroApp2.captureError(error, { tags: ["plugin"] });
|
||
throw error;
|
||
}
|
||
}
|
||
}
|
||
const nitroApp$1 = createNitroApp();
|
||
function useNitroApp() {
|
||
return nitroApp$1;
|
||
}
|
||
runNitroPlugins(nitroApp$1);
|
||
|
||
if (!globalThis.crypto) {
|
||
globalThis.crypto = crypto$1.webcrypto;
|
||
}
|
||
const { NITRO_NO_UNIX_SOCKET, NITRO_DEV_WORKER_ID } = process.env;
|
||
trapUnhandledNodeErrors();
|
||
parentPort?.on("message", (msg) => {
|
||
if (msg && msg.event === "shutdown") {
|
||
shutdown();
|
||
}
|
||
});
|
||
const nitroApp = useNitroApp();
|
||
const server$1 = new Server(toNodeListener(nitroApp.h3App));
|
||
let listener;
|
||
listen().catch(() => listen(
|
||
true
|
||
/* use random port */
|
||
)).catch((error) => {
|
||
console.error("Dev worker failed to listen:", error);
|
||
return shutdown();
|
||
});
|
||
nitroApp.router.get(
|
||
"/_nitro/tasks",
|
||
defineEventHandler(async (event) => {
|
||
const _tasks = await Promise.all(
|
||
Object.entries(tasks).map(async ([name, task]) => {
|
||
const _task = await task.resolve?.();
|
||
return [name, { description: _task?.meta?.description }];
|
||
})
|
||
);
|
||
return {
|
||
tasks: Object.fromEntries(_tasks),
|
||
scheduledTasks
|
||
};
|
||
})
|
||
);
|
||
nitroApp.router.use(
|
||
"/_nitro/tasks/:name",
|
||
defineEventHandler(async (event) => {
|
||
const name = getRouterParam(event, "name");
|
||
const payload = {
|
||
...getQuery$1(event),
|
||
...await readBody(event).then((r) => r?.payload).catch(() => ({}))
|
||
};
|
||
return await runTask(name, { payload });
|
||
})
|
||
);
|
||
function listen(useRandomPort = Boolean(
|
||
NITRO_NO_UNIX_SOCKET || process.versions.webcontainer || "Bun" in globalThis && process.platform === "win32"
|
||
)) {
|
||
return new Promise((resolve, reject) => {
|
||
try {
|
||
listener = server$1.listen(useRandomPort ? 0 : getSocketAddress(), () => {
|
||
const address = server$1.address();
|
||
parentPort?.postMessage({
|
||
event: "listen",
|
||
address: typeof address === "string" ? { socketPath: address } : { host: "localhost", port: address?.port }
|
||
});
|
||
resolve();
|
||
});
|
||
} catch (error) {
|
||
reject(error);
|
||
}
|
||
});
|
||
}
|
||
function getSocketAddress() {
|
||
const socketName = `nitro-worker-${process.pid}-${threadId}-${NITRO_DEV_WORKER_ID}-${Math.round(Math.random() * 1e4)}.sock`;
|
||
if (process.platform === "win32") {
|
||
return join(String.raw`\\.\pipe`, socketName);
|
||
}
|
||
if (process.platform === "linux") {
|
||
const nodeMajor = Number.parseInt(process.versions.node.split(".")[0], 10);
|
||
if (nodeMajor >= 20) {
|
||
return `\0${socketName}`;
|
||
}
|
||
}
|
||
return join(tmpdir(), socketName);
|
||
}
|
||
async function shutdown() {
|
||
server$1.closeAllConnections?.();
|
||
await Promise.all([
|
||
new Promise((resolve) => listener?.close(resolve)),
|
||
nitroApp.hooks.callHook("close").catch(console.error)
|
||
]);
|
||
parentPort?.postMessage({ event: "exit" });
|
||
}
|
||
|
||
const _messages = {
|
||
"appName": "Nuxt",
|
||
"version": "",
|
||
"status": 500,
|
||
"statusText": "Server error",
|
||
"description": "This page is temporarily unavailable."
|
||
};
|
||
const template$1 = (messages) => {
|
||
messages = {
|
||
..._messages,
|
||
...messages
|
||
};
|
||
return "<!DOCTYPE html><html lang=\"en\"><head><title>" + escapeHtml(messages.status) + " - " + escapeHtml(messages.statusText) + " | " + escapeHtml(messages.appName) + "</title><meta charset=\"utf-8\"><meta content=\"width=device-width,initial-scale=1.0,minimum-scale=1.0\" name=\"viewport\"><style>.spotlight{background:linear-gradient(45deg,#00dc82,#36e4da 50%,#0047e1);filter:blur(20vh)}*,:after,:before{border-color:var(--un-default-border-color,#e5e7eb);border-style:solid;border-width:0;box-sizing:border-box}:after,:before{--un-content:\"\"}html{line-height:1.5;-webkit-text-size-adjust:100%;font-family:ui-sans-serif,system-ui,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji;font-feature-settings:normal;font-variation-settings:normal;-moz-tab-size:4;tab-size:4;-webkit-tap-highlight-color:transparent}body{line-height:inherit;margin:0}h1{font-size:inherit;font-weight:inherit}h1,p{margin:0}*,:after,:before{--un-rotate:0;--un-rotate-x:0;--un-rotate-y:0;--un-rotate-z:0;--un-scale-x:1;--un-scale-y:1;--un-scale-z:1;--un-skew-x:0;--un-skew-y:0;--un-translate-x:0;--un-translate-y:0;--un-translate-z:0;--un-pan-x: ;--un-pan-y: ;--un-pinch-zoom: ;--un-scroll-snap-strictness:proximity;--un-ordinal: ;--un-slashed-zero: ;--un-numeric-figure: ;--un-numeric-spacing: ;--un-numeric-fraction: ;--un-border-spacing-x:0;--un-border-spacing-y:0;--un-ring-offset-shadow:0 0 transparent;--un-ring-shadow:0 0 transparent;--un-shadow-inset: ;--un-shadow:0 0 transparent;--un-ring-inset: ;--un-ring-offset-width:0px;--un-ring-offset-color:#fff;--un-ring-width:0px;--un-ring-color:rgba(147,197,253,.5);--un-blur: ;--un-brightness: ;--un-contrast: ;--un-drop-shadow: ;--un-grayscale: ;--un-hue-rotate: ;--un-invert: ;--un-saturate: ;--un-sepia: ;--un-backdrop-blur: ;--un-backdrop-brightness: ;--un-backdrop-contrast: ;--un-backdrop-grayscale: ;--un-backdrop-hue-rotate: ;--un-backdrop-invert: ;--un-backdrop-opacity: ;--un-backdrop-saturate: ;--un-backdrop-sepia: }.fixed{position:fixed}.-bottom-1\\/2{bottom:-50%}.left-0{left:0}.right-0{right:0}.grid{display:grid}.mb-16{margin-bottom:4rem}.mb-8{margin-bottom:2rem}.h-1\\/2{height:50%}.max-w-520px{max-width:520px}.min-h-screen{min-height:100vh}.place-content-center{place-content:center}.overflow-hidden{overflow:hidden}.bg-white{--un-bg-opacity:1;background-color:rgb(255 255 255/var(--un-bg-opacity))}.px-8{padding-left:2rem;padding-right:2rem}.text-center{text-align:center}.text-8xl{font-size:6rem;line-height:1}.text-xl{font-size:1.25rem;line-height:1.75rem}.text-black{--un-text-opacity:1;color:rgb(0 0 0/var(--un-text-opacity))}.font-light{font-weight:300}.font-medium{font-weight:500}.leading-tight{line-height:1.25}.font-sans{font-family:ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,Noto Sans,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji}.antialiased{-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}@media(prefers-color-scheme:dark){.dark\\:bg-black{--un-bg-opacity:1;background-color:rgb(0 0 0/var(--un-bg-opacity))}.dark\\:text-white{--un-text-opacity:1;color:rgb(255 255 255/var(--un-text-opacity))}}@media(min-width:640px){.sm\\:px-0{padding-left:0;padding-right:0}.sm\\:text-4xl{font-size:2.25rem;line-height:2.5rem}}</style><script>!function(){const e=document.createElement(\"link\").relList;if(!(e&&e.supports&&e.supports(\"modulepreload\"))){for(const e of document.querySelectorAll('link[rel=\"modulepreload\"]'))r(e);new MutationObserver(e=>{for(const o of e)if(\"childList\"===o.type)for(const e of o.addedNodes)\"LINK\"===e.tagName&&\"modulepreload\"===e.rel&&r(e)}).observe(document,{childList:!0,subtree:!0})}function r(e){if(e.ep)return;e.ep=!0;const r=function(e){const r={};return e.integrity&&(r.integrity=e.integrity),e.referrerPolicy&&(r.referrerPolicy=e.referrerPolicy),\"use-credentials\"===e.crossOrigin?r.credentials=\"include\":\"anonymous\"===e.crossOrigin?r.credentials=\"omit\":r.credentials=\"same-origin\",r}(e);fetch(e.href,r)}}();<\/script></head><body class=\"antialiased bg-white dark:bg-black dark:text-white font-sans grid min-h-screen overflow-hidden place-content-center text-black\"><div class=\"-bottom-1/2 fixed h-1/2 left-0 right-0 spotlight\"></div><div class=\"max-w-520px text-center\"><h1 class=\"font-medium mb-8 sm:text-10xl text-8xl\">" + escapeHtml(messages.status) + "</h1><p class=\"font-light leading-tight mb-16 px-8 sm:px-0 sm:text-4xl text-xl\">" + escapeHtml(messages.description) + "</p></div></body></html>";
|
||
};
|
||
|
||
const error500 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
|
||
__proto__: null,
|
||
template: template$1
|
||
}, Symbol.toStringTag, { value: 'Module' }));
|
||
|
||
const server = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
|
||
__proto__: null,
|
||
default: viteNodeEntry_mjs
|
||
}, Symbol.toStringTag, { value: 'Module' }));
|
||
|
||
const client_manifest = () => viteNodeFetch.getManifest();
|
||
|
||
const client_manifest$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
|
||
__proto__: null,
|
||
default: client_manifest
|
||
}, Symbol.toStringTag, { value: 'Module' }));
|
||
|
||
const template = "";
|
||
|
||
const _virtual__spaTemplate = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
|
||
__proto__: null,
|
||
template: template
|
||
}, Symbol.toStringTag, { value: 'Module' }));
|
||
|
||
const styles = {};
|
||
|
||
const styles$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
|
||
__proto__: null,
|
||
default: styles
|
||
}, Symbol.toStringTag, { value: 'Module' }));
|
||
|
||
function renderPayloadResponse(ssrContext) {
|
||
return {
|
||
body: encodeForwardSlashes(stringify(splitPayload(ssrContext).payload, ssrContext["~payloadReducers"])) ,
|
||
statusCode: getResponseStatus(ssrContext.event),
|
||
statusMessage: getResponseStatusText(ssrContext.event),
|
||
headers: {
|
||
"content-type": "application/json;charset=utf-8" ,
|
||
"x-powered-by": "Nuxt"
|
||
}
|
||
};
|
||
}
|
||
function renderPayloadJsonScript(opts) {
|
||
const contents = opts.data ? encodeForwardSlashes(stringify(opts.data, opts.ssrContext["~payloadReducers"])) : "";
|
||
const payload = {
|
||
"type": "application/json",
|
||
"innerHTML": contents,
|
||
"data-nuxt-data": appId,
|
||
"data-ssr": !(opts.ssrContext.noSSR)
|
||
};
|
||
{
|
||
payload.id = "__NUXT_DATA__";
|
||
}
|
||
if (opts.src) {
|
||
payload["data-src"] = opts.src;
|
||
}
|
||
const config = uneval(opts.ssrContext.config);
|
||
return [payload, { innerHTML: `window.__NUXT__={};window.__NUXT__.config=${config}` }];
|
||
}
|
||
|
||
function encodeForwardSlashes(str) {
|
||
return str.replaceAll("/", "\\u002F");
|
||
}
|
||
function splitPayload(ssrContext) {
|
||
const { data, prerenderedAt, ...initial } = ssrContext.payload;
|
||
return {
|
||
initial: {
|
||
...initial,
|
||
prerenderedAt
|
||
},
|
||
payload: {
|
||
data,
|
||
prerenderedAt
|
||
}
|
||
};
|
||
}
|
||
|
||
const renderSSRHeadOptions = {"omitLineBreaks":false};
|
||
|
||
// @ts-expect-error private property consumed by vite-generated url helpers
|
||
globalThis.__buildAssetsURL = buildAssetsURL;
|
||
// @ts-expect-error private property consumed by vite-generated url helpers
|
||
globalThis.__publicAssetsURL = publicAssetsURL;
|
||
const HAS_APP_TELEPORTS = !!(appTeleportAttrs.id);
|
||
const APP_TELEPORT_OPEN_TAG = HAS_APP_TELEPORTS ? `<${appTeleportTag}${propsToString(appTeleportAttrs)}>` : "";
|
||
const APP_TELEPORT_CLOSE_TAG = HAS_APP_TELEPORTS ? `</${appTeleportTag}>` : "";
|
||
const PAYLOAD_URL_RE = /^[^?]*\/_payload.json(?:\?.*)?$/ ;
|
||
const handler = defineRenderHandler((event) => {
|
||
|
||
const ssrError = event.path.startsWith("/__nuxt_error") ? getQuery$1(event) : null;
|
||
if (ssrError && !("__unenv__" in event.node.req)) {
|
||
throw createError({
|
||
status: 404,
|
||
statusText: "Page Not Found: /__nuxt_error",
|
||
message: "Page Not Found: /__nuxt_error"
|
||
});
|
||
}
|
||
return renderRoute(event, ssrError);
|
||
});
|
||
async function renderRoute(event, ssrError) {
|
||
const nitroApp = useNitroApp();
|
||
|
||
const ssrContext = createSSRContext(event);
|
||
|
||
const headEntryOptions = { mode: "server" };
|
||
ssrContext.head.push(appHead, headEntryOptions);
|
||
if (ssrError) {
|
||
|
||
const status = ssrError.status || ssrError.statusCode;
|
||
if (status) {
|
||
|
||
ssrError.status = ssrError.statusCode = Number.parseInt(status);
|
||
}
|
||
setSSRError(ssrContext, ssrError);
|
||
}
|
||
|
||
const routeOptions = getRouteRules(event);
|
||
if (routeOptions.ssr === false) {
|
||
ssrContext.noSSR = true;
|
||
}
|
||
|
||
!ssrContext.noSSR && (NUXT_RUNTIME_PAYLOAD_EXTRACTION);
|
||
const isRenderingPayload = (routeOptions.prerender) && PAYLOAD_URL_RE.test(ssrContext.url);
|
||
if (isRenderingPayload) {
|
||
const url = ssrContext.url.substring(0, ssrContext.url.lastIndexOf("/")) || "/";
|
||
ssrContext.url = url;
|
||
event._path = event.node.req.url = url;
|
||
}
|
||
|
||
const renderer = await getRenderer(ssrContext);
|
||
const _rendered = await renderer.renderToString(ssrContext).catch(async (error) => {
|
||
|
||
|
||
if ((ssrContext["~renderResponse"] || ssrContext._renderResponse) && error.message === "skipping render") {
|
||
return {};
|
||
}
|
||
|
||
const _err = !ssrError && ssrContext.payload?.error || error;
|
||
await ssrContext.nuxt?.hooks.callHook("app:error", _err);
|
||
throw _err;
|
||
});
|
||
|
||
|
||
const inlinedStyles = [];
|
||
await ssrContext.nuxt?.hooks.callHook("app:rendered", {
|
||
ssrContext,
|
||
renderResult: _rendered
|
||
});
|
||
if (ssrContext["~renderResponse"] || ssrContext._renderResponse) {
|
||
|
||
return ssrContext["~renderResponse"] || ssrContext._renderResponse;
|
||
}
|
||
|
||
if (ssrContext.payload?.error && !ssrError) {
|
||
throw ssrContext.payload.error;
|
||
}
|
||
|
||
if (isRenderingPayload) {
|
||
const response = renderPayloadResponse(ssrContext);
|
||
return response;
|
||
}
|
||
const NO_SCRIPTS = routeOptions.noScripts;
|
||
|
||
const { styles, scripts } = getRequestDependencies(ssrContext, renderer.rendererContext);
|
||
if (ssrContext["~preloadManifest"] && !NO_SCRIPTS) {
|
||
ssrContext.head.push({ link: [{
|
||
rel: "preload",
|
||
as: "fetch",
|
||
fetchpriority: "low",
|
||
crossorigin: "anonymous",
|
||
href: buildAssetsURL(`builds/meta/${ssrContext.runtimeConfig.app.buildId}.json`)
|
||
}] }, {
|
||
...headEntryOptions,
|
||
tagPriority: "low"
|
||
});
|
||
}
|
||
|
||
if (inlinedStyles.length) {
|
||
ssrContext.head.push({ style: inlinedStyles });
|
||
}
|
||
const link = [];
|
||
for (const resource of Object.values(styles)) {
|
||
|
||
if ("inline" in getQuery(resource.file)) {
|
||
continue;
|
||
}
|
||
|
||
|
||
|
||
link.push({
|
||
rel: "stylesheet",
|
||
href: renderer.rendererContext.buildAssetsURL(resource.file),
|
||
crossorigin: ""
|
||
});
|
||
}
|
||
if (link.length) {
|
||
ssrContext.head.push({ link }, headEntryOptions);
|
||
}
|
||
if (!NO_SCRIPTS) {
|
||
|
||
|
||
|
||
if (ssrContext["~lazyHydratedModules"]) {
|
||
for (const id of ssrContext["~lazyHydratedModules"]) {
|
||
ssrContext.modules?.delete(id);
|
||
}
|
||
}
|
||
|
||
ssrContext.head.push({ link: getPreloadLinks(ssrContext, renderer.rendererContext) }, headEntryOptions);
|
||
ssrContext.head.push({ link: getPrefetchLinks(ssrContext, renderer.rendererContext) }, headEntryOptions);
|
||
|
||
ssrContext.head.push({ script: renderPayloadJsonScript({
|
||
ssrContext,
|
||
data: ssrContext.payload
|
||
}) }, {
|
||
...headEntryOptions,
|
||
|
||
tagPosition: "bodyClose",
|
||
tagPriority: "high"
|
||
});
|
||
}
|
||
|
||
if (!routeOptions.noScripts) {
|
||
const tagPosition = "head";
|
||
ssrContext.head.push({ script: Object.values(scripts).map((resource) => ({
|
||
type: resource.module ? "module" : null,
|
||
src: renderer.rendererContext.buildAssetsURL(resource.file),
|
||
defer: resource.module ? null : true,
|
||
|
||
|
||
tagPosition,
|
||
crossorigin: ""
|
||
})) }, headEntryOptions);
|
||
}
|
||
const { headTags, bodyTags, bodyTagsOpen, htmlAttrs, bodyAttrs } = await renderSSRHead(ssrContext.head, renderSSRHeadOptions);
|
||
|
||
const htmlContext = {
|
||
htmlAttrs: htmlAttrs ? [htmlAttrs] : [],
|
||
head: normalizeChunks([headTags]),
|
||
bodyAttrs: bodyAttrs ? [bodyAttrs] : [],
|
||
bodyPrepend: normalizeChunks([bodyTagsOpen, ssrContext.teleports?.body]),
|
||
body: [replaceIslandTeleports(ssrContext, _rendered.html) , APP_TELEPORT_OPEN_TAG + (HAS_APP_TELEPORTS ? joinTags([ssrContext.teleports?.[`#${appTeleportAttrs.id}`]]) : "") + APP_TELEPORT_CLOSE_TAG],
|
||
bodyAppend: [bodyTags]
|
||
};
|
||
|
||
await nitroApp.hooks.callHook("render:html", htmlContext, { event });
|
||
|
||
return {
|
||
body: renderHTMLDocument(htmlContext),
|
||
statusCode: getResponseStatus(event),
|
||
statusMessage: getResponseStatusText(event),
|
||
headers: {
|
||
"content-type": "text/html;charset=utf-8",
|
||
"x-powered-by": "Nuxt"
|
||
}
|
||
};
|
||
}
|
||
function normalizeChunks(chunks) {
|
||
const result = [];
|
||
for (const _chunk of chunks) {
|
||
const chunk = _chunk?.trim();
|
||
if (chunk) {
|
||
result.push(chunk);
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
function joinTags(tags) {
|
||
return tags.join("");
|
||
}
|
||
function joinAttrs(chunks) {
|
||
if (chunks.length === 0) {
|
||
return "";
|
||
}
|
||
return " " + chunks.join(" ");
|
||
}
|
||
function renderHTMLDocument(html) {
|
||
return "<!DOCTYPE html>" + `<html${joinAttrs(html.htmlAttrs)}>` + `<head>${joinTags(html.head)}</head>` + `<body${joinAttrs(html.bodyAttrs)}>${joinTags(html.bodyPrepend)}${joinTags(html.body)}${joinTags(html.bodyAppend)}</body>` + "</html>";
|
||
}
|
||
|
||
const renderer = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
|
||
__proto__: null,
|
||
default: handler
|
||
}, Symbol.toStringTag, { value: 'Module' }));
|
||
//# sourceMappingURL=index.mjs.map
|