10010 lines
326 KiB
JavaScript
10010 lines
326 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$e = (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$e();
|
|
}
|
|
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$e(null);
|
|
deepCopy(value, obj[key]);
|
|
return true;
|
|
}
|
|
});
|
|
async function loadVueI18nOptions(vueI18nConfigs) {
|
|
const nuxtApp = __nuxtMock;
|
|
let vueI18nOptions = { messages: create$e(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$e(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 loading$F = "Betöltés...";
|
|
var saving$f = "Mentés...";
|
|
var error$r = "Hiba történt";
|
|
var retry$z = "Újra";
|
|
var save$p = "Mentés";
|
|
var saving_data$1 = "Adatok mentése...";
|
|
var cancel$l = "Mégsem";
|
|
var discard$3 = "Elvetés";
|
|
var delete_confirm$7 = "Biztosan törölni szeretnéd ezt az elemet?";
|
|
var delete_btn$7 = "Törlés";
|
|
var delete_title$7 = "Törlés Megerősítése";
|
|
var deleted$5 = "Sikeresen törölve";
|
|
var edit$f = "Szerkesztés";
|
|
var edit_title$h = "Elem Szerkesztése";
|
|
var create$d = "Létrehozás";
|
|
var create_btn$7 = "Létrehozás";
|
|
var create_title$d = "Új Létrehozása";
|
|
var create_first$7 = "Hozd létre az első elemet a kezdéshez";
|
|
var search$5 = "Keresés";
|
|
var search_placeholder$9 = "Keresés...";
|
|
var filter$5 = "Szűrés";
|
|
var no_results$d = "Nincs találat";
|
|
var no_results_hint$5 = "Próbáld módosítani a keresési vagy szűrési feltételeket";
|
|
var no_items$d = "Nincsenek elemek";
|
|
var actions$l = "Műveletek";
|
|
var status$h = "Státusz";
|
|
var active$9 = "Aktív";
|
|
var inactive$9 = "Inaktív";
|
|
var activate$7 = "Aktiválás";
|
|
var deactivate$5 = "Deaktiválás";
|
|
var name$d = "Név";
|
|
var name_placeholder$7 = "Add meg a nevet";
|
|
var description$7 = "Leírás";
|
|
var desc_placeholder$5 = "Add meg a leírást";
|
|
var details$9 = "Részletek";
|
|
var email$9 = "E-mail";
|
|
var id$7 = "Azonosító";
|
|
var type$3 = "Típus";
|
|
var type_corporate$5 = "Vállalati";
|
|
var view$7 = "Megtekintés";
|
|
var updated$f = "Sikeresen frissítve";
|
|
var save_error$f = "Sikertelen mentés";
|
|
var invalid_json$7 = "Érvénytelen JSON formátum";
|
|
var prev$b = "Előző";
|
|
var next$b = "Következő";
|
|
var none$5 = "Nincs";
|
|
var reset$5 = "Visszaállítás";
|
|
var confirm$1 = "Megerősítés";
|
|
var close$1 = "Bezárás";
|
|
var back$7 = "Vissza";
|
|
var exit$1 = "Kilépés";
|
|
var all$1 = "Minden";
|
|
var select_all$3 = "Összes kiválasztása";
|
|
var deselect_all$3 = "Összes elrejtése";
|
|
var expires$5 = "Lejárat";
|
|
var created$7 = "Létrehozva";
|
|
var start_date$5 = "Kezdő Dátum";
|
|
var end_date$5 = "Befejező Dátum";
|
|
var points$d = "Pontok";
|
|
var level$b = "Szint";
|
|
var user$5 = "Felhasználó";
|
|
var user_id$7 = "Felhasználó Azonosító";
|
|
var services$7 = "Szolgáltatások";
|
|
var discoveries$5 = "Felfedezések";
|
|
var restriction$5 = "Korlátozás";
|
|
var restriction_mild$5 = "Enyhe";
|
|
var restriction_moderate$5 = "Mérsékelt";
|
|
var restriction_severe$5 = "Súlyos";
|
|
var min_xp$5 = "Min XP";
|
|
var xp$9 = "XP";
|
|
var penalty$9 = "Büntetés";
|
|
var feature_flags$5 = "Funkció Kapcsolók";
|
|
var permission$3 = "Engedély";
|
|
var role$5 = "Szerepkör";
|
|
var domain$1 = "Tartomány";
|
|
var action$3 = "Művelet";
|
|
var value$3 = "Érték";
|
|
var key$3 = "Kulcs";
|
|
var enabled$1 = "Bekapcsolva";
|
|
var disabled$1 = "Kikapcsolva";
|
|
var yes$1 = "Igen";
|
|
var no$3 = "Nem";
|
|
var on$1 = "Be";
|
|
var off$1 = "Ki";
|
|
var service_finder$1 = "Service Finder";
|
|
var admin$1 = "Admin";
|
|
var version$1 = "Verzió";
|
|
var super_administrator$1 = "Szuper Adminisztrátor";
|
|
var administrator$1 = "Adminisztrátor";
|
|
var profile_settings$1 = "Profil Beállítások";
|
|
var sign_out$1 = "Kijelentkezés";
|
|
var unknown_user$1 = "Ismeretlen felhasználó";
|
|
var ascending$3 = "Növekvő";
|
|
var descending$3 = "Csökkenő";
|
|
const locale_common_46json_68c48c8a = {
|
|
loading: loading$F,
|
|
saving: saving$f,
|
|
error: error$r,
|
|
retry: retry$z,
|
|
save: save$p,
|
|
saving_data: saving_data$1,
|
|
cancel: cancel$l,
|
|
discard: discard$3,
|
|
"delete": "Törlés",
|
|
delete_confirm: delete_confirm$7,
|
|
delete_btn: delete_btn$7,
|
|
delete_title: delete_title$7,
|
|
deleted: deleted$5,
|
|
edit: edit$f,
|
|
edit_title: edit_title$h,
|
|
create: create$d,
|
|
create_btn: create_btn$7,
|
|
create_title: create_title$d,
|
|
create_first: create_first$7,
|
|
search: search$5,
|
|
search_placeholder: search_placeholder$9,
|
|
filter: filter$5,
|
|
no_results: no_results$d,
|
|
no_results_hint: no_results_hint$5,
|
|
no_items: no_items$d,
|
|
actions: actions$l,
|
|
status: status$h,
|
|
active: active$9,
|
|
inactive: inactive$9,
|
|
activate: activate$7,
|
|
deactivate: deactivate$5,
|
|
name: name$d,
|
|
name_placeholder: name_placeholder$7,
|
|
description: description$7,
|
|
desc_placeholder: desc_placeholder$5,
|
|
details: details$9,
|
|
email: email$9,
|
|
id: id$7,
|
|
type: type$3,
|
|
type_corporate: type_corporate$5,
|
|
view: view$7,
|
|
updated: updated$f,
|
|
save_error: save_error$f,
|
|
invalid_json: invalid_json$7,
|
|
prev: prev$b,
|
|
next: next$b,
|
|
none: none$5,
|
|
reset: reset$5,
|
|
confirm: confirm$1,
|
|
close: close$1,
|
|
back: back$7,
|
|
"continue": "Tovább",
|
|
exit: exit$1,
|
|
all: all$1,
|
|
select_all: select_all$3,
|
|
deselect_all: deselect_all$3,
|
|
expires: expires$5,
|
|
created: created$7,
|
|
start_date: start_date$5,
|
|
end_date: end_date$5,
|
|
points: points$d,
|
|
level: level$b,
|
|
user: user$5,
|
|
user_id: user_id$7,
|
|
services: services$7,
|
|
discoveries: discoveries$5,
|
|
restriction: restriction$5,
|
|
restriction_mild: restriction_mild$5,
|
|
restriction_moderate: restriction_moderate$5,
|
|
restriction_severe: restriction_severe$5,
|
|
min_xp: min_xp$5,
|
|
xp: xp$9,
|
|
penalty: penalty$9,
|
|
feature_flags: feature_flags$5,
|
|
permission: permission$3,
|
|
role: role$5,
|
|
domain: domain$1,
|
|
action: action$3,
|
|
value: value$3,
|
|
key: key$3,
|
|
enabled: enabled$1,
|
|
disabled: disabled$1,
|
|
yes: yes$1,
|
|
no: no$3,
|
|
on: on$1,
|
|
off: off$1,
|
|
service_finder: service_finder$1,
|
|
admin: admin$1,
|
|
version: version$1,
|
|
super_administrator: super_administrator$1,
|
|
administrator: administrator$1,
|
|
profile_settings: profile_settings$1,
|
|
sign_out: sign_out$1,
|
|
unknown_user: unknown_user$1,
|
|
ascending: ascending$3,
|
|
descending: descending$3
|
|
};
|
|
|
|
var center$1 = "Központ";
|
|
var dashboard$1 = "Dashboard";
|
|
var providers$1 = "Szolgáltatók";
|
|
var providers_title$1 = "Szolgáltatók";
|
|
var all_providers$1 = "Összes szolgáltató";
|
|
var pending_providers$1 = "Jóváhagyásra váró";
|
|
var users_and_partners$1 = "Felhasználók & Partnerek";
|
|
var garages$3 = "Garázsok";
|
|
var garage_list$1 = "Garázsok listája";
|
|
var users$1 = "Felhasználók";
|
|
var user_list$1 = "Felhasználók listája";
|
|
var persons$1 = "Személyek";
|
|
var finance$1 = "Pénzügyek";
|
|
var packages$1 = "Csomagok";
|
|
var gamification$1 = "Gamification";
|
|
var game_settings$1 = "Játékmenet Beállítások";
|
|
var point_rules$1 = "Pontszabályok";
|
|
var levels$1 = "Szintek";
|
|
var badges$1 = "Kitüntetések";
|
|
var validation_rules$1 = "Validációs Szabályok";
|
|
var events_and_seasons$1 = "Események & Szezonok";
|
|
var seasons$1 = "Szezonok";
|
|
var competitions$1 = "Versenyek";
|
|
var user_data$1 = "Felhasználói Adatok";
|
|
var statistics$1 = "Statisztikák";
|
|
var leaderboard$1 = "Ranglista";
|
|
var points_ledger$1 = "Pontnapló";
|
|
var gamification_hq$1 = "Gamification HQ";
|
|
var system_config$1 = "Rendszer Konfig";
|
|
var system_parameters$1 = "Rendszerparaméterek";
|
|
var system$1 = "Rendszer";
|
|
var permissions$1 = "Jogosultságok";
|
|
var system_logs$1 = "Rendszernaplók";
|
|
const locale_menu_46json_d8dcbc3e = {
|
|
center: center$1,
|
|
dashboard: dashboard$1,
|
|
providers: providers$1,
|
|
providers_title: providers_title$1,
|
|
all_providers: all_providers$1,
|
|
pending_providers: pending_providers$1,
|
|
users_and_partners: users_and_partners$1,
|
|
garages: garages$3,
|
|
garage_list: garage_list$1,
|
|
users: users$1,
|
|
user_list: user_list$1,
|
|
persons: persons$1,
|
|
finance: finance$1,
|
|
packages: packages$1,
|
|
gamification: gamification$1,
|
|
game_settings: game_settings$1,
|
|
point_rules: point_rules$1,
|
|
levels: levels$1,
|
|
badges: badges$1,
|
|
validation_rules: validation_rules$1,
|
|
events_and_seasons: events_and_seasons$1,
|
|
seasons: seasons$1,
|
|
competitions: competitions$1,
|
|
user_data: user_data$1,
|
|
statistics: statistics$1,
|
|
leaderboard: leaderboard$1,
|
|
points_ledger: points_ledger$1,
|
|
gamification_hq: gamification_hq$1,
|
|
system_config: system_config$1,
|
|
system_parameters: system_parameters$1,
|
|
system: system$1,
|
|
permissions: permissions$1,
|
|
system_logs: system_logs$1
|
|
};
|
|
|
|
var title$D = "Szolgáltatók";
|
|
var subtitle$x = "Szolgáltatók listázása, keresése és moderálása";
|
|
var loading$E = "Szolgáltatók betöltése...";
|
|
var error$q = "Hiba történt a szolgáltatók betöltése közben.";
|
|
var retry$y = "Újrapróbálkozás";
|
|
var stats_total$1 = "Összes";
|
|
var stats_pending$1 = "Függőben";
|
|
var stats_approved$1 = "Jóváhagyott";
|
|
var stats_rejected$1 = "Elutasított";
|
|
var stats_flagged$1 = "Megjelölt";
|
|
var search_placeholder$8 = "Keresés név alapján...";
|
|
var filter_all_status$1 = "Minden státusz";
|
|
var filter_pending$1 = "Függőben";
|
|
var filter_approved$1 = "Jóváhagyott";
|
|
var filter_rejected$1 = "Elutasított";
|
|
var filter_flagged$1 = "Megjelölt";
|
|
var filter_all_sources$1 = "Minden forrás";
|
|
var source_manual$1 = "Kézi";
|
|
var source_ocr$1 = "OCR";
|
|
var source_import$1 = "Import";
|
|
var source_bot$1 = "Bot (Staging)";
|
|
var source_verified_org$1 = "Szervezet";
|
|
var sort_created_at$1 = "Létrehozás dátuma";
|
|
var sort_name$1 = "Név";
|
|
var sort_validation_score$1 = "Validációs pontszám";
|
|
var col_id$1 = "ID";
|
|
var col_name$1 = "Név";
|
|
var col_address$1 = "Cím";
|
|
var col_status$1 = "Státusz";
|
|
var col_source$1 = "Forrás";
|
|
var col_validation$1 = "Validáció";
|
|
var col_created$1 = "Létrehozva";
|
|
var col_actions$1 = "Műveletek";
|
|
var no_providers$1 = "Nincs megjeleníthető szolgáltató.";
|
|
var results_count$1 = "{count} találat (összesen: {total})";
|
|
var page$1 = "{page}. oldal";
|
|
var view_details$3 = "Részletek";
|
|
var status_pending$1 = "Függőben";
|
|
var status_approved$1 = "Jóváhagyott";
|
|
var status_rejected$1 = "Elutasított";
|
|
var status_flagged$1 = "Megjelölt";
|
|
var provider_detail$1 = "Szolgáltató részletek";
|
|
var detail_loading$1 = "Szolgáltató betöltése...";
|
|
var detail_not_found$1 = "A szolgáltató nem található.";
|
|
var detail_back$1 = "Vissza a szolgáltatókhoz";
|
|
var detail_provider_number$1 = "Szolgáltató #{id}";
|
|
var detail_raw_data$1 = "Nyers adatok";
|
|
var detail_tab_data$1 = "Adatok";
|
|
var detail_tab_status$1 = "Státusz";
|
|
var detail_tab_validations$1 = "Validációk";
|
|
var detail_tab_crawler$1 = "Crawler / Nyers Adatok";
|
|
var detail_tab_history$1 = "Előzmények";
|
|
var detail_section_basic$1 = "Alapadatok";
|
|
var detail_section_address$1 = "Cím adatok";
|
|
var detail_section_contact$1 = "Elérhetőség";
|
|
var detail_section_services$1 = "Szolgáltatások";
|
|
var detail_section_vehicle_classes$1 = "Járműosztályok";
|
|
var detail_section_specializations$1 = "Specializációk";
|
|
var detail_section_opening_hours$1 = "Nyitvatartás";
|
|
var detail_section_evidence$1 = "Bizonyíték kép";
|
|
var detail_section_moderation$1 = "Moderációs műveletek";
|
|
var detail_section_status_management$1 = "Státusz kezelés";
|
|
var detail_section_validation_score$1 = "Validációs Pontszám";
|
|
var detail_section_gamification_validations$1 = "Gamification Validációk";
|
|
var detail_section_crawler_data$1 = "Crawler / Nyers Adatok";
|
|
var detail_section_history$1 = "Állapotváltoztatások előzményei";
|
|
var detail_field_name$1 = "Név";
|
|
var detail_field_category$1 = "Kategória";
|
|
var detail_field_source$1 = "Forrás";
|
|
var detail_field_validation_score$1 = "Validációs pontszám";
|
|
var detail_field_created$1 = "Létrehozva";
|
|
var detail_field_submitted_by$1 = "Beküldő user ID";
|
|
var detail_field_full_address$1 = "Teljes cím";
|
|
var detail_field_city$1 = "Város";
|
|
var detail_field_zip$1 = "Irányítószám";
|
|
var detail_field_street$1 = "Utca";
|
|
var detail_field_house_number$1 = "Házszám";
|
|
var detail_field_plus_code$1 = "Plus Code";
|
|
var detail_field_phone$1 = "Telefon";
|
|
var detail_field_email$1 = "Email";
|
|
var detail_field_website$1 = "Weboldal";
|
|
var detail_no_categories$1 = "Nincsenek kategóriák beállítva";
|
|
var detail_no_vehicle_classes$1 = "Nincsenek járműosztályok beállítva";
|
|
var detail_no_specializations$1 = "Nincsenek specializációk beállítva";
|
|
var detail_no_opening_hours$1 = "Nincs beállítva nyitvatartás";
|
|
var detail_day_monday$1 = "Hétfő";
|
|
var detail_day_tuesday$1 = "Kedd";
|
|
var detail_day_wednesday$1 = "Szerda";
|
|
var detail_day_thursday$1 = "Csütörtök";
|
|
var detail_day_friday$1 = "Péntek";
|
|
var detail_day_saturday$1 = "Szombat";
|
|
var detail_day_sunday$1 = "Vasárnap";
|
|
var detail_day_label$1 = "Nap";
|
|
var detail_hours_label$1 = "Nyitva";
|
|
var detail_closed$1 = "Zárva";
|
|
var detail_specialization_brands$1 = "Márkák";
|
|
var detail_specialization_propulsion$1 = "Hajtáslánc";
|
|
var detail_status_approved$1 = "Jóváhagyva";
|
|
var detail_status_pending$1 = "Függőben";
|
|
var detail_status_research$1 = "Kutatás folyamatban";
|
|
var detail_status_rejected$1 = "Elutasítva";
|
|
var detail_status_unknown$1 = "Ismeretlen";
|
|
var detail_status_desc_approved$1 = "A szolgáltató aktív és látható a felhasználók számára.";
|
|
var detail_status_desc_pending$1 = "A szolgáltató még nem lett jóváhagyva, moderálásra vár.";
|
|
var detail_status_desc_research$1 = "A szolgáltató adatai még feldolgozás alatt állnak, automatikus kutatás folyik.";
|
|
var detail_status_desc_rejected$1 = "A szolgáltató elutasításra került, nem látható a felhasználók számára.";
|
|
var detail_edit$1 = "Szerkesztés";
|
|
var detail_approve$1 = "Jóváhagyás";
|
|
var detail_reject$1 = "Elutasítás";
|
|
var detail_flag$1 = "Megjelölés (Flag)";
|
|
var detail_delete$1 = "Törlés (Soft Delete)";
|
|
var detail_restore$1 = "Visszaállítás";
|
|
var detail_status_rejected_or_flagged$1 = "A szolgáltató {status} került.";
|
|
var detail_status_rejected_text$1 = "elutasításra";
|
|
var detail_status_flagged_text$1 = "megjelölésre";
|
|
var detail_status_form_label$1 = "Státusz";
|
|
var detail_status_form_score$1 = "Validációs pontszám (0-100)";
|
|
var detail_status_form_reason$1 = "Indoklás (opcionális)";
|
|
var detail_status_form_reason_placeholder$1 = "Add meg a státuszváltoztatás okát...";
|
|
var detail_status_form_cancel$1 = "Mégsem";
|
|
var detail_status_form_save$1 = "Státusz mentése";
|
|
var detail_validation_score_excellent$1 = "Kiváló";
|
|
var detail_validation_score_medium$1 = "Közepes";
|
|
var detail_validation_score_weak$1 = "Gyenge";
|
|
var detail_validation_score_desc$1 = "A szolgáltató megbízhatósági pontszáma a gamification validációk alapján.";
|
|
var detail_validation_no_entries$1 = "Nincsenek validációs bejegyzések ehhez a szolgáltatóhoz.";
|
|
var detail_validation_voter$1 = "Szavazó:";
|
|
var detail_validation_reason$1 = "Indoklás:";
|
|
var detail_validation_weight$1 = "súly:";
|
|
var detail_crawler_source$1 = "Forrás:";
|
|
var detail_crawler_trust_score$1 = "Trust Score:";
|
|
var detail_crawler_rejection_reason_title$1 = "Elutasítás indoklása";
|
|
var detail_crawler_raw_data$1 = "Nyers adatok (raw_data)";
|
|
var detail_crawler_audit_trail$1 = "Audit Trail";
|
|
var detail_history_no_entries$1 = "Nincsenek előzmények ehhez a szolgáltatóhoz.";
|
|
var detail_history_user$1 = "User #{id}";
|
|
var detail_history_status$1 = "Státusz:";
|
|
var detail_history_reason$1 = "Indoklás:";
|
|
var detail_history_detailed_changes$1 = "Részletes változások";
|
|
var detail_history_old_data$1 = "Régi adatok";
|
|
var detail_flag_modal_title$1 = "Szolgáltató megjelölése";
|
|
var detail_flag_modal_body$1 = "Biztosan megjelölöd a(z) {name} szolgáltatót?";
|
|
var detail_flag_reason_label$1 = "Indoklás (opcionális)";
|
|
var detail_flag_reason_placeholder$1 = "Add meg a megjelölés okát...";
|
|
var detail_flag_submit$1 = "Megjelölés";
|
|
var detail_toast_approved$1 = "Szolgáltató jóváhagyva!";
|
|
var detail_toast_rejected$1 = "Szolgáltató elutasítva!";
|
|
var detail_toast_restored$1 = "Szolgáltató visszaállítva!";
|
|
var detail_toast_flagged$1 = "Szolgáltató megjelölve!";
|
|
var detail_toast_deleted$1 = "Szolgáltató törölve!";
|
|
var detail_toast_status_updated$1 = "Státusz frissítve!";
|
|
var detail_toast_error_approve$1 = "Hiba a jóváhagyás során";
|
|
var detail_toast_error_reject$1 = "Hiba az elutasítás során";
|
|
var detail_toast_error_restore$1 = "Hiba a visszaállítás során";
|
|
var detail_toast_error_flag$1 = "Hiba a megjelölés során";
|
|
var detail_toast_error_delete$1 = "Hiba a törlés során";
|
|
var detail_toast_error_status$1 = "Hiba a státusz mentése során";
|
|
var detail_delete_confirm$1 = "Biztosan törlöd ezt a szolgáltatót? Ez a művelet nem visszavonható.";
|
|
var detail_vehicle_class_car$1 = "Személyautó";
|
|
var detail_vehicle_class_motorcycle$1 = "Motorkerékpár";
|
|
var detail_vehicle_class_truck$1 = "Teherautó";
|
|
var detail_vehicle_class_hgv$1 = "Nehézgépjármű (HGV)";
|
|
var detail_vehicle_class_light_commercial$1 = "Kishaszonjármű";
|
|
var detail_vehicle_class_personal$1 = "Személyes";
|
|
var detail_vehicle_class_boat$1 = "Csónak/Vízi";
|
|
var detail_vehicle_class_other$1 = "Egyéb";
|
|
var detail_validation_type_phone_verified$1 = "Telefon igazolt";
|
|
var detail_validation_type_email_verified$1 = "Email igazolt";
|
|
var detail_validation_type_address_verified$1 = "Cím igazolt";
|
|
var detail_validation_type_website_verified$1 = "Weboldal igazolt";
|
|
var detail_validation_type_manual_review$1 = "Kézi ellenőrzés";
|
|
var detail_validation_type_community_vouch$1 = "Közösségi ajánlás";
|
|
var detail_validation_type_business_hours$1 = "Nyitvatartás ellenőrzött";
|
|
var detail_validation_type_photo_evidence$1 = "Fénykép bizonyíték";
|
|
var detail_history_action_approve$1 = "Jóváhagyás";
|
|
var detail_history_action_reject$1 = "Elutasítás";
|
|
var detail_history_action_restore$1 = "Visszaállítás";
|
|
var detail_history_action_flag$1 = "Megjelölés";
|
|
var detail_history_action_update$1 = "Módosítás";
|
|
var detail_history_action_delete$1 = "Törlés";
|
|
var detail_history_action_create$1 = "Létrehozás";
|
|
var pending_title$1 = "Jóváhagyásra váró szolgáltatók";
|
|
var pending_subtitle$1 = "A közösség által beküldött szolgáltatók moderációs sora";
|
|
var pending_loading$1 = "Függőben lévő szolgáltatók betöltése...";
|
|
var rejected_title$1 = "Elutasított szolgáltatók";
|
|
var rejected_subtitle$1 = "Elutasított szolgáltatók visszaállítása az aktív kereshető szolgáltatók közé";
|
|
var rejected_loading$1 = "Elutasított szolgáltatók betöltése...";
|
|
var approve$1 = "Jóváhagyás";
|
|
var reject$1 = "Elutasítás";
|
|
var restore$1 = "Visszaállítás";
|
|
var details$8 = "Részletek";
|
|
var reject_modal_title$1 = "Szolgáltató elutasítása";
|
|
var reject_modal_body$1 = "Biztosan elutasítod a(z) {name} szolgáltatót?";
|
|
var reject_reason_label$1 = "Indoklás (opcionális)";
|
|
var reject_reason_placeholder$1 = "Add meg az elutasítás okát...";
|
|
var restore_modal_title$1 = "Szolgáltató visszaállítása";
|
|
var restore_modal_body$1 = "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.";
|
|
var restore_reason_label$1 = "Indoklás (opcionális)";
|
|
var restore_reason_placeholder$1 = "Add meg a visszaállítás okát...";
|
|
var no_pending$1 = "Nincs függőben lévő szolgáltató";
|
|
var no_pending_subtitle$1 = "Minden beküldött szolgáltató fel lett dolgozva.";
|
|
var no_rejected$1 = "Nincs elutasított szolgáltató";
|
|
var no_rejected_subtitle$1 = "Minden szolgáltató jóváhagyott státuszban van.";
|
|
var approved_toast$1 = "\"{name}\" sikeresen jóváhagyva";
|
|
var rejected_toast$1 = "\"{name}\" elutasítva";
|
|
var restored_toast$1 = "\"{name}\" sikeresen visszaállítva";
|
|
var error_prefix$1 = "Hiba: {detail}";
|
|
var unknown_error$3 = "Ismeretlen hiba";
|
|
var label_address$1 = "Cím:";
|
|
var label_city$1 = "Város:";
|
|
var label_category$1 = "Kategória:";
|
|
var label_validation_score$1 = "Validációs pontszám:";
|
|
var label_submitted$1 = "Beküldve:";
|
|
var label_created$1 = "Létrehozva:";
|
|
var edit_title$g = "Szolgáltató szerkesztése";
|
|
var edit_loading$1 = "Szolgáltató betöltése...";
|
|
var edit_error$1 = "Hiba történt a szolgáltató betöltése közben.";
|
|
var edit_not_found$1 = "A szolgáltató nem található.";
|
|
var edit_back$1 = "Vissza a szolgáltatóhoz";
|
|
var edit_raw_data$1 = "Nyers adatok";
|
|
var edit_tab_basic$1 = "Alapadatok & Kapcsolat";
|
|
var edit_tab_matrix$1 = "Szolgáltatások & Járművek";
|
|
var edit_tab_location$1 = "Helyszín & Lokáció";
|
|
var edit_tab_hours$1 = "Nyitvatartás";
|
|
var edit_section_basic$1 = "Alapadatok";
|
|
var edit_section_contact$1 = "Elérhetőség";
|
|
var edit_section_matrix$1 = "3D Képesség Mátrix";
|
|
var edit_section_matrix_desc$1 = "Állítsd be, hogy a szolgáltató milyen járműosztályokhoz, szolgáltatási kategóriákhoz és specializációkhoz tartozik.";
|
|
var edit_section_vehicle_classes$1 = "Járműosztályok (Vehicle Classes)";
|
|
var edit_section_vehicle_classes_desc$1 = "Mely járműtípusokat szervizeli a szolgáltató?";
|
|
var edit_section_expertise_tags$1 = "Szolgáltatási Kategóriák (Expertise Tags)";
|
|
var edit_section_expertise_tags_desc$1 = "Válaszd ki a szolgáltatóhoz tartozó kategóriákat a hierarchikus fából.";
|
|
var edit_section_specializations$1 = "Specializációk";
|
|
var edit_section_specializations_desc$1 = "Adj meg speciális márkákat, hajtáslánc típusokat vagy egyéb címkéket.";
|
|
var edit_section_location_extra$1 = "További helyszín adatok";
|
|
var edit_section_opening_hours$1 = "Nyitvatartás";
|
|
var edit_section_opening_hours_desc$1 = "Állítsd be a szolgáltató nyitvatartási idejét napokra bontva.";
|
|
var edit_field_name$1 = "Név *";
|
|
var edit_field_category$1 = "Kategória";
|
|
var edit_field_category_placeholder$1 = "pl. Autószerviz, Gumiszerviz";
|
|
var edit_field_source$1 = "Forrás";
|
|
var edit_field_phone$1 = "Telefon";
|
|
var edit_field_phone_placeholder$1 = "+36 30 123 4567";
|
|
var edit_field_email$1 = "Email";
|
|
var edit_field_email_placeholder$1 = "info{'@'}example.com";
|
|
var edit_field_website$1 = "Weboldal";
|
|
var edit_field_website_placeholder$1 = "https://...";
|
|
var edit_field_full_address$1 = "Teljes cím szövege";
|
|
var edit_field_full_address_placeholder$1 = "Teljes cím szövege";
|
|
var edit_field_plus_code$1 = "Plus Code";
|
|
var edit_field_plus_code_placeholder$1 = "8FVC9X8V+XV";
|
|
var edit_field_brands$1 = "Márkák (Brands)";
|
|
var edit_field_brands_placeholder$1 = "pl. Volvo, Scania";
|
|
var edit_field_propulsion$1 = "Hajtáslánc (Propulsion)";
|
|
var edit_field_propulsion_placeholder$1 = "pl. EV, Hybrid, Diesel";
|
|
var edit_field_add$1 = "Hozzáad";
|
|
var edit_always_open$1 = "Folyamatos (0-24) nyitvatartás";
|
|
var edit_always_open_desc$1 = "A szolgáltató a hét minden napján 0-24 óráig nyitva van";
|
|
var edit_btn_24_7$1 = "24/7 Folyamatos nyitvatartás";
|
|
var edit_btn_copy_weekdays$1 = "Hétköznapok másolása (Hétfő → K-P)";
|
|
var edit_btn_clear_all$1 = "Összes törlése";
|
|
var edit_closed$1 = "Zárva";
|
|
var edit_has_changes$1 = "● Módosítások el nem mentve";
|
|
var edit_no_changes$1 = "Nincs változás";
|
|
var edit_cancel$1 = "Mégse";
|
|
var edit_save$1 = "Mentés";
|
|
var edit_toast_saved$1 = "Szolgáltató sikeresen frissítve!";
|
|
var edit_toast_promoted$1 = "Sikeres előléptetés!";
|
|
var edit_toast_error$1 = "Hiba a mentés során: {message}";
|
|
var edit_copy_weekdays_open_prompt$1 = "Add meg a nyitási időt (pl. 08:00):";
|
|
var edit_copy_weekdays_close_prompt$1 = "Add meg a zárási időt (pl. 17:00):";
|
|
var edit_categories_loading$1 = "Kategóriák betöltése...";
|
|
var edit_level_label$1 = "(Szint {level})";
|
|
var edit_source_label$1 = "Forrás:";
|
|
var edit_trust_score_label$1 = "Trust Score:";
|
|
var edit_raw_data_title$1 = "Nyers adatok (raw_data)";
|
|
var edit_audit_trail_title$1 = "Audit Trail";
|
|
var edit_rejection_reason_title$1 = "Elutasítás indoklása";
|
|
const locale_providers_46json_ca903007 = {
|
|
title: title$D,
|
|
subtitle: subtitle$x,
|
|
loading: loading$E,
|
|
error: error$q,
|
|
retry: retry$y,
|
|
stats_total: stats_total$1,
|
|
stats_pending: stats_pending$1,
|
|
stats_approved: stats_approved$1,
|
|
stats_rejected: stats_rejected$1,
|
|
stats_flagged: stats_flagged$1,
|
|
search_placeholder: search_placeholder$8,
|
|
filter_all_status: filter_all_status$1,
|
|
filter_pending: filter_pending$1,
|
|
filter_approved: filter_approved$1,
|
|
filter_rejected: filter_rejected$1,
|
|
filter_flagged: filter_flagged$1,
|
|
filter_all_sources: filter_all_sources$1,
|
|
source_manual: source_manual$1,
|
|
source_ocr: source_ocr$1,
|
|
source_import: source_import$1,
|
|
source_bot: source_bot$1,
|
|
source_verified_org: source_verified_org$1,
|
|
sort_created_at: sort_created_at$1,
|
|
sort_name: sort_name$1,
|
|
sort_validation_score: sort_validation_score$1,
|
|
col_id: col_id$1,
|
|
col_name: col_name$1,
|
|
col_address: col_address$1,
|
|
col_status: col_status$1,
|
|
col_source: col_source$1,
|
|
col_validation: col_validation$1,
|
|
col_created: col_created$1,
|
|
col_actions: col_actions$1,
|
|
no_providers: no_providers$1,
|
|
results_count: results_count$1,
|
|
page: page$1,
|
|
view_details: view_details$3,
|
|
status_pending: status_pending$1,
|
|
status_approved: status_approved$1,
|
|
status_rejected: status_rejected$1,
|
|
status_flagged: status_flagged$1,
|
|
provider_detail: provider_detail$1,
|
|
detail_loading: detail_loading$1,
|
|
detail_not_found: detail_not_found$1,
|
|
detail_back: detail_back$1,
|
|
detail_provider_number: detail_provider_number$1,
|
|
detail_raw_data: detail_raw_data$1,
|
|
detail_tab_data: detail_tab_data$1,
|
|
detail_tab_status: detail_tab_status$1,
|
|
detail_tab_validations: detail_tab_validations$1,
|
|
detail_tab_crawler: detail_tab_crawler$1,
|
|
detail_tab_history: detail_tab_history$1,
|
|
detail_section_basic: detail_section_basic$1,
|
|
detail_section_address: detail_section_address$1,
|
|
detail_section_contact: detail_section_contact$1,
|
|
detail_section_services: detail_section_services$1,
|
|
detail_section_vehicle_classes: detail_section_vehicle_classes$1,
|
|
detail_section_specializations: detail_section_specializations$1,
|
|
detail_section_opening_hours: detail_section_opening_hours$1,
|
|
detail_section_evidence: detail_section_evidence$1,
|
|
detail_section_moderation: detail_section_moderation$1,
|
|
detail_section_status_management: detail_section_status_management$1,
|
|
detail_section_validation_score: detail_section_validation_score$1,
|
|
detail_section_gamification_validations: detail_section_gamification_validations$1,
|
|
detail_section_crawler_data: detail_section_crawler_data$1,
|
|
detail_section_history: detail_section_history$1,
|
|
detail_field_name: detail_field_name$1,
|
|
detail_field_category: detail_field_category$1,
|
|
detail_field_source: detail_field_source$1,
|
|
detail_field_validation_score: detail_field_validation_score$1,
|
|
detail_field_created: detail_field_created$1,
|
|
detail_field_submitted_by: detail_field_submitted_by$1,
|
|
detail_field_full_address: detail_field_full_address$1,
|
|
detail_field_city: detail_field_city$1,
|
|
detail_field_zip: detail_field_zip$1,
|
|
detail_field_street: detail_field_street$1,
|
|
detail_field_house_number: detail_field_house_number$1,
|
|
detail_field_plus_code: detail_field_plus_code$1,
|
|
detail_field_phone: detail_field_phone$1,
|
|
detail_field_email: detail_field_email$1,
|
|
detail_field_website: detail_field_website$1,
|
|
detail_no_categories: detail_no_categories$1,
|
|
detail_no_vehicle_classes: detail_no_vehicle_classes$1,
|
|
detail_no_specializations: detail_no_specializations$1,
|
|
detail_no_opening_hours: detail_no_opening_hours$1,
|
|
detail_day_monday: detail_day_monday$1,
|
|
detail_day_tuesday: detail_day_tuesday$1,
|
|
detail_day_wednesday: detail_day_wednesday$1,
|
|
detail_day_thursday: detail_day_thursday$1,
|
|
detail_day_friday: detail_day_friday$1,
|
|
detail_day_saturday: detail_day_saturday$1,
|
|
detail_day_sunday: detail_day_sunday$1,
|
|
detail_day_label: detail_day_label$1,
|
|
detail_hours_label: detail_hours_label$1,
|
|
detail_closed: detail_closed$1,
|
|
detail_specialization_brands: detail_specialization_brands$1,
|
|
detail_specialization_propulsion: detail_specialization_propulsion$1,
|
|
detail_status_approved: detail_status_approved$1,
|
|
detail_status_pending: detail_status_pending$1,
|
|
detail_status_research: detail_status_research$1,
|
|
detail_status_rejected: detail_status_rejected$1,
|
|
detail_status_unknown: detail_status_unknown$1,
|
|
detail_status_desc_approved: detail_status_desc_approved$1,
|
|
detail_status_desc_pending: detail_status_desc_pending$1,
|
|
detail_status_desc_research: detail_status_desc_research$1,
|
|
detail_status_desc_rejected: detail_status_desc_rejected$1,
|
|
detail_edit: detail_edit$1,
|
|
detail_approve: detail_approve$1,
|
|
detail_reject: detail_reject$1,
|
|
detail_flag: detail_flag$1,
|
|
detail_delete: detail_delete$1,
|
|
detail_restore: detail_restore$1,
|
|
detail_status_rejected_or_flagged: detail_status_rejected_or_flagged$1,
|
|
detail_status_rejected_text: detail_status_rejected_text$1,
|
|
detail_status_flagged_text: detail_status_flagged_text$1,
|
|
detail_status_form_label: detail_status_form_label$1,
|
|
detail_status_form_score: detail_status_form_score$1,
|
|
detail_status_form_reason: detail_status_form_reason$1,
|
|
detail_status_form_reason_placeholder: detail_status_form_reason_placeholder$1,
|
|
detail_status_form_cancel: detail_status_form_cancel$1,
|
|
detail_status_form_save: detail_status_form_save$1,
|
|
detail_validation_score_excellent: detail_validation_score_excellent$1,
|
|
detail_validation_score_medium: detail_validation_score_medium$1,
|
|
detail_validation_score_weak: detail_validation_score_weak$1,
|
|
detail_validation_score_desc: detail_validation_score_desc$1,
|
|
detail_validation_no_entries: detail_validation_no_entries$1,
|
|
detail_validation_voter: detail_validation_voter$1,
|
|
detail_validation_reason: detail_validation_reason$1,
|
|
detail_validation_weight: detail_validation_weight$1,
|
|
detail_crawler_source: detail_crawler_source$1,
|
|
detail_crawler_trust_score: detail_crawler_trust_score$1,
|
|
detail_crawler_rejection_reason_title: detail_crawler_rejection_reason_title$1,
|
|
detail_crawler_raw_data: detail_crawler_raw_data$1,
|
|
detail_crawler_audit_trail: detail_crawler_audit_trail$1,
|
|
detail_history_no_entries: detail_history_no_entries$1,
|
|
detail_history_user: detail_history_user$1,
|
|
detail_history_status: detail_history_status$1,
|
|
detail_history_reason: detail_history_reason$1,
|
|
detail_history_detailed_changes: detail_history_detailed_changes$1,
|
|
detail_history_old_data: detail_history_old_data$1,
|
|
detail_flag_modal_title: detail_flag_modal_title$1,
|
|
detail_flag_modal_body: detail_flag_modal_body$1,
|
|
detail_flag_reason_label: detail_flag_reason_label$1,
|
|
detail_flag_reason_placeholder: detail_flag_reason_placeholder$1,
|
|
detail_flag_submit: detail_flag_submit$1,
|
|
detail_toast_approved: detail_toast_approved$1,
|
|
detail_toast_rejected: detail_toast_rejected$1,
|
|
detail_toast_restored: detail_toast_restored$1,
|
|
detail_toast_flagged: detail_toast_flagged$1,
|
|
detail_toast_deleted: detail_toast_deleted$1,
|
|
detail_toast_status_updated: detail_toast_status_updated$1,
|
|
detail_toast_error_approve: detail_toast_error_approve$1,
|
|
detail_toast_error_reject: detail_toast_error_reject$1,
|
|
detail_toast_error_restore: detail_toast_error_restore$1,
|
|
detail_toast_error_flag: detail_toast_error_flag$1,
|
|
detail_toast_error_delete: detail_toast_error_delete$1,
|
|
detail_toast_error_status: detail_toast_error_status$1,
|
|
detail_delete_confirm: detail_delete_confirm$1,
|
|
detail_vehicle_class_car: detail_vehicle_class_car$1,
|
|
detail_vehicle_class_motorcycle: detail_vehicle_class_motorcycle$1,
|
|
detail_vehicle_class_truck: detail_vehicle_class_truck$1,
|
|
detail_vehicle_class_hgv: detail_vehicle_class_hgv$1,
|
|
detail_vehicle_class_light_commercial: detail_vehicle_class_light_commercial$1,
|
|
detail_vehicle_class_personal: detail_vehicle_class_personal$1,
|
|
detail_vehicle_class_boat: detail_vehicle_class_boat$1,
|
|
detail_vehicle_class_other: detail_vehicle_class_other$1,
|
|
detail_validation_type_phone_verified: detail_validation_type_phone_verified$1,
|
|
detail_validation_type_email_verified: detail_validation_type_email_verified$1,
|
|
detail_validation_type_address_verified: detail_validation_type_address_verified$1,
|
|
detail_validation_type_website_verified: detail_validation_type_website_verified$1,
|
|
detail_validation_type_manual_review: detail_validation_type_manual_review$1,
|
|
detail_validation_type_community_vouch: detail_validation_type_community_vouch$1,
|
|
detail_validation_type_business_hours: detail_validation_type_business_hours$1,
|
|
detail_validation_type_photo_evidence: detail_validation_type_photo_evidence$1,
|
|
detail_history_action_approve: detail_history_action_approve$1,
|
|
detail_history_action_reject: detail_history_action_reject$1,
|
|
detail_history_action_restore: detail_history_action_restore$1,
|
|
detail_history_action_flag: detail_history_action_flag$1,
|
|
detail_history_action_update: detail_history_action_update$1,
|
|
detail_history_action_delete: detail_history_action_delete$1,
|
|
detail_history_action_create: detail_history_action_create$1,
|
|
pending_title: pending_title$1,
|
|
pending_subtitle: pending_subtitle$1,
|
|
pending_loading: pending_loading$1,
|
|
rejected_title: rejected_title$1,
|
|
rejected_subtitle: rejected_subtitle$1,
|
|
rejected_loading: rejected_loading$1,
|
|
approve: approve$1,
|
|
reject: reject$1,
|
|
restore: restore$1,
|
|
details: details$8,
|
|
reject_modal_title: reject_modal_title$1,
|
|
reject_modal_body: reject_modal_body$1,
|
|
reject_reason_label: reject_reason_label$1,
|
|
reject_reason_placeholder: reject_reason_placeholder$1,
|
|
restore_modal_title: restore_modal_title$1,
|
|
restore_modal_body: restore_modal_body$1,
|
|
restore_reason_label: restore_reason_label$1,
|
|
restore_reason_placeholder: restore_reason_placeholder$1,
|
|
no_pending: no_pending$1,
|
|
no_pending_subtitle: no_pending_subtitle$1,
|
|
no_rejected: no_rejected$1,
|
|
no_rejected_subtitle: no_rejected_subtitle$1,
|
|
approved_toast: approved_toast$1,
|
|
rejected_toast: rejected_toast$1,
|
|
restored_toast: restored_toast$1,
|
|
error_prefix: error_prefix$1,
|
|
unknown_error: unknown_error$3,
|
|
label_address: label_address$1,
|
|
label_city: label_city$1,
|
|
label_category: label_category$1,
|
|
label_validation_score: label_validation_score$1,
|
|
label_submitted: label_submitted$1,
|
|
label_created: label_created$1,
|
|
edit_title: edit_title$g,
|
|
edit_loading: edit_loading$1,
|
|
edit_error: edit_error$1,
|
|
edit_not_found: edit_not_found$1,
|
|
edit_back: edit_back$1,
|
|
edit_raw_data: edit_raw_data$1,
|
|
edit_tab_basic: edit_tab_basic$1,
|
|
edit_tab_matrix: edit_tab_matrix$1,
|
|
edit_tab_location: edit_tab_location$1,
|
|
edit_tab_hours: edit_tab_hours$1,
|
|
edit_section_basic: edit_section_basic$1,
|
|
edit_section_contact: edit_section_contact$1,
|
|
edit_section_matrix: edit_section_matrix$1,
|
|
edit_section_matrix_desc: edit_section_matrix_desc$1,
|
|
edit_section_vehicle_classes: edit_section_vehicle_classes$1,
|
|
edit_section_vehicle_classes_desc: edit_section_vehicle_classes_desc$1,
|
|
edit_section_expertise_tags: edit_section_expertise_tags$1,
|
|
edit_section_expertise_tags_desc: edit_section_expertise_tags_desc$1,
|
|
edit_section_specializations: edit_section_specializations$1,
|
|
edit_section_specializations_desc: edit_section_specializations_desc$1,
|
|
edit_section_location_extra: edit_section_location_extra$1,
|
|
edit_section_opening_hours: edit_section_opening_hours$1,
|
|
edit_section_opening_hours_desc: edit_section_opening_hours_desc$1,
|
|
edit_field_name: edit_field_name$1,
|
|
edit_field_category: edit_field_category$1,
|
|
edit_field_category_placeholder: edit_field_category_placeholder$1,
|
|
edit_field_source: edit_field_source$1,
|
|
edit_field_phone: edit_field_phone$1,
|
|
edit_field_phone_placeholder: edit_field_phone_placeholder$1,
|
|
edit_field_email: edit_field_email$1,
|
|
edit_field_email_placeholder: edit_field_email_placeholder$1,
|
|
edit_field_website: edit_field_website$1,
|
|
edit_field_website_placeholder: edit_field_website_placeholder$1,
|
|
edit_field_full_address: edit_field_full_address$1,
|
|
edit_field_full_address_placeholder: edit_field_full_address_placeholder$1,
|
|
edit_field_plus_code: edit_field_plus_code$1,
|
|
edit_field_plus_code_placeholder: edit_field_plus_code_placeholder$1,
|
|
edit_field_brands: edit_field_brands$1,
|
|
edit_field_brands_placeholder: edit_field_brands_placeholder$1,
|
|
edit_field_propulsion: edit_field_propulsion$1,
|
|
edit_field_propulsion_placeholder: edit_field_propulsion_placeholder$1,
|
|
edit_field_add: edit_field_add$1,
|
|
edit_always_open: edit_always_open$1,
|
|
edit_always_open_desc: edit_always_open_desc$1,
|
|
edit_btn_24_7: edit_btn_24_7$1,
|
|
edit_btn_copy_weekdays: edit_btn_copy_weekdays$1,
|
|
edit_btn_clear_all: edit_btn_clear_all$1,
|
|
edit_closed: edit_closed$1,
|
|
edit_has_changes: edit_has_changes$1,
|
|
edit_no_changes: edit_no_changes$1,
|
|
edit_cancel: edit_cancel$1,
|
|
edit_save: edit_save$1,
|
|
edit_toast_saved: edit_toast_saved$1,
|
|
edit_toast_promoted: edit_toast_promoted$1,
|
|
edit_toast_error: edit_toast_error$1,
|
|
edit_copy_weekdays_open_prompt: edit_copy_weekdays_open_prompt$1,
|
|
edit_copy_weekdays_close_prompt: edit_copy_weekdays_close_prompt$1,
|
|
edit_categories_loading: edit_categories_loading$1,
|
|
edit_level_label: edit_level_label$1,
|
|
edit_source_label: edit_source_label$1,
|
|
edit_trust_score_label: edit_trust_score_label$1,
|
|
edit_raw_data_title: edit_raw_data_title$1,
|
|
edit_audit_trail_title: edit_audit_trail_title$1,
|
|
edit_rejection_reason_title: edit_rejection_reason_title$1
|
|
};
|
|
|
|
var title$C = "Garázsok CRM";
|
|
var subtitle$w = "Garázsok listája, csomagkezelés és státuszmódosítás";
|
|
var total_garages$1 = "Összes Garázs";
|
|
var private_garages$1 = "Privát Garázsok";
|
|
var corporate_garages$1 = "Céges Garázsok";
|
|
var search_placeholder$7 = "Keresés név, kapcsolattartó vagy e-mail alapján...";
|
|
var all_tiers$1 = "Összes csomag";
|
|
var all_types$1 = "Összes típus";
|
|
var type_individual$1 = "Privát (Egyéni)";
|
|
var type_corporate$4 = "Céges (Vállalati)";
|
|
var company_name$3 = "Cégnév";
|
|
var email$8 = "E-mail";
|
|
var status$g = "Státusz";
|
|
var current_package$1 = "Aktuális Csomag";
|
|
var expiration_date$1 = "Lejárat Dátuma";
|
|
var actions$k = "Műveletek";
|
|
var active$8 = "Aktív";
|
|
var inactive$8 = "Inaktív";
|
|
var suspended$1 = "Felfüggesztve";
|
|
var change_package$1 = "Csomag Módosítása";
|
|
var manage_subscription$1 = "Előfizetés Kezelése";
|
|
var view$6 = "Megtekintés";
|
|
var activate$6 = "Aktiválás";
|
|
var deactivate$4 = "Deaktiválás";
|
|
var no_results$c = "Nincs a keresésnek megfelelő garázs.";
|
|
var loading$D = "Garázsok betöltése...";
|
|
var retry$x = "Újra";
|
|
var members$1 = "tag";
|
|
var free_fallback$1 = "Ingyenes / Visszaesési";
|
|
var expires$4 = "Lejárat";
|
|
var select_package$1 = "Csomag Kiválasztása";
|
|
var select_package_placeholder$1 = "Válassz egy előfizetési csomagot...";
|
|
var custom_expiration$1 = "Egyéni Lejárati Dátum";
|
|
var optional$1 = "opcionális";
|
|
var custom_expiration_hint$1 = "Hagyd üresen az alapértelmezett időtartamhoz (pl. 30 nap). 2-5 éves B2B deal-eknél adj meg egyedi dátumot!";
|
|
var cancel$k = "Mégse";
|
|
var save$o = "Mentés";
|
|
var saving$e = "Mentés...";
|
|
var subscription_updated$1 = "előfizetése sikeresen frissítve!";
|
|
var view_details$2 = "Részletek";
|
|
var indefinite$1 = "Határozatlan";
|
|
var addons_title$1 = "Kiegészítők (Add-ons)";
|
|
var addon_vehicles$1 = "Extra Jármű";
|
|
var addon_branches$1 = "Extra Telephely";
|
|
var addon_users$1 = "Extra Dolgozó";
|
|
var active_addons$1 = "Aktív kiegészítők";
|
|
var no_active_addons$1 = "Nincsenek aktív kiegészítők";
|
|
var addon_vehicles_expiration$1 = "Extra Jármű lejárati dátuma";
|
|
var addon_branches_expiration$1 = "Extra Telephely lejárati dátuma";
|
|
var addon_users_expiration$1 = "Extra Dolgozó lejárati dátuma";
|
|
var addon_expiration_hint$1 = "Ha üres, a meglévő lejárati dátumok megmaradnak.";
|
|
const locale_garages_46json_a818fc5b = {
|
|
title: title$C,
|
|
subtitle: subtitle$w,
|
|
total_garages: total_garages$1,
|
|
private_garages: private_garages$1,
|
|
corporate_garages: corporate_garages$1,
|
|
search_placeholder: search_placeholder$7,
|
|
all_tiers: all_tiers$1,
|
|
all_types: all_types$1,
|
|
type_individual: type_individual$1,
|
|
type_corporate: type_corporate$4,
|
|
company_name: company_name$3,
|
|
email: email$8,
|
|
status: status$g,
|
|
current_package: current_package$1,
|
|
expiration_date: expiration_date$1,
|
|
actions: actions$k,
|
|
active: active$8,
|
|
inactive: inactive$8,
|
|
suspended: suspended$1,
|
|
change_package: change_package$1,
|
|
manage_subscription: manage_subscription$1,
|
|
view: view$6,
|
|
activate: activate$6,
|
|
deactivate: deactivate$4,
|
|
no_results: no_results$c,
|
|
loading: loading$D,
|
|
retry: retry$x,
|
|
members: members$1,
|
|
free_fallback: free_fallback$1,
|
|
expires: expires$4,
|
|
select_package: select_package$1,
|
|
select_package_placeholder: select_package_placeholder$1,
|
|
custom_expiration: custom_expiration$1,
|
|
optional: optional$1,
|
|
custom_expiration_hint: custom_expiration_hint$1,
|
|
cancel: cancel$k,
|
|
save: save$o,
|
|
saving: saving$e,
|
|
subscription_updated: subscription_updated$1,
|
|
view_details: view_details$2,
|
|
indefinite: indefinite$1,
|
|
addons_title: addons_title$1,
|
|
addon_vehicles: addon_vehicles$1,
|
|
addon_branches: addon_branches$1,
|
|
addon_users: addon_users$1,
|
|
active_addons: active_addons$1,
|
|
no_active_addons: no_active_addons$1,
|
|
addon_vehicles_expiration: addon_vehicles_expiration$1,
|
|
addon_branches_expiration: addon_branches_expiration$1,
|
|
addon_users_expiration: addon_users_expiration$1,
|
|
addon_expiration_hint: addon_expiration_hint$1
|
|
};
|
|
|
|
var title$B = "Gamification HQ";
|
|
var subtitle$v = "Gamification rendszer áttekintő irányítópultja";
|
|
var loading$C = "Dashboard betöltése...";
|
|
var error$p = "Nem sikerült betölteni a dashboard adatokat.";
|
|
var total_users$3 = "Összes Felhasználó";
|
|
var active_season$1 = "Aktív Szezon";
|
|
var pending_contributions$1 = "Függő Hozzájárulások";
|
|
var xp_earned_today$1 = "Ma Szerzett XP";
|
|
var none$4 = "Nincs";
|
|
var quick_actions$1 = "Gyors Műveletek";
|
|
var manage_point_rules$1 = "Pontszabályok kezelése";
|
|
var manage_badges$1 = "Kitüntetések kezelése";
|
|
var manage_seasons$1 = "Szezonok kezelése";
|
|
var recent_ledger$1 = "Legutóbbi Pontnapló Bejegyzések";
|
|
var no_ledger$1 = "Még nincsenek pontnapló bejegyzések.";
|
|
var top_5$1 = "Top 5 Ranglista";
|
|
var full_leaderboard$1 = "Teljes ranglista →";
|
|
var no_leaderboard$1 = "Még nincsenek ranglista adatok.";
|
|
var level$a = "Szint";
|
|
var xp$8 = "XP";
|
|
var points$c = "pont";
|
|
const locale_dashboard_46json_d0703406 = {
|
|
title: title$B,
|
|
subtitle: subtitle$v,
|
|
loading: loading$C,
|
|
error: error$p,
|
|
total_users: total_users$3,
|
|
active_season: active_season$1,
|
|
pending_contributions: pending_contributions$1,
|
|
xp_earned_today: xp_earned_today$1,
|
|
none: none$4,
|
|
quick_actions: quick_actions$1,
|
|
manage_point_rules: manage_point_rules$1,
|
|
manage_badges: manage_badges$1,
|
|
manage_seasons: manage_seasons$1,
|
|
recent_ledger: recent_ledger$1,
|
|
no_ledger: no_ledger$1,
|
|
top_5: top_5$1,
|
|
full_leaderboard: full_leaderboard$1,
|
|
no_leaderboard: no_leaderboard$1,
|
|
level: level$a,
|
|
xp: xp$8,
|
|
points: points$c
|
|
};
|
|
|
|
var title$A = "Rendszer Konfig";
|
|
var subtitle$u = "Gamification master konfiguráció szerkesztése";
|
|
var loading$B = "Konfiguráció betöltése...";
|
|
var error$o = "Nem sikerült betölteni a konfigurációt.";
|
|
var last_save$1 = "Utolsó mentés:";
|
|
var saving$d = "Mentés...";
|
|
var save$n = "Konfiguráció mentése";
|
|
var section_xp$1 = "XP Logika";
|
|
var section_conversion$1 = "Konverziós Logika";
|
|
var section_penalty$1 = "Büntetési Logika";
|
|
var section_rewards$1 = "Szint Jutalmak";
|
|
var calculator$1 = "Hatás Kalkulátor";
|
|
var calculator_desc$1 = "Állítsd be a paramétereket a becsült hatás megtekintéséhez";
|
|
var estimated_results$1 = "Becsült Eredmények";
|
|
var daily_xp$1 = "Napi XP";
|
|
var xp_for_level$1 = "Szintlépéshez Szükséges XP";
|
|
var social_to_credit$1 = "Social → Credit";
|
|
var days_to_level$1 = "Szintlépés Napok Száma";
|
|
var raw_json$1 = "Nyers JSON Szerkesztő";
|
|
var apply_json$1 = "JSON Alkalmazása";
|
|
var updated$e = "Konfiguráció frissítve!";
|
|
var save_error$e = "Hiba történt a mentés során.";
|
|
var json_applied$1 = "JSON alkalmazva a form mezőkre!";
|
|
var invalid_json$6 = "Érvénytelen JSON: ";
|
|
const locale_config_46json_88e60c59 = {
|
|
title: title$A,
|
|
subtitle: subtitle$u,
|
|
loading: loading$B,
|
|
error: error$o,
|
|
last_save: last_save$1,
|
|
saving: saving$d,
|
|
save: save$n,
|
|
section_xp: section_xp$1,
|
|
section_conversion: section_conversion$1,
|
|
section_penalty: section_penalty$1,
|
|
section_rewards: section_rewards$1,
|
|
calculator: calculator$1,
|
|
calculator_desc: calculator_desc$1,
|
|
estimated_results: estimated_results$1,
|
|
daily_xp: daily_xp$1,
|
|
xp_for_level: xp_for_level$1,
|
|
social_to_credit: social_to_credit$1,
|
|
days_to_level: days_to_level$1,
|
|
raw_json: raw_json$1,
|
|
apply_json: apply_json$1,
|
|
updated: updated$e,
|
|
save_error: save_error$e,
|
|
json_applied: json_applied$1,
|
|
invalid_json: invalid_json$6
|
|
};
|
|
|
|
var title$z = "Kitüntetések";
|
|
var subtitle$t = "Badge-ek kezelése — CRUD";
|
|
var loading$A = "Kitüntetések betöltése...";
|
|
var error$n = "Nem sikerült betölteni a kitüntetéseket.";
|
|
var retry$w = "Újrapróbálkozás";
|
|
var create$c = "Új kitüntetés";
|
|
var no_items$c = "Még nincsenek kitüntetések.";
|
|
var id$6 = "ID";
|
|
var name$c = "Név";
|
|
var description$6 = "Leírás";
|
|
var icon$1 = "Ikon";
|
|
var actions$j = "Műveletek";
|
|
var edit$e = "Szerkesztés";
|
|
var cancel$j = "Mégse";
|
|
var save$m = "Mentés";
|
|
var create_title$c = "Kitüntetés létrehozása";
|
|
var edit_title$f = "Kitüntetés szerkesztése";
|
|
var name_placeholder$6 = "Kitüntetés neve";
|
|
var desc_placeholder$4 = "Kitüntetés leírása";
|
|
var icon_placeholder$1 = "Ikon URL";
|
|
var icon_hint$1 = "Opcionális. Az ikon URL-je a kitüntetéshez.";
|
|
var icon_preview$1 = "Ikon előnézet";
|
|
var create_btn$6 = "Létrehozás";
|
|
var delete_title$6 = "Kitüntetés törlése";
|
|
var delete_confirm$6 = "Biztosan törölni szeretnéd ezt a kitüntetést?";
|
|
var delete_btn$6 = "Törlés";
|
|
var created$6 = "Kitüntetés létrehozva!";
|
|
var updated$d = "Kitüntetés frissítve!";
|
|
var deleted$4 = "Kitüntetés törölve!";
|
|
var save_error$d = "Nem sikerült menteni a kitüntetést.";
|
|
var delete_error$1 = "Nem sikerült törölni a kitüntetést.";
|
|
var unknown_error$2 = "Ismeretlen hiba";
|
|
const locale_badges_46json_3e08338d = {
|
|
title: title$z,
|
|
subtitle: subtitle$t,
|
|
loading: loading$A,
|
|
error: error$n,
|
|
retry: retry$w,
|
|
create: create$c,
|
|
no_items: no_items$c,
|
|
id: id$6,
|
|
name: name$c,
|
|
description: description$6,
|
|
icon: icon$1,
|
|
actions: actions$j,
|
|
edit: edit$e,
|
|
"delete": "Törlés",
|
|
cancel: cancel$j,
|
|
save: save$m,
|
|
create_title: create_title$c,
|
|
edit_title: edit_title$f,
|
|
name_placeholder: name_placeholder$6,
|
|
desc_placeholder: desc_placeholder$4,
|
|
icon_placeholder: icon_placeholder$1,
|
|
icon_hint: icon_hint$1,
|
|
icon_preview: icon_preview$1,
|
|
create_btn: create_btn$6,
|
|
delete_title: delete_title$6,
|
|
delete_confirm: delete_confirm$6,
|
|
delete_btn: delete_btn$6,
|
|
created: created$6,
|
|
updated: updated$d,
|
|
deleted: deleted$4,
|
|
save_error: save_error$d,
|
|
delete_error: delete_error$1,
|
|
unknown_error: unknown_error$2
|
|
};
|
|
|
|
var title$y = "Szintek";
|
|
var subtitle$s = "Szint konfigurációk kezelése — CRUD";
|
|
var loading$z = "Szintek betöltése...";
|
|
var error$m = "Nem sikerült betölteni a szint konfigurációkat.";
|
|
var retry$v = "Újrapróbálkozás";
|
|
var create$b = "Új szint";
|
|
var no_items$b = "Még nincsenek szint konfigurációk.";
|
|
var level$9 = "Szint";
|
|
var rank$1 = "Rang";
|
|
var min_points$1 = "Min. Pont";
|
|
var type$2 = "Típus";
|
|
var actions$i = "Műveletek";
|
|
var penalty$8 = "Büntető";
|
|
var normal$1 = "Normál";
|
|
var tree_diagram$1 = "Szint Fa Diagram";
|
|
var no_tree_data$1 = "Nincsenek szintek megjelenítéshez.";
|
|
var points$b = "pont";
|
|
var edit_title$e = "Szint szerkesztése";
|
|
var create_title$b = "Szint létrehozása";
|
|
var level_number$1 = "Szint Száma";
|
|
var rank_name$1 = "Rang Neve";
|
|
var min_points_label$1 = "Minimum Pont";
|
|
var is_penalty$1 = "Büntető szint";
|
|
var cancel$i = "Mégse";
|
|
var save$l = "Mentés";
|
|
var saving$c = "Mentés...";
|
|
var updated$c = "Szint frissítve!";
|
|
var created$5 = "Szint létrehozva!";
|
|
var duplicate_level$1 = "Ezzel a szint számmal már létezik konfiguráció.";
|
|
var save_error$c = "Hiba történt a mentés során.";
|
|
const locale_levels_46json_ae6f2fe4 = {
|
|
title: title$y,
|
|
subtitle: subtitle$s,
|
|
loading: loading$z,
|
|
error: error$m,
|
|
retry: retry$v,
|
|
create: create$b,
|
|
no_items: no_items$b,
|
|
level: level$9,
|
|
rank: rank$1,
|
|
min_points: min_points$1,
|
|
type: type$2,
|
|
actions: actions$i,
|
|
penalty: penalty$8,
|
|
normal: normal$1,
|
|
tree_diagram: tree_diagram$1,
|
|
no_tree_data: no_tree_data$1,
|
|
points: points$b,
|
|
edit_title: edit_title$e,
|
|
create_title: create_title$b,
|
|
level_number: level_number$1,
|
|
rank_name: rank_name$1,
|
|
min_points_label: min_points_label$1,
|
|
is_penalty: is_penalty$1,
|
|
cancel: cancel$i,
|
|
save: save$l,
|
|
saving: saving$c,
|
|
updated: updated$c,
|
|
created: created$5,
|
|
duplicate_level: duplicate_level$1,
|
|
save_error: save_error$c
|
|
};
|
|
|
|
var title$x = "Pontszabályok";
|
|
var subtitle$r = "Gamification pontszabályok kezelése — CRUD";
|
|
var loading$y = "Pontszabályok betöltése...";
|
|
var error$l = "Nem sikerült betölteni a pontszabályokat.";
|
|
var retry$u = "Újrapróbálkozás";
|
|
var create$a = "Új pontszabály";
|
|
var no_items$a = "Még nincsenek pontszabályok. Hozz létre egyet a fenti gombbal!";
|
|
var id$5 = "ID";
|
|
var action_key$1 = "Akció Kulcs";
|
|
var points$a = "Pont";
|
|
var description$5 = "Leírás";
|
|
var status$f = "Státusz";
|
|
var actions$h = "Műveletek";
|
|
var active$7 = "Aktív";
|
|
var inactive$7 = "Inaktív";
|
|
var edit$d = "Szerkesztés";
|
|
var edit_title$d = "Pontszabály szerkesztése";
|
|
var create_title$a = "Új pontszabály";
|
|
var action_key_label$1 = "Akció Kulcs";
|
|
var action_key_placeholder$1 = "pl. service_submitted";
|
|
var points_label$1 = "Pontérték";
|
|
var points_placeholder$1 = "0";
|
|
var description_label$1 = "Leírás";
|
|
var description_placeholder$1 = "Rövid leírás a szabályról...";
|
|
var is_active$3 = "Aktív";
|
|
var cancel$h = "Mégse";
|
|
var save$k = "Mentés";
|
|
var saving$b = "Mentés...";
|
|
var updated$b = "Pontszabály frissítve!";
|
|
var created$4 = "Pontszabály létrehozva!";
|
|
var deleted$3 = "Pontszabály deaktiválva!";
|
|
var duplicate_key$1 = "Egy szabály ezzel a kulccsal már létezik.";
|
|
var save_error$b = "Nem sikerült menteni a pontszabályt.";
|
|
var delete_title$5 = "Pontszabály törlése";
|
|
var delete_confirm$5 = "Biztosan deaktiválod a következő szabályt:";
|
|
var delete_btn$5 = "Törlés";
|
|
var deleting$1 = "Törlés...";
|
|
const locale_point_rules_46json_bbf72486 = {
|
|
title: title$x,
|
|
subtitle: subtitle$r,
|
|
loading: loading$y,
|
|
error: error$l,
|
|
retry: retry$u,
|
|
create: create$a,
|
|
no_items: no_items$a,
|
|
id: id$5,
|
|
action_key: action_key$1,
|
|
points: points$a,
|
|
description: description$5,
|
|
status: status$f,
|
|
actions: actions$h,
|
|
active: active$7,
|
|
inactive: inactive$7,
|
|
edit: edit$d,
|
|
"delete": "Törlés (soft-delete)",
|
|
edit_title: edit_title$d,
|
|
create_title: create_title$a,
|
|
action_key_label: action_key_label$1,
|
|
action_key_placeholder: action_key_placeholder$1,
|
|
points_label: points_label$1,
|
|
points_placeholder: points_placeholder$1,
|
|
description_label: description_label$1,
|
|
description_placeholder: description_placeholder$1,
|
|
is_active: is_active$3,
|
|
cancel: cancel$h,
|
|
save: save$k,
|
|
saving: saving$b,
|
|
updated: updated$b,
|
|
created: created$4,
|
|
deleted: deleted$3,
|
|
duplicate_key: duplicate_key$1,
|
|
save_error: save_error$b,
|
|
delete_title: delete_title$5,
|
|
delete_confirm: delete_confirm$5,
|
|
delete_btn: delete_btn$5,
|
|
deleting: deleting$1
|
|
};
|
|
|
|
var title$w = "Szezonok";
|
|
var subtitle$q = "Gamification szezonkezelés";
|
|
var loading$x = "Szezonok betöltése...";
|
|
var error$k = "Nem sikerült betölteni a szezonokat.";
|
|
var retry$t = "Újra";
|
|
var create$9 = "Új Szezon";
|
|
var no_items$9 = "Még nincsenek szezonok létrehozva.";
|
|
var create_first$6 = "Első Szezon Létrehozása";
|
|
var active$6 = "Aktív";
|
|
var inactive$6 = "Inaktív";
|
|
var created_at$3 = "Létrehozva:";
|
|
var activate$5 = "Aktiválás";
|
|
var edit$c = "Szerkesztés";
|
|
var edit_title$c = "Szezon szerkesztése";
|
|
var create_title$9 = "Új Szezon";
|
|
var name$b = "Név";
|
|
var name_placeholder$5 = "pl. 2026 Q1 Szezon";
|
|
var start_date$4 = "Kezdő dátum";
|
|
var end_date$4 = "Záró dátum";
|
|
var activate_on_create$1 = "Aktiválás létrehozáskor";
|
|
var cancel$g = "Mégse";
|
|
var save$j = "Mentés";
|
|
var create_btn$5 = "Létrehozás";
|
|
var activate_title$1 = "Szezon aktiválása";
|
|
var activate_confirm$1 = "Biztosan aktiválni szeretnéd";
|
|
var activate_warning$1 = "Ez deaktiválja az összes többi szezont.";
|
|
var activating$1 = "Aktiválás...";
|
|
var activate_btn$1 = "Aktiválás";
|
|
var save_error$a = "Nem sikerült menteni a szezont.";
|
|
const locale_seasons_46json_075b46de = {
|
|
title: title$w,
|
|
subtitle: subtitle$q,
|
|
loading: loading$x,
|
|
error: error$k,
|
|
retry: retry$t,
|
|
create: create$9,
|
|
no_items: no_items$9,
|
|
create_first: create_first$6,
|
|
active: active$6,
|
|
inactive: inactive$6,
|
|
created_at: created_at$3,
|
|
activate: activate$5,
|
|
edit: edit$c,
|
|
edit_title: edit_title$c,
|
|
create_title: create_title$9,
|
|
name: name$b,
|
|
name_placeholder: name_placeholder$5,
|
|
start_date: start_date$4,
|
|
end_date: end_date$4,
|
|
activate_on_create: activate_on_create$1,
|
|
cancel: cancel$g,
|
|
save: save$j,
|
|
create_btn: create_btn$5,
|
|
activate_title: activate_title$1,
|
|
activate_confirm: activate_confirm$1,
|
|
activate_warning: activate_warning$1,
|
|
activating: activating$1,
|
|
activate_btn: activate_btn$1,
|
|
save_error: save_error$a
|
|
};
|
|
|
|
var title$v = "Versenyek";
|
|
var subtitle$p = "Szezonális versenyek kezelése";
|
|
var loading$w = "Versenyek betöltése...";
|
|
var error$j = "Nem sikerült betölteni a versenyeket.";
|
|
var retry$s = "Újrapróbálkozás";
|
|
var create$8 = "Új Verseny";
|
|
var no_items$8 = "Még nincsenek versenyek létrehozva.";
|
|
var create_first$5 = "Első Verseny Létrehozása";
|
|
var season_filter$1 = "Szezon szűrő:";
|
|
var all_seasons$1 = "Összes szezon";
|
|
var active_badge$1 = "(Aktív)";
|
|
var status_active$5 = "Aktív";
|
|
var status_draft$1 = "Draft";
|
|
var status_completed$1 = "Befejezett";
|
|
var status_cancelled$1 = "Törölt";
|
|
var view_rules$1 = "Szabályok megtekintése";
|
|
var edit$b = "Szerkesztés";
|
|
var cancel$f = "Mégse";
|
|
var save$i = "Mentés";
|
|
var create_title$8 = "Verseny létrehozása";
|
|
var edit_title$b = "Verseny szerkesztése";
|
|
var name$a = "Név";
|
|
var name_placeholder$4 = "Pl. Q1 Szerviz Beküldő Verseny";
|
|
var description$4 = "Leírás";
|
|
var desc_placeholder$3 = "Verseny leírása...";
|
|
var season$1 = "Szezon";
|
|
var select_season$1 = "Válassz szezont";
|
|
var start_date$3 = "Kezdő dátum";
|
|
var end_date$3 = "Záró dátum";
|
|
var status$e = "Státusz";
|
|
var rules$1 = "Szabályok (JSON)";
|
|
var rules_placeholder$1 = "type: service_submission, points_multiplier: 1.5";
|
|
var invalid_json$5 = "Érvénytelen JSON formátum!";
|
|
var create_btn$4 = "Létrehozás";
|
|
var season_id_label$1 = "Szezon ID:";
|
|
var save_error$9 = "Hiba történt a mentés során.";
|
|
const locale_competitions_46json_2f85d252 = {
|
|
title: title$v,
|
|
subtitle: subtitle$p,
|
|
loading: loading$w,
|
|
error: error$j,
|
|
retry: retry$s,
|
|
create: create$8,
|
|
no_items: no_items$8,
|
|
create_first: create_first$5,
|
|
season_filter: season_filter$1,
|
|
all_seasons: all_seasons$1,
|
|
active_badge: active_badge$1,
|
|
status_active: status_active$5,
|
|
status_draft: status_draft$1,
|
|
status_completed: status_completed$1,
|
|
status_cancelled: status_cancelled$1,
|
|
view_rules: view_rules$1,
|
|
edit: edit$b,
|
|
cancel: cancel$f,
|
|
save: save$i,
|
|
create_title: create_title$8,
|
|
edit_title: edit_title$b,
|
|
name: name$a,
|
|
name_placeholder: name_placeholder$4,
|
|
description: description$4,
|
|
desc_placeholder: desc_placeholder$3,
|
|
season: season$1,
|
|
select_season: select_season$1,
|
|
start_date: start_date$3,
|
|
end_date: end_date$3,
|
|
status: status$e,
|
|
rules: rules$1,
|
|
rules_placeholder: rules_placeholder$1,
|
|
invalid_json: invalid_json$5,
|
|
create_btn: create_btn$4,
|
|
season_id_label: season_id_label$1,
|
|
save_error: save_error$9
|
|
};
|
|
|
|
var title$u = "Ranglista";
|
|
var subtitle$o = "Gamification ranglista admin nézet";
|
|
var search$4 = "Keresés";
|
|
var level$8 = "Szint";
|
|
var min_xp$4 = "Minimum XP";
|
|
var sort$1 = "Rendezés";
|
|
var sort_xp$1 = "XP szerint";
|
|
var sort_points$1 = "Pontok szerint";
|
|
var sort_social$1 = "Szociális pontok szerint";
|
|
var sort_level$1 = "Szint szerint";
|
|
var filter$4 = "Szűrés";
|
|
var reset$4 = "Visszaállítás";
|
|
var descending$2 = "Csökkenő";
|
|
var ascending$2 = "Növekvő";
|
|
var user$4 = "felhasználó";
|
|
var loading$v = "Ranglista betöltése...";
|
|
var error$i = "Nem sikerült betölteni a ranglistát.";
|
|
var retry$r = "Újrapróbálkozás";
|
|
var no_results$b = "Nincs találat a megadott szűrőkkel.";
|
|
var no_results_hint$4 = "Próbálj más szűrési feltételeket használni.";
|
|
var user_col$1 = "Felhasználó";
|
|
var email$7 = "Email";
|
|
var xp$7 = "XP";
|
|
var points$9 = "Pontok";
|
|
var social$1 = "Szociális";
|
|
var penalty$7 = "Büntetés";
|
|
var restriction$4 = "Restrikció";
|
|
var discoveries$4 = "Felfedezések";
|
|
var services$6 = "Szolgáltatások";
|
|
var updated$a = "Utolsó módosítás";
|
|
var actions$g = "Műveletek";
|
|
var details$7 = "Részletek";
|
|
var prev$a = "Előző";
|
|
var next$a = "Következő";
|
|
var page_of$1 = "/ oldal";
|
|
var restriction_mild$4 = "Enyhe";
|
|
var restriction_moderate$4 = "Közepes";
|
|
var restriction_severe$4 = "Súlyos";
|
|
const locale_leaderboard_46json_a72f79f0 = {
|
|
title: title$u,
|
|
subtitle: subtitle$o,
|
|
search: search$4,
|
|
level: level$8,
|
|
min_xp: min_xp$4,
|
|
sort: sort$1,
|
|
sort_xp: sort_xp$1,
|
|
sort_points: sort_points$1,
|
|
sort_social: sort_social$1,
|
|
sort_level: sort_level$1,
|
|
filter: filter$4,
|
|
reset: reset$4,
|
|
descending: descending$2,
|
|
ascending: ascending$2,
|
|
user: user$4,
|
|
loading: loading$v,
|
|
error: error$i,
|
|
retry: retry$r,
|
|
no_results: no_results$b,
|
|
no_results_hint: no_results_hint$4,
|
|
user_col: user_col$1,
|
|
email: email$7,
|
|
xp: xp$7,
|
|
points: points$9,
|
|
social: social$1,
|
|
penalty: penalty$7,
|
|
restriction: restriction$4,
|
|
discoveries: discoveries$4,
|
|
services: services$6,
|
|
updated: updated$a,
|
|
actions: actions$g,
|
|
details: details$7,
|
|
prev: prev$a,
|
|
next: next$a,
|
|
page_of: page_of$1,
|
|
restriction_mild: restriction_mild$4,
|
|
restriction_moderate: restriction_moderate$4,
|
|
restriction_severe: restriction_severe$4
|
|
};
|
|
|
|
var title$t = "Pontnapló";
|
|
var subtitle$n = "Gamification pontnapló böngészése";
|
|
var loading$u = "Pontnapló betöltése...";
|
|
var error$h = "Nem sikerült betölteni a pontnaplót.";
|
|
var user_id$6 = "User ID";
|
|
var date_from$1 = "Dátumtól";
|
|
var date_to$1 = "Dátumig";
|
|
var reason$1 = "Ok";
|
|
var search$3 = "Keresés";
|
|
var clear$1 = "Törlés";
|
|
var csv$1 = "CSV";
|
|
var no_results$a = "Nincs találat a megadott szűrőkkel.";
|
|
var no_results_hint$3 = "Próbálj más szűrési feltételeket használni.";
|
|
var id$4 = "ID";
|
|
var user$3 = "User";
|
|
var points$8 = "Pont";
|
|
var penalty$6 = "Büntetés";
|
|
var xp$6 = "XP";
|
|
var source$1 = "Forrás";
|
|
var date$1 = "Dátum";
|
|
var prev$9 = "Előző";
|
|
var next$9 = "Következő";
|
|
var of$1 = "/";
|
|
var showing$5 = "mutatva";
|
|
var filtered$1 = "(szűrve)";
|
|
var no_csv_data$1 = "Nincs adat a CSV exportáláshoz.";
|
|
var csv_downloaded$1 = "CSV letöltés elindítva.";
|
|
const locale_ledger_46json_eba48ff6 = {
|
|
title: title$t,
|
|
subtitle: subtitle$n,
|
|
loading: loading$u,
|
|
error: error$h,
|
|
user_id: user_id$6,
|
|
date_from: date_from$1,
|
|
date_to: date_to$1,
|
|
reason: reason$1,
|
|
search: search$3,
|
|
clear: clear$1,
|
|
csv: csv$1,
|
|
no_results: no_results$a,
|
|
no_results_hint: no_results_hint$3,
|
|
id: id$4,
|
|
user: user$3,
|
|
points: points$8,
|
|
penalty: penalty$6,
|
|
xp: xp$6,
|
|
source: source$1,
|
|
date: date$1,
|
|
prev: prev$9,
|
|
next: next$9,
|
|
of: of$1,
|
|
showing: showing$5,
|
|
filtered: filtered$1,
|
|
no_csv_data: no_csv_data$1,
|
|
csv_downloaded: csv_downloaded$1
|
|
};
|
|
|
|
var title$s = "Rendszerparaméterek";
|
|
var subtitle$m = "Gamification kategóriájú rendszerparaméterek";
|
|
var loading$t = "Paraméterek betöltése...";
|
|
var error$g = "Nem sikerült betölteni a rendszerparamétereket.";
|
|
var retry$q = "Újrapróbálkozás";
|
|
var no_items$7 = "Nincsenek gamification rendszerparaméterek.";
|
|
var key$2 = "Kulcs";
|
|
var value$2 = "Érték";
|
|
var category$1 = "Kategória";
|
|
var scope$1 = "Hatósugár";
|
|
var scope_id$3 = "Scope ID";
|
|
var actions$f = "Műveletek";
|
|
var edit$a = "Szerkesztés";
|
|
var edit_title$a = "Paraméter szerkesztése";
|
|
var value_label$1 = "Érték";
|
|
var value_placeholder$1 = "Paraméter értéke (JSON vagy sima szöveg)";
|
|
var json_detected$1 = "🔹 JSON formátum érzékelve";
|
|
var text_value$1 = "🔸 Szöveges érték";
|
|
var cancel$e = "Mégse";
|
|
var save$h = "Mentés";
|
|
var saving$a = "Mentés...";
|
|
var invalid_json$4 = "Érvénytelen JSON formátum: ";
|
|
var save_error$8 = "Hiba történt a mentés során.";
|
|
var updated$9 = "frissítve!";
|
|
const locale_params_46json_11c105c4 = {
|
|
title: title$s,
|
|
subtitle: subtitle$m,
|
|
loading: loading$t,
|
|
error: error$g,
|
|
retry: retry$q,
|
|
no_items: no_items$7,
|
|
key: key$2,
|
|
value: value$2,
|
|
category: category$1,
|
|
scope: scope$1,
|
|
scope_id: scope_id$3,
|
|
actions: actions$f,
|
|
edit: edit$a,
|
|
edit_title: edit_title$a,
|
|
value_label: value_label$1,
|
|
value_placeholder: value_placeholder$1,
|
|
json_detected: json_detected$1,
|
|
text_value: text_value$1,
|
|
cancel: cancel$e,
|
|
save: save$h,
|
|
saving: saving$a,
|
|
invalid_json: invalid_json$4,
|
|
save_error: save_error$8,
|
|
updated: updated$9
|
|
};
|
|
|
|
var title$r = "Csomagok Kezelése";
|
|
var subtitle$l = "Előfizetési csomagok és funkciók kezelése — Free, Premium, Enterprise";
|
|
var loading$s = "Csomagok betöltése...";
|
|
var retry$p = "Újra";
|
|
var create_new$1 = "Új Csomag";
|
|
var no_packages$1 = "Még nincsenek csomagok";
|
|
var no_packages_desc$1 = "Hozd létre az első előfizetési csomagot a kezdéshez.";
|
|
var create_first$4 = "Első Csomag Létrehozása";
|
|
var popular$1 = "Népszerű";
|
|
var fallback_badge$1 = "Visszaesési";
|
|
var trial_badge$1 = "Próba";
|
|
var month$1 = "hó";
|
|
var feature_flags$4 = "Elérhető Funkciók";
|
|
var edit$9 = "Szerkesztés";
|
|
var duplicate$1 = "Másolás";
|
|
var set_as_default$1 = "Beállítás alapértelmezettként";
|
|
var set_as_default_success$1 = "alapértelmezett csomagként beállítva!";
|
|
var edit_title$9 = "Csomag Szerkesztése";
|
|
var create_title$7 = "Csomag Létrehozása";
|
|
var cancel$d = "Mégse";
|
|
var save$g = "Változtatások Mentése";
|
|
var create$7 = "Létrehozás";
|
|
var save_success$1 = "Csomag sikeresen frissítve!";
|
|
var delete_title$4 = "Csomag Törlése";
|
|
var delete_confirm$4 = "Biztosan törölni szeretnéd a \"{name}\" csomagot?";
|
|
var delete_btn$4 = "Törlés";
|
|
var allowances$1 = "Korlátok";
|
|
var max_vehicles$3 = "Max Jármű";
|
|
var max_garages$3 = "Max Garázs";
|
|
var max_users$1 = "Max Dolgozó";
|
|
var monthly_credits$1 = "Havi Kredit";
|
|
var tier_level$3 = "Szint";
|
|
var form_name$1 = "Rendszer Név";
|
|
var form_name_placeholder$1 = "pl. premium_2024";
|
|
var form_display_name$1 = "Megjelenítési Név";
|
|
var form_display_name_placeholder$1 = "pl. Premium Plus";
|
|
var form_type$1 = "Típus";
|
|
var type_private$1 = "Magán";
|
|
var type_corporate$3 = "Vállalati";
|
|
var form_tier_level$1 = "Szintszám";
|
|
var form_tier_level_hint$1 = "Magasabb szám = több funkció és magasabb rang";
|
|
var form_monthly_price$1 = "Havi Díj";
|
|
var form_yearly_price$1 = "Éves Díj";
|
|
var form_currency$1 = "Pénznem";
|
|
var form_subtitle$1 = "Felirat / Leírás";
|
|
var form_subtitle_placeholder$1 = "pl. Ideális kisvállalkozásoknak";
|
|
var form_badge$1 = "Jelvény Szöveg";
|
|
var form_badge_placeholder$1 = "pl. Legnépszerűbb";
|
|
var form_is_custom$1 = "Egyedi Csomag (nem publikus)";
|
|
var singleton_rules$1 = "Egyediségi Szabályok";
|
|
var form_is_default_fallback$1 = "Alapértelmezett Visszaesési Csomag — lejárt előfizetés esetén erre vált";
|
|
var form_trial_days$1 = "Próba Napok Regisztrációnál";
|
|
var form_trial_days_hint$1 = "Az új szervezetek ennyi ingyenes napot kapnak. Csak egy csomagnál lehet > 0.";
|
|
var per_region_pricing$1 = "Régiók szerinti árazás";
|
|
var smart_calculator$1 = "Okos Árkalkulátor";
|
|
var calc_net_price$1 = "Nettó ár";
|
|
var calc_vat_rate$1 = "ÁFA kulcs";
|
|
var calc_currency$1 = "Pénznem";
|
|
var calc_net$1 = "Nettó";
|
|
var calc_vat$1 = "ÁFA";
|
|
var calc_gross$1 = "Bruttó";
|
|
var calc_apply$1 = "Alkalmaz a kiválasztott régióra";
|
|
var add_zone$1 = "Új Zóna Hozzáadása";
|
|
var add_zone_select$1 = "Válassz országkódot...";
|
|
var add_zone_already_exists$1 = "Ez a régió már létezik a csomag árazásában!";
|
|
const locale_packages_46json_15bd53c5 = {
|
|
title: title$r,
|
|
subtitle: subtitle$l,
|
|
loading: loading$s,
|
|
retry: retry$p,
|
|
create_new: create_new$1,
|
|
no_packages: no_packages$1,
|
|
no_packages_desc: no_packages_desc$1,
|
|
create_first: create_first$4,
|
|
popular: popular$1,
|
|
fallback_badge: fallback_badge$1,
|
|
trial_badge: trial_badge$1,
|
|
month: month$1,
|
|
feature_flags: feature_flags$4,
|
|
edit: edit$9,
|
|
duplicate: duplicate$1,
|
|
"delete": "Törlés",
|
|
set_as_default: set_as_default$1,
|
|
set_as_default_success: set_as_default_success$1,
|
|
edit_title: edit_title$9,
|
|
create_title: create_title$7,
|
|
cancel: cancel$d,
|
|
save: save$g,
|
|
create: create$7,
|
|
save_success: save_success$1,
|
|
delete_title: delete_title$4,
|
|
delete_confirm: delete_confirm$4,
|
|
delete_btn: delete_btn$4,
|
|
allowances: allowances$1,
|
|
max_vehicles: max_vehicles$3,
|
|
max_garages: max_garages$3,
|
|
max_users: max_users$1,
|
|
monthly_credits: monthly_credits$1,
|
|
tier_level: tier_level$3,
|
|
form_name: form_name$1,
|
|
form_name_placeholder: form_name_placeholder$1,
|
|
form_display_name: form_display_name$1,
|
|
form_display_name_placeholder: form_display_name_placeholder$1,
|
|
form_type: form_type$1,
|
|
type_private: type_private$1,
|
|
type_corporate: type_corporate$3,
|
|
form_tier_level: form_tier_level$1,
|
|
form_tier_level_hint: form_tier_level_hint$1,
|
|
form_monthly_price: form_monthly_price$1,
|
|
form_yearly_price: form_yearly_price$1,
|
|
form_currency: form_currency$1,
|
|
form_subtitle: form_subtitle$1,
|
|
form_subtitle_placeholder: form_subtitle_placeholder$1,
|
|
form_badge: form_badge$1,
|
|
form_badge_placeholder: form_badge_placeholder$1,
|
|
form_is_custom: form_is_custom$1,
|
|
singleton_rules: singleton_rules$1,
|
|
form_is_default_fallback: form_is_default_fallback$1,
|
|
form_trial_days: form_trial_days$1,
|
|
form_trial_days_hint: form_trial_days_hint$1,
|
|
per_region_pricing: per_region_pricing$1,
|
|
smart_calculator: smart_calculator$1,
|
|
calc_net_price: calc_net_price$1,
|
|
calc_vat_rate: calc_vat_rate$1,
|
|
calc_currency: calc_currency$1,
|
|
calc_net: calc_net$1,
|
|
calc_vat: calc_vat$1,
|
|
calc_gross: calc_gross$1,
|
|
calc_apply: calc_apply$1,
|
|
add_zone: add_zone$1,
|
|
add_zone_select: add_zone_select$1,
|
|
add_zone_already_exists: add_zone_already_exists$1
|
|
};
|
|
|
|
var title$q = "Személyek Kezelése";
|
|
var subtitle$k = "Személyek listája, keresés, szűrők és részletek";
|
|
var loading$r = "Személyek betöltése...";
|
|
var retry$o = "Újra";
|
|
var search_placeholder$6 = "Keresés név, telefonszám vagy e-mail alapján...";
|
|
var all_ghost_statuses$1 = "Összes szellem státusz";
|
|
var ghost_no$1 = "Nem szellem";
|
|
var ghost_yes$1 = "Szellem";
|
|
var all_active_statuses$1 = "Összes aktív státusz";
|
|
var active_yes$1 = "Aktív";
|
|
var active_no$1 = "Inaktív";
|
|
var all_user_statuses$1 = "Összes felhasználói státusz";
|
|
var has_user_yes$1 = "Van felhasználó";
|
|
var has_user_no$1 = "Nincs felhasználó";
|
|
var all_merged_statuses$1 = "Összes egyesítési státusz";
|
|
var merged_no$1 = "Nincs egyesítve";
|
|
var merged_yes$1 = "Egyesítve";
|
|
var total_persons$1 = "Összes Személy";
|
|
var active_persons$1 = "Aktív Személyek";
|
|
var ghost_persons$1 = "Szellem Személyek";
|
|
var merged_persons$1 = "Egyesített Személyek";
|
|
var filtered_results$3 = "Szűrt eredmények";
|
|
var name$9 = "Név";
|
|
var phone$3 = "Telefonszám";
|
|
var birth_date$3 = "Születési Dátum";
|
|
var status$d = "Státusz";
|
|
var users_count$1 = "Felhasználók";
|
|
var active_user$1 = "Aktív Felhasználó";
|
|
var address$5 = "Cím";
|
|
var actions$e = "Műveletek";
|
|
var active$5 = "Aktív";
|
|
var inactive$5 = "Inaktív";
|
|
var ghost$1 = "Szellem";
|
|
var merged$1 = "Egyesítve";
|
|
var view$5 = "Megtekintés";
|
|
var no_results$9 = "Nincs a keresésnek megfelelő személy.";
|
|
var showing$4 = "Mutató";
|
|
var prev$8 = "Előző";
|
|
var next$8 = "Következő";
|
|
var details$6 = {
|
|
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_persons_46json_39baf6d4 = {
|
|
title: title$q,
|
|
subtitle: subtitle$k,
|
|
loading: loading$r,
|
|
retry: retry$o,
|
|
search_placeholder: search_placeholder$6,
|
|
all_ghost_statuses: all_ghost_statuses$1,
|
|
ghost_no: ghost_no$1,
|
|
ghost_yes: ghost_yes$1,
|
|
all_active_statuses: all_active_statuses$1,
|
|
active_yes: active_yes$1,
|
|
active_no: active_no$1,
|
|
all_user_statuses: all_user_statuses$1,
|
|
has_user_yes: has_user_yes$1,
|
|
has_user_no: has_user_no$1,
|
|
all_merged_statuses: all_merged_statuses$1,
|
|
merged_no: merged_no$1,
|
|
merged_yes: merged_yes$1,
|
|
total_persons: total_persons$1,
|
|
active_persons: active_persons$1,
|
|
ghost_persons: ghost_persons$1,
|
|
merged_persons: merged_persons$1,
|
|
filtered_results: filtered_results$3,
|
|
name: name$9,
|
|
phone: phone$3,
|
|
birth_date: birth_date$3,
|
|
status: status$d,
|
|
users_count: users_count$1,
|
|
active_user: active_user$1,
|
|
address: address$5,
|
|
actions: actions$e,
|
|
active: active$5,
|
|
inactive: inactive$5,
|
|
ghost: ghost$1,
|
|
merged: merged$1,
|
|
view: view$5,
|
|
no_results: no_results$9,
|
|
showing: showing$4,
|
|
prev: prev$8,
|
|
next: next$8,
|
|
details: details$6
|
|
};
|
|
|
|
var title$p = "Jogosultság Kezelés";
|
|
var subtitle$j = "Jogosultsági Mátrix — Szerepkör alapú hozzáférés-vezérlés";
|
|
var loading$q = "Jogosultságok betöltése...";
|
|
var error_title$1 = "Nem sikerült betölteni a jogosultságokat";
|
|
var retry$n = "Újra";
|
|
var save_changes$1 = "Változtatások Mentése";
|
|
var discard$2 = "Elvetés";
|
|
var modified_count$1 = "{count} módosítás";
|
|
var domain_filter$1 = "Tartomány Szűrő (Sorok)";
|
|
var role_filter$1 = "Szerepkör Szűrő (Oszlopok)";
|
|
var select_all$2 = "Összes kiválasztása";
|
|
var deselect_all$2 = "Összes elrejtése";
|
|
var all_domains$1 = "Minden";
|
|
var permission$2 = "Engedély";
|
|
var no_permissions$1 = "Nincsenek engedélyek ebben a tartományban.";
|
|
var current_tier$1 = "Aktuális Csomag";
|
|
var expires$3 = "Lejárat";
|
|
var superadmin$1 = "Superadmin";
|
|
var superadmin_desc$1 = "Teljes rendszer hozzáférés — felhasználók, számlázás, robotok és rendszerkonfiguráció.";
|
|
var garages$2 = "Garázsok";
|
|
var garages_desc$1 = "Garázs szintű hozzáférés — járműkezelés, szervizfoglalás, ügyféladatok.";
|
|
var feature_flags$3 = "Feature Flags";
|
|
var feature_flags_desc$1 = "Előfizetési funkciók — a jelenlegi csomagod alapján ({tier}).";
|
|
var rbac_title$1 = "RBAC Jogosultsági Mátrix";
|
|
var rbac_desc$1 = "Szerepkör alapú hozzáférés-vezérlés — mely szerepkörök mely admin műveleteket végezhetik.";
|
|
var action$2 = "Művelet";
|
|
const locale_permissions_46json_10a6b504 = {
|
|
title: title$p,
|
|
subtitle: subtitle$j,
|
|
loading: loading$q,
|
|
error_title: error_title$1,
|
|
retry: retry$n,
|
|
save_changes: save_changes$1,
|
|
discard: discard$2,
|
|
modified_count: modified_count$1,
|
|
domain_filter: domain_filter$1,
|
|
role_filter: role_filter$1,
|
|
select_all: select_all$2,
|
|
deselect_all: deselect_all$2,
|
|
all_domains: all_domains$1,
|
|
permission: permission$2,
|
|
no_permissions: no_permissions$1,
|
|
current_tier: current_tier$1,
|
|
expires: expires$3,
|
|
superadmin: superadmin$1,
|
|
superadmin_desc: superadmin_desc$1,
|
|
garages: garages$2,
|
|
garages_desc: garages_desc$1,
|
|
feature_flags: feature_flags$3,
|
|
feature_flags_desc: feature_flags_desc$1,
|
|
rbac_title: rbac_title$1,
|
|
rbac_desc: rbac_desc$1,
|
|
action: action$2
|
|
};
|
|
|
|
var title$o = "Felhasználó Kezelés";
|
|
var subtitle$i = "Felhasználói lista, keresés, szűrők és csoportos műveletek";
|
|
var loading$p = "Felhasználók betöltése...";
|
|
var retry$m = "Újra";
|
|
var search_placeholder$5 = "Keresés e-mail, név vagy telefonszám alapján...";
|
|
var all_statuses$1 = "Összes státusz";
|
|
var status_active$4 = "Aktív";
|
|
var status_inactive$3 = "Inaktív";
|
|
var status_deleted$1 = "Törölt";
|
|
var status_banned$1 = "Kitiltva";
|
|
var all_roles$1 = "Összes szerepkör";
|
|
var role_user$1 = "Felhasználó";
|
|
var role_admin$1 = "Admin";
|
|
var role_staff$1 = "Munkatárs";
|
|
var role_superadmin$1 = "Superadmin";
|
|
var all_plans$1 = "Összes csomag";
|
|
var plan_free$1 = "Ingyenes";
|
|
var plan_premium$1 = "Prémium";
|
|
var plan_enterprise$1 = "Vállalati";
|
|
var total_users$2 = "Összes Felhasználó";
|
|
var active_users$1 = "Aktív Felhasználók";
|
|
var deleted_users$1 = "Törölt Felhasználók";
|
|
var banned_users$1 = "Kitiltott Felhasználók";
|
|
var new_today$1 = "Ma Regisztráltak";
|
|
var filtered_results$2 = "Szűrt eredmények";
|
|
var selected_count$1 = "{count} felhasználó kiválasztva";
|
|
var bulk_activate$1 = "Aktiválás";
|
|
var bulk_deactivate$1 = "Deaktiválás";
|
|
var clear_selection$1 = "Kijelölés törlése";
|
|
var email$6 = "E-mail";
|
|
var name$8 = "Név";
|
|
var role$4 = "Szerepkör";
|
|
var status$c = "Státusz";
|
|
var registration$1 = "Regisztráció";
|
|
var language$1 = "Nyelv";
|
|
var actions$d = "Műveletek";
|
|
var view$4 = "Megtekintés";
|
|
var activate$4 = "Aktiválás";
|
|
var deactivate$3 = "Deaktiválás";
|
|
var no_results$8 = "Nincs a keresésnek megfelelő felhasználó.";
|
|
var showing$3 = "Mutató";
|
|
var prev$7 = "Előző";
|
|
var next$7 = "Következő";
|
|
const locale_users_46json_304d0127 = {
|
|
title: title$o,
|
|
subtitle: subtitle$i,
|
|
loading: loading$p,
|
|
retry: retry$m,
|
|
search_placeholder: search_placeholder$5,
|
|
all_statuses: all_statuses$1,
|
|
status_active: status_active$4,
|
|
status_inactive: status_inactive$3,
|
|
status_deleted: status_deleted$1,
|
|
status_banned: status_banned$1,
|
|
all_roles: all_roles$1,
|
|
role_user: role_user$1,
|
|
role_admin: role_admin$1,
|
|
role_staff: role_staff$1,
|
|
role_superadmin: role_superadmin$1,
|
|
all_plans: all_plans$1,
|
|
plan_free: plan_free$1,
|
|
plan_premium: plan_premium$1,
|
|
plan_enterprise: plan_enterprise$1,
|
|
total_users: total_users$2,
|
|
active_users: active_users$1,
|
|
deleted_users: deleted_users$1,
|
|
banned_users: banned_users$1,
|
|
new_today: new_today$1,
|
|
filtered_results: filtered_results$2,
|
|
selected_count: selected_count$1,
|
|
bulk_activate: bulk_activate$1,
|
|
bulk_deactivate: bulk_deactivate$1,
|
|
clear_selection: clear_selection$1,
|
|
email: email$6,
|
|
name: name$8,
|
|
role: role$4,
|
|
status: status$c,
|
|
"package": "Csomag",
|
|
registration: registration$1,
|
|
language: language$1,
|
|
actions: actions$d,
|
|
view: view$4,
|
|
activate: activate$4,
|
|
deactivate: deactivate$3,
|
|
no_results: no_results$8,
|
|
showing: showing$3,
|
|
prev: prev$7,
|
|
next: next$7
|
|
};
|
|
|
|
var loading$o = "Felhasználó adatainak betöltése...";
|
|
var retry$l = "Újra";
|
|
var back$6 = "Vissza a felhasználókhoz";
|
|
var edit$8 = "Felhasználó szerkesztése";
|
|
var edit_user$1 = "Felhasználó szerkesztése";
|
|
var profile_tab$1 = "Profil";
|
|
var memberships_tab$1 = "Tagságok";
|
|
var account_info$1 = "Fiók Információk";
|
|
var user_id$5 = "Felhasználó ID";
|
|
var registration_date$1 = "Regisztráció Dátuma";
|
|
var last_login$1 = "Utolsó Belépés";
|
|
var ui_mode$1 = "UI Mód";
|
|
var region$1 = "Régió";
|
|
var currency$1 = "Pénznem";
|
|
var subscription_info$3 = "Előfizetés Információk";
|
|
var subscription_expires$1 = "Lejárat Dátuma";
|
|
var scope_level$1 = "Hatósugár Szint";
|
|
var scope_id$2 = "Hatósugár ID";
|
|
var max_vehicles$2 = "Max Járművek";
|
|
var max_garages$2 = "Max Garázsok";
|
|
var personal_info$1 = "Személyes Információk";
|
|
var last_name$1 = "Vezetéknév";
|
|
var first_name$1 = "Keresztnév";
|
|
var phone$2 = "Telefon";
|
|
var birth_place$1 = "Születési Hely";
|
|
var birth_date$2 = "Születési Dátum";
|
|
var mothers_name$1 = "Anyja Neve";
|
|
var mothers_first_name$1 = "Anyja Keresztneve";
|
|
var address$4 = "Cím";
|
|
var zip$3 = "Irányítószám";
|
|
var city$3 = "Város";
|
|
var street$1 = "Utca";
|
|
var house_number$3 = "Házszám";
|
|
var no_person_record$1 = "Nem található személyes adat ehhez a felhasználóhoz.";
|
|
var memberships$1 = "Szervezeti Tagságok";
|
|
var memberships_count$1 = "{count} tagság";
|
|
var no_memberships$1 = "Ez a felhasználó nem tagja egyetlen szervezetnek sem.";
|
|
var org_name$1 = "Szervezet";
|
|
var org_role$1 = "Szerepkör";
|
|
var member_status$1 = "Státusz";
|
|
var joined_at$1 = "Csatlakozott";
|
|
var verified$1 = "Hitelesítve";
|
|
var verified_yes$1 = "Igen";
|
|
var verified_no$1 = "Nem";
|
|
var preferred_language$1 = "Előnyben Részesített Nyelv";
|
|
var is_active$2 = "Aktív";
|
|
var is_vip$1 = "VIP";
|
|
var cancel$c = "Mégse";
|
|
var save$f = "Változtatások Mentése";
|
|
var saving$9 = "Mentés...";
|
|
const locale_user_detail_46json_f916c048 = {
|
|
loading: loading$o,
|
|
retry: retry$l,
|
|
back: back$6,
|
|
edit: edit$8,
|
|
edit_user: edit_user$1,
|
|
profile_tab: profile_tab$1,
|
|
memberships_tab: memberships_tab$1,
|
|
account_info: account_info$1,
|
|
user_id: user_id$5,
|
|
registration_date: registration_date$1,
|
|
last_login: last_login$1,
|
|
ui_mode: ui_mode$1,
|
|
region: region$1,
|
|
currency: currency$1,
|
|
subscription_info: subscription_info$3,
|
|
subscription_expires: subscription_expires$1,
|
|
scope_level: scope_level$1,
|
|
scope_id: scope_id$2,
|
|
max_vehicles: max_vehicles$2,
|
|
max_garages: max_garages$2,
|
|
personal_info: personal_info$1,
|
|
last_name: last_name$1,
|
|
first_name: first_name$1,
|
|
phone: phone$2,
|
|
birth_place: birth_place$1,
|
|
birth_date: birth_date$2,
|
|
mothers_name: mothers_name$1,
|
|
mothers_first_name: mothers_first_name$1,
|
|
address: address$4,
|
|
zip: zip$3,
|
|
city: city$3,
|
|
street: street$1,
|
|
house_number: house_number$3,
|
|
no_person_record: no_person_record$1,
|
|
memberships: memberships$1,
|
|
memberships_count: memberships_count$1,
|
|
no_memberships: no_memberships$1,
|
|
org_name: org_name$1,
|
|
org_role: org_role$1,
|
|
member_status: member_status$1,
|
|
joined_at: joined_at$1,
|
|
verified: verified$1,
|
|
verified_yes: verified_yes$1,
|
|
verified_no: verified_no$1,
|
|
preferred_language: preferred_language$1,
|
|
is_active: is_active$2,
|
|
is_vip: is_vip$1,
|
|
cancel: cancel$c,
|
|
save: save$f,
|
|
saving: saving$9
|
|
};
|
|
|
|
var title$n = "Gamification Felhasználók";
|
|
var subtitle$h = "Felhasználói gamification statisztikák kezelése";
|
|
var loading$n = "Felhasználók betöltése...";
|
|
var error$f = "Nem sikerült betölteni a felhasználói statisztikákat.";
|
|
var retry$k = "Újra";
|
|
var no_results$7 = "Nincsenek megjeleníthető felhasználói statisztikák.";
|
|
var level$7 = "Szint";
|
|
var all_levels$1 = "Minden Szint";
|
|
var level_n$3 = "{n}. szint";
|
|
var min_xp$3 = "Minimum XP";
|
|
var max_xp$1 = "Maximum XP";
|
|
var penalty$5 = "Büntetés";
|
|
var any$1 = "Bármelyik";
|
|
var only_penalized$1 = "Csak büntetettek";
|
|
var only_clean$1 = "Csak tiszták";
|
|
var filter$3 = "Szűrés";
|
|
var reset$3 = "Visszaállítás";
|
|
var count$1 = "felhasználó";
|
|
var user_id$4 = "Felhasználó ID";
|
|
var xp$5 = "XP";
|
|
var points$7 = "Pontok";
|
|
var restriction$3 = "Korlátozás";
|
|
var services$5 = "Szolgáltatások";
|
|
var discoveries$3 = "Felfedezések";
|
|
var updated$8 = "Utolsó frissítés";
|
|
var actions$c = "Műveletek";
|
|
var details$5 = "Részletek";
|
|
var prev$6 = "Előző";
|
|
var next$6 = "Következő";
|
|
var none$3 = "Nincs";
|
|
var restriction_mild$3 = "Enyhe";
|
|
var restriction_moderate$3 = "Mérsékelt";
|
|
var restriction_severe$3 = "Súlyos";
|
|
const locale_gamification_users_46json_a890945b = {
|
|
title: title$n,
|
|
subtitle: subtitle$h,
|
|
loading: loading$n,
|
|
error: error$f,
|
|
retry: retry$k,
|
|
no_results: no_results$7,
|
|
level: level$7,
|
|
all_levels: all_levels$1,
|
|
level_n: level_n$3,
|
|
min_xp: min_xp$3,
|
|
max_xp: max_xp$1,
|
|
penalty: penalty$5,
|
|
any: any$1,
|
|
only_penalized: only_penalized$1,
|
|
only_clean: only_clean$1,
|
|
filter: filter$3,
|
|
reset: reset$3,
|
|
count: count$1,
|
|
user_id: user_id$4,
|
|
xp: xp$5,
|
|
points: points$7,
|
|
restriction: restriction$3,
|
|
services: services$5,
|
|
discoveries: discoveries$3,
|
|
updated: updated$8,
|
|
actions: actions$c,
|
|
details: details$5,
|
|
prev: prev$6,
|
|
next: next$6,
|
|
none: none$3,
|
|
restriction_mild: restriction_mild$3,
|
|
restriction_moderate: restriction_moderate$3,
|
|
restriction_severe: restriction_severe$3
|
|
};
|
|
|
|
var back$5 = "Vissza a listához";
|
|
var title$m = "Felhasználó Gamification Részletei";
|
|
var id_label$1 = "ID:";
|
|
var loading$m = "Felhasználó betöltése...";
|
|
var error$e = "Nem sikerült betölteni a felhasználói adatokat.";
|
|
var retry$j = "Újra";
|
|
var not_found$1 = "Felhasználó nem található.";
|
|
var total_xp$1 = "Összes XP";
|
|
var level$6 = "Szint";
|
|
var total_points$1 = "Összes Pont";
|
|
var social_points$1 = "Szociális Pontok";
|
|
var penalty_points$1 = "Büntető Pontok";
|
|
var restriction_level$1 = "Korlátozás Szintje";
|
|
var penalty_quota$1 = "Büntetési Kvóta";
|
|
var banned_until$1 = "Kitiltva eddig:";
|
|
var no$2 = "Nincs";
|
|
var services$4 = "Szolgáltatások";
|
|
var discovered_places$1 = "Felfedezett Helyek";
|
|
var validated_places$1 = "Validált Helyek";
|
|
var added_providers$1 = "Hozzáadott Szolgáltatók";
|
|
var penalty_form_title$1 = "Büntetés Kiosztása";
|
|
var penalty_points_label$1 = "Büntető Pontok";
|
|
var penalty_reason_label$1 = "Indok";
|
|
var penalty_reason_placeholder$1 = "Büntetés indoka...";
|
|
var penalty_submit$1 = "Büntetés Kiosztása";
|
|
var penalty_submitting$1 = "Küldés...";
|
|
var penalty_success$1 = "Büntetés sikeresen kiosztva: {amount} pont.";
|
|
var penalty_error$1 = "Nem sikerült kiosztani a büntetést.";
|
|
var reward_form_title$1 = "Jutalom Kiosztása";
|
|
var reward_xp_label$1 = "XP Jutalom";
|
|
var reward_social_label$1 = "Szociális Pont Jutalom";
|
|
var reward_reason_label$1 = "Indok";
|
|
var reward_reason_placeholder$1 = "Jutalom indoka...";
|
|
var reward_submit$1 = "Jutalom Kiosztása";
|
|
var reward_submitting$1 = "Küldés...";
|
|
var reward_success$1 = "Jutalom sikeresen kiosztva: {xp} XP, {social} szociális pont.";
|
|
var reward_error$1 = "Nem sikerült kiosztani a jutalmat.";
|
|
var ledger_title$1 = "Pont Napló";
|
|
var ledger_count$1 = "bejegyzés";
|
|
var ledger_loading$1 = "Betöltés...";
|
|
var ledger_empty$1 = "Még nincsenek naplóbejegyzések ehhez a felhasználóhoz.";
|
|
var ledger_date$1 = "Dátum";
|
|
var ledger_points$1 = "Pontok";
|
|
var ledger_penalty$1 = "Büntetés";
|
|
var ledger_xp$1 = "XP";
|
|
var ledger_reason$1 = "Indok";
|
|
var ledger_source$1 = "Forrás";
|
|
const locale_gamification_user_detail_46json_465d14db = {
|
|
back: back$5,
|
|
title: title$m,
|
|
id_label: id_label$1,
|
|
loading: loading$m,
|
|
error: error$e,
|
|
retry: retry$j,
|
|
not_found: not_found$1,
|
|
total_xp: total_xp$1,
|
|
level: level$6,
|
|
total_points: total_points$1,
|
|
social_points: social_points$1,
|
|
penalty_points: penalty_points$1,
|
|
restriction_level: restriction_level$1,
|
|
penalty_quota: penalty_quota$1,
|
|
banned_until: banned_until$1,
|
|
no: no$2,
|
|
services: services$4,
|
|
discovered_places: discovered_places$1,
|
|
validated_places: validated_places$1,
|
|
added_providers: added_providers$1,
|
|
penalty_form_title: penalty_form_title$1,
|
|
penalty_points_label: penalty_points_label$1,
|
|
penalty_reason_label: penalty_reason_label$1,
|
|
penalty_reason_placeholder: penalty_reason_placeholder$1,
|
|
penalty_submit: penalty_submit$1,
|
|
penalty_submitting: penalty_submitting$1,
|
|
penalty_success: penalty_success$1,
|
|
penalty_error: penalty_error$1,
|
|
reward_form_title: reward_form_title$1,
|
|
reward_xp_label: reward_xp_label$1,
|
|
reward_social_label: reward_social_label$1,
|
|
reward_reason_label: reward_reason_label$1,
|
|
reward_reason_placeholder: reward_reason_placeholder$1,
|
|
reward_submit: reward_submit$1,
|
|
reward_submitting: reward_submitting$1,
|
|
reward_success: reward_success$1,
|
|
reward_error: reward_error$1,
|
|
ledger_title: ledger_title$1,
|
|
ledger_count: ledger_count$1,
|
|
ledger_loading: ledger_loading$1,
|
|
ledger_empty: ledger_empty$1,
|
|
ledger_date: ledger_date$1,
|
|
ledger_points: ledger_points$1,
|
|
ledger_penalty: ledger_penalty$1,
|
|
ledger_xp: ledger_xp$1,
|
|
ledger_reason: ledger_reason$1,
|
|
ledger_source: ledger_source$1
|
|
};
|
|
|
|
var loading$l = "Garázs adatainak betöltése...";
|
|
var retry$i = "Újra";
|
|
var back$4 = "Vissza a garázsokhoz";
|
|
var company_info$1 = "Cég adatok";
|
|
var company_name$2 = "Cégnév";
|
|
var display_name$1 = "Megjelenítési név";
|
|
var org_type$1 = "Szervezet típusa";
|
|
var tax_number$1 = "Adószám";
|
|
var reg_number$1 = "Cégjegyzékszám";
|
|
var created_at$2 = "Létrehozva";
|
|
var address$3 = "Cím";
|
|
var subscription_info$2 = "Előfizetés státusza";
|
|
var tier_name$1 = "Csomag";
|
|
var tier_level$2 = "Szint";
|
|
var level_n$2 = "{n}. szint";
|
|
var expires_at$1 = "Lejárat";
|
|
var asset_limit$1 = "Járműkorlát";
|
|
var vehicles$1 = "jármű";
|
|
var no_subscription$1 = "Nincs aktív előfizetés";
|
|
var contact_info$1 = "Elérhetőség";
|
|
var contact_name$1 = "Kapcsolattartó neve";
|
|
var contact_role$1 = "Szerepkör";
|
|
var contact_department$1 = "Osztály";
|
|
var contact_phone$1 = "Kapcsolattartó telefon";
|
|
var no_contact$1 = "Nincs elsődleges kapcsolattartó";
|
|
var edit_details$1 = "Adatok Szerkesztése";
|
|
var save$e = "Mentés";
|
|
var generalTab$1 = "Általános";
|
|
var employeesTab$1 = "Dolgozók";
|
|
var fleetTab$1 = "Flotta";
|
|
var analyticsTab$1 = "Analitika";
|
|
var subscriptionTab$1 = "Előfizetés";
|
|
var editBasicTab$1 = "Alapadatok";
|
|
var editContactTab$1 = "Kapcsolat";
|
|
var editAddressTab$1 = "Címek";
|
|
var zip$2 = "Irányítószám";
|
|
var city$2 = "Város";
|
|
var street_name$1 = "Utca";
|
|
var street_type$1 = "Utca típusa";
|
|
var house_number$2 = "Házszám";
|
|
var coming_soon$1 = "Ez a funkció hamarosan elérhető lesz...";
|
|
var missing_data_title$1 = "Hiányzó adatok";
|
|
var missing_data_desc$1 = "A garázs profilja hiányos. Kérjük, egészítse ki a hiányzó adatokat.";
|
|
var missing_data_activation_required$1 = "A garázs aktiválásához az alábbi adatok pótlása kötelező:";
|
|
var missing_tax_number$1 = "Adószám";
|
|
var missing_billing$1 = "Számlázási cím";
|
|
var missing_contact_email$1 = "Kapcsolattartó e-mail";
|
|
var missing_contact_phone$1 = "Kapcsolattartó telefon";
|
|
var missing_data_count$1 = "{count} mező hiányzik";
|
|
var contact_person_name$1 = "Kapcsolattartó neve";
|
|
var contact_email$1 = "Kapcsolattartó e-mail";
|
|
var billing_address$1 = "Számlázási cím";
|
|
var billing_zip$1 = "Irányítószám";
|
|
var billing_city$1 = "Város";
|
|
var billing_street_name$1 = "Utca";
|
|
var billing_street_type$1 = "Utca típusa";
|
|
var billing_house_number$1 = "Házszám";
|
|
var notification_address$1 = "Értesítési cím";
|
|
var notification_zip$1 = "Irányítószám";
|
|
var notification_city$1 = "Város";
|
|
var notification_street_name$1 = "Utca";
|
|
var notification_street_type$1 = "Utca típusa";
|
|
var notification_house_number$1 = "Házszám";
|
|
var tab_basic$1 = "Alapadatok";
|
|
var tab_contact$1 = "Kapcsolat";
|
|
var tab_addresses$1 = "Címek";
|
|
var basic_info$1 = "Alapadatok";
|
|
var contact_section$1 = "Kapcsolattartó";
|
|
var addresses_section$1 = "Címek";
|
|
var vehicles_used$1 = "Járművek";
|
|
var branches_used$1 = "Telephelyek";
|
|
var employees_used$1 = "Dolgozók";
|
|
var branches$1 = "telephely";
|
|
var employees$1 = "dolgozó";
|
|
var status$b = "Státusz";
|
|
var subscription_history$1 = "Előfizetési Előzmények";
|
|
var history_date$1 = "Dátum";
|
|
var history_package$1 = "Csomag";
|
|
var history_action$1 = "Művelet";
|
|
var history_status$1 = "Státusz";
|
|
var no_subscription_history$1 = "Még nincsenek előfizetési előzmények.";
|
|
const locale_garages_45details_46json_c9e5034e = {
|
|
loading: loading$l,
|
|
retry: retry$i,
|
|
back: back$4,
|
|
company_info: company_info$1,
|
|
company_name: company_name$2,
|
|
display_name: display_name$1,
|
|
org_type: org_type$1,
|
|
tax_number: tax_number$1,
|
|
reg_number: reg_number$1,
|
|
created_at: created_at$2,
|
|
address: address$3,
|
|
subscription_info: subscription_info$2,
|
|
tier_name: tier_name$1,
|
|
tier_level: tier_level$2,
|
|
level_n: level_n$2,
|
|
expires_at: expires_at$1,
|
|
asset_limit: asset_limit$1,
|
|
vehicles: vehicles$1,
|
|
no_subscription: no_subscription$1,
|
|
contact_info: contact_info$1,
|
|
contact_name: contact_name$1,
|
|
contact_role: contact_role$1,
|
|
contact_department: contact_department$1,
|
|
contact_phone: contact_phone$1,
|
|
no_contact: no_contact$1,
|
|
edit_details: edit_details$1,
|
|
save: save$e,
|
|
generalTab: generalTab$1,
|
|
employeesTab: employeesTab$1,
|
|
fleetTab: fleetTab$1,
|
|
analyticsTab: analyticsTab$1,
|
|
subscriptionTab: subscriptionTab$1,
|
|
editBasicTab: editBasicTab$1,
|
|
editContactTab: editContactTab$1,
|
|
editAddressTab: editAddressTab$1,
|
|
zip: zip$2,
|
|
city: city$2,
|
|
street_name: street_name$1,
|
|
street_type: street_type$1,
|
|
house_number: house_number$2,
|
|
coming_soon: coming_soon$1,
|
|
missing_data_title: missing_data_title$1,
|
|
missing_data_desc: missing_data_desc$1,
|
|
missing_data_activation_required: missing_data_activation_required$1,
|
|
missing_tax_number: missing_tax_number$1,
|
|
missing_billing: missing_billing$1,
|
|
missing_contact_email: missing_contact_email$1,
|
|
missing_contact_phone: missing_contact_phone$1,
|
|
missing_data_count: missing_data_count$1,
|
|
contact_person_name: contact_person_name$1,
|
|
contact_email: contact_email$1,
|
|
billing_address: billing_address$1,
|
|
billing_zip: billing_zip$1,
|
|
billing_city: billing_city$1,
|
|
billing_street_name: billing_street_name$1,
|
|
billing_street_type: billing_street_type$1,
|
|
billing_house_number: billing_house_number$1,
|
|
notification_address: notification_address$1,
|
|
notification_zip: notification_zip$1,
|
|
notification_city: notification_city$1,
|
|
notification_street_name: notification_street_name$1,
|
|
notification_street_type: notification_street_type$1,
|
|
notification_house_number: notification_house_number$1,
|
|
tab_basic: tab_basic$1,
|
|
tab_contact: tab_contact$1,
|
|
tab_addresses: tab_addresses$1,
|
|
basic_info: basic_info$1,
|
|
contact_section: contact_section$1,
|
|
addresses_section: addresses_section$1,
|
|
vehicles_used: vehicles_used$1,
|
|
branches_used: branches_used$1,
|
|
employees_used: employees_used$1,
|
|
branches: branches$1,
|
|
employees: employees$1,
|
|
status: status$b,
|
|
subscription_history: subscription_history$1,
|
|
history_date: history_date$1,
|
|
history_package: history_package$1,
|
|
history_action: history_action$1,
|
|
history_status: history_status$1,
|
|
no_subscription_history: no_subscription_history$1
|
|
};
|
|
|
|
var title$l = "Dolgozók";
|
|
var total_count$1 = "Összesen {count} fő";
|
|
var name$7 = "Név";
|
|
var email_phone$1 = "E-mail / Telefon";
|
|
var role$3 = "Szerepkör";
|
|
var status$a = "Státusz";
|
|
var actions$b = "Műveletek";
|
|
var edit_role$1 = "Szerepkör szerkesztése";
|
|
var remove$1 = "Eltávolítás";
|
|
var no_employees$1 = "Még nincsenek tagok ehhez a garázshoz.";
|
|
var edit_role_title$1 = "Tag szerepkörének szerkesztése";
|
|
var editRoleTitle$1 = "Tag szerepkörének szerkesztése";
|
|
var editRoleFor$1 = "{name} szerepkörének módosítása";
|
|
var cancel$b = "Mégse";
|
|
var save$d = "Mentés";
|
|
var saveRole$1 = "Szerepkör mentése";
|
|
var saving$8 = "Mentés...";
|
|
var status_active$3 = "Aktív";
|
|
var status_inactive$2 = "Inaktív";
|
|
var remove_title$1 = "Tag eltávolítása";
|
|
var removeTitle$1 = "Tag eltávolítása";
|
|
var remove_confirm$1 = "Biztosan eltávolítod {name} tagot a garázsból?";
|
|
var removeConfirm$1 = "Biztosan eltávolítod {name} tagot a garázsból?";
|
|
var remove_btn$1 = "Eltávolítás";
|
|
var removing$1 = "Eltávolítás...";
|
|
var add_employee$1 = "Új dolgozó hozzáadása";
|
|
var addTitle$1 = "Új dolgozó hozzáadása";
|
|
var email$5 = "E-mail cím";
|
|
var emailPlaceholder$1 = "Add meg az e-mail címet...";
|
|
var roleMember$1 = "Tag";
|
|
var roleManager$1 = "Menedzser";
|
|
var roleAdmin$1 = "Admin";
|
|
var roleOwner$1 = "Tulajdonos";
|
|
var add$1 = "Hozzáadás";
|
|
var adding$1 = "Hozzáadás...";
|
|
const locale_garages_45employees_46json_5e5dc9e8 = {
|
|
title: title$l,
|
|
total_count: total_count$1,
|
|
name: name$7,
|
|
email_phone: email_phone$1,
|
|
role: role$3,
|
|
status: status$a,
|
|
actions: actions$b,
|
|
edit_role: edit_role$1,
|
|
remove: remove$1,
|
|
no_employees: no_employees$1,
|
|
edit_role_title: edit_role_title$1,
|
|
editRoleTitle: editRoleTitle$1,
|
|
editRoleFor: editRoleFor$1,
|
|
cancel: cancel$b,
|
|
save: save$d,
|
|
saveRole: saveRole$1,
|
|
saving: saving$8,
|
|
status_active: status_active$3,
|
|
status_inactive: status_inactive$2,
|
|
remove_title: remove_title$1,
|
|
removeTitle: removeTitle$1,
|
|
remove_confirm: remove_confirm$1,
|
|
removeConfirm: removeConfirm$1,
|
|
remove_btn: remove_btn$1,
|
|
removing: removing$1,
|
|
add_employee: add_employee$1,
|
|
addTitle: addTitle$1,
|
|
email: email$5,
|
|
emailPlaceholder: emailPlaceholder$1,
|
|
roleMember: roleMember$1,
|
|
roleManager: roleManager$1,
|
|
roleAdmin: roleAdmin$1,
|
|
roleOwner: roleOwner$1,
|
|
add: add$1,
|
|
adding: adding$1
|
|
};
|
|
|
|
var title$k = "Flotta";
|
|
var total_vehicles$1 = "Összesen {count} jármű";
|
|
var plate$1 = "Rendszám";
|
|
var brand$1 = "Márka";
|
|
var model$1 = "Modell";
|
|
var brand_model$1 = "Márka & Modell";
|
|
var year$1 = "Évjárat";
|
|
var status$9 = "Státusz";
|
|
var vin$1 = "Alvázszám";
|
|
var no_vehicles$1 = "Ehhez a garázshoz még nincsenek járművek rendelve.";
|
|
var no_fleet_access$1 = "Nincs jogosultságod a flotta adatok megtekintéséhez.";
|
|
const locale_garages_45fleet_46json_104aa8bd = {
|
|
title: title$k,
|
|
total_vehicles: total_vehicles$1,
|
|
plate: plate$1,
|
|
brand: brand$1,
|
|
model: model$1,
|
|
brand_model: brand_model$1,
|
|
year: year$1,
|
|
status: status$9,
|
|
vin: vin$1,
|
|
no_vehicles: no_vehicles$1,
|
|
no_fleet_access: no_fleet_access$1
|
|
};
|
|
|
|
var ltv$1 = "Élettartam Érték (LTV)";
|
|
var mrr$1 = "Havi Bevétel (MRR)";
|
|
var monthly_recurring$1 = "Havi ismétlődő bevétel";
|
|
var outstanding$1 = "Kintlévőség";
|
|
var all_settled$1 = "Minden számla rendezve";
|
|
var earned_credits$1 = "Szerzett Kreditek";
|
|
var contribution_xp$1 = "Platform építésével gyűjtött XP";
|
|
var invited_companies$1 = "Meghívott Cégek";
|
|
var companies_joined$1 = "Cég csatlakozott a meghívásodra";
|
|
var validated_garages$1 = "Validált Garázsok";
|
|
var garages_confirmed$1 = "Garázs sikeresen hitelesítve";
|
|
var utilization$1 = "Kihasználtság";
|
|
var vehicle_quota$1 = "Jármű Kvóta";
|
|
var employee_quota$1 = "Alkalmazotti Kvóta";
|
|
var utilized$1 = "kihasználva";
|
|
var marketplace_engagement$1 = "Piactér & Aktivitás";
|
|
var avg_rating$1 = "Átlagos Értékelés";
|
|
var reviews$1 = "Értékelések";
|
|
var reviews_count$1 = "értékelés";
|
|
var last_activity$1 = "Utolsó Aktivitás";
|
|
var last_login_mock$1 = "2 órája";
|
|
var services_30d$1 = "Elvégzett Szervizek (30 nap)";
|
|
const locale_garages_45analytics_46json_bffdef7b = {
|
|
ltv: ltv$1,
|
|
mrr: mrr$1,
|
|
monthly_recurring: monthly_recurring$1,
|
|
outstanding: outstanding$1,
|
|
all_settled: all_settled$1,
|
|
earned_credits: earned_credits$1,
|
|
contribution_xp: contribution_xp$1,
|
|
invited_companies: invited_companies$1,
|
|
companies_joined: companies_joined$1,
|
|
validated_garages: validated_garages$1,
|
|
garages_confirmed: garages_confirmed$1,
|
|
utilization: utilization$1,
|
|
vehicle_quota: vehicle_quota$1,
|
|
employee_quota: employee_quota$1,
|
|
utilized: utilized$1,
|
|
marketplace_engagement: marketplace_engagement$1,
|
|
avg_rating: avg_rating$1,
|
|
reviews: reviews$1,
|
|
reviews_count: reviews_count$1,
|
|
last_activity: last_activity$1,
|
|
last_login_mock: last_login_mock$1,
|
|
services_30d: services_30d$1
|
|
};
|
|
|
|
var loading$k = "Loading...";
|
|
var saving$7 = "Saving...";
|
|
var error$d = "An error occurred";
|
|
var retry$h = "Retry";
|
|
var save$c = "Save";
|
|
var saving_data = "Saving data...";
|
|
var cancel$a = "Cancel";
|
|
var discard$1 = "Discard";
|
|
var delete_confirm$3 = "Are you sure you want to delete this item?";
|
|
var delete_btn$3 = "Delete";
|
|
var delete_title$3 = "Confirm Deletion";
|
|
var deleted$2 = "Deleted successfully";
|
|
var edit$7 = "Edit";
|
|
var edit_title$8 = "Edit Item";
|
|
var create$6 = "Create";
|
|
var create_btn$3 = "Create";
|
|
var create_title$6 = "Create New";
|
|
var create_first$3 = "Create your first item to get started";
|
|
var search$2 = "Search";
|
|
var search_placeholder$4 = "Search...";
|
|
var filter$2 = "Filter";
|
|
var no_results$6 = "No results found";
|
|
var no_results_hint$2 = "Try adjusting your search or filter criteria";
|
|
var no_items$6 = "No items available";
|
|
var actions$a = "Actions";
|
|
var status$8 = "Status";
|
|
var active$4 = "Active";
|
|
var inactive$4 = "Inactive";
|
|
var activate$3 = "Activate";
|
|
var deactivate$2 = "Deactivate";
|
|
var name$6 = "Name";
|
|
var name_placeholder$3 = "Enter name";
|
|
var description$3 = "Description";
|
|
var desc_placeholder$2 = "Enter description";
|
|
var details$4 = "Details";
|
|
var email$4 = "Email";
|
|
var id$3 = "ID";
|
|
var type$1 = "Type";
|
|
var type_corporate$2 = "Corporate";
|
|
var view$3 = "View";
|
|
var updated$7 = "Updated successfully";
|
|
var save_error$7 = "Failed to save";
|
|
var invalid_json$3 = "Invalid JSON format";
|
|
var prev$5 = "Previous";
|
|
var next$5 = "Next";
|
|
var none$2 = "None";
|
|
var reset$2 = "Reset";
|
|
var confirm = "Confirm";
|
|
var close = "Close";
|
|
var back$3 = "Back";
|
|
var exit = "Exit";
|
|
var all = "All";
|
|
var select_all$1 = "Select All";
|
|
var deselect_all$1 = "Deselect All";
|
|
var expires$2 = "Expires";
|
|
var created$3 = "Created";
|
|
var start_date$2 = "Start Date";
|
|
var end_date$2 = "End Date";
|
|
var points$6 = "Points";
|
|
var level$5 = "Level";
|
|
var user$2 = "User";
|
|
var user_id$3 = "User ID";
|
|
var services$3 = "Services";
|
|
var discoveries$2 = "Discoveries";
|
|
var restriction$2 = "Restriction";
|
|
var restriction_mild$2 = "Mild";
|
|
var restriction_moderate$2 = "Moderate";
|
|
var restriction_severe$2 = "Severe";
|
|
var min_xp$2 = "Min XP";
|
|
var xp$4 = "XP";
|
|
var penalty$4 = "Penalty";
|
|
var feature_flags$2 = "Feature Flags";
|
|
var permission$1 = "Permission";
|
|
var role$2 = "Role";
|
|
var domain = "Domain";
|
|
var action$1 = "Action";
|
|
var value$1 = "Value";
|
|
var key$1 = "Key";
|
|
var enabled = "Enabled";
|
|
var disabled = "Disabled";
|
|
var yes = "Yes";
|
|
var no$1 = "No";
|
|
var on = "On";
|
|
var off = "Off";
|
|
var service_finder = "Service Finder";
|
|
var admin = "Admin";
|
|
var version = "Version";
|
|
var super_administrator = "Super Administrator";
|
|
var administrator = "Administrator";
|
|
var profile_settings = "Profile Settings";
|
|
var sign_out = "Sign Out";
|
|
var unknown_user = "Unknown user";
|
|
var ascending$1 = "Ascending";
|
|
var descending$1 = "Descending";
|
|
const locale_common_46json_364cfaa7 = {
|
|
loading: loading$k,
|
|
saving: saving$7,
|
|
error: error$d,
|
|
retry: retry$h,
|
|
save: save$c,
|
|
saving_data: saving_data,
|
|
cancel: cancel$a,
|
|
discard: discard$1,
|
|
"delete": "Delete",
|
|
delete_confirm: delete_confirm$3,
|
|
delete_btn: delete_btn$3,
|
|
delete_title: delete_title$3,
|
|
deleted: deleted$2,
|
|
edit: edit$7,
|
|
edit_title: edit_title$8,
|
|
create: create$6,
|
|
create_btn: create_btn$3,
|
|
create_title: create_title$6,
|
|
create_first: create_first$3,
|
|
search: search$2,
|
|
search_placeholder: search_placeholder$4,
|
|
filter: filter$2,
|
|
no_results: no_results$6,
|
|
no_results_hint: no_results_hint$2,
|
|
no_items: no_items$6,
|
|
actions: actions$a,
|
|
status: status$8,
|
|
active: active$4,
|
|
inactive: inactive$4,
|
|
activate: activate$3,
|
|
deactivate: deactivate$2,
|
|
name: name$6,
|
|
name_placeholder: name_placeholder$3,
|
|
description: description$3,
|
|
desc_placeholder: desc_placeholder$2,
|
|
details: details$4,
|
|
email: email$4,
|
|
id: id$3,
|
|
type: type$1,
|
|
type_corporate: type_corporate$2,
|
|
view: view$3,
|
|
updated: updated$7,
|
|
save_error: save_error$7,
|
|
invalid_json: invalid_json$3,
|
|
prev: prev$5,
|
|
next: next$5,
|
|
none: none$2,
|
|
reset: reset$2,
|
|
confirm: confirm,
|
|
close: close,
|
|
back: back$3,
|
|
"continue": "Continue",
|
|
exit: exit,
|
|
all: all,
|
|
select_all: select_all$1,
|
|
deselect_all: deselect_all$1,
|
|
expires: expires$2,
|
|
created: created$3,
|
|
start_date: start_date$2,
|
|
end_date: end_date$2,
|
|
points: points$6,
|
|
level: level$5,
|
|
user: user$2,
|
|
user_id: user_id$3,
|
|
services: services$3,
|
|
discoveries: discoveries$2,
|
|
restriction: restriction$2,
|
|
restriction_mild: restriction_mild$2,
|
|
restriction_moderate: restriction_moderate$2,
|
|
restriction_severe: restriction_severe$2,
|
|
min_xp: min_xp$2,
|
|
xp: xp$4,
|
|
penalty: penalty$4,
|
|
feature_flags: feature_flags$2,
|
|
permission: permission$1,
|
|
role: role$2,
|
|
domain: domain,
|
|
action: action$1,
|
|
value: value$1,
|
|
key: key$1,
|
|
enabled: enabled,
|
|
disabled: disabled,
|
|
yes: yes,
|
|
no: no$1,
|
|
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$1,
|
|
descending: descending$1
|
|
};
|
|
|
|
var center = "Center";
|
|
var dashboard = "Dashboard";
|
|
var providers = "Providers";
|
|
var providers_title = "Providers";
|
|
var all_providers = "All Providers";
|
|
var pending_providers = "Pending Approval";
|
|
var users_and_partners = "Users & Partners";
|
|
var garages$1 = "Garages";
|
|
var garage_list = "Garage List";
|
|
var users = "Users";
|
|
var user_list = "User List";
|
|
var persons = "Persons";
|
|
var finance = "Finance";
|
|
var packages = "Packages";
|
|
var gamification = "Gamification";
|
|
var game_settings = "Game Settings";
|
|
var point_rules = "Point Rules";
|
|
var levels = "Levels";
|
|
var badges = "Badges";
|
|
var validation_rules = "Validation Rules";
|
|
var events_and_seasons = "Events & Seasons";
|
|
var seasons = "Seasons";
|
|
var competitions = "Competitions";
|
|
var user_data = "User Data";
|
|
var statistics = "Statistics";
|
|
var leaderboard = "Leaderboard";
|
|
var points_ledger = "Points Ledger";
|
|
var gamification_hq = "Gamification HQ";
|
|
var system_config = "System Config";
|
|
var system_parameters = "System Parameters";
|
|
var system = "System";
|
|
var permissions = "Permissions";
|
|
var system_logs = "System Logs";
|
|
const locale_menu_46json_75789531 = {
|
|
center: center,
|
|
dashboard: dashboard,
|
|
providers: providers,
|
|
providers_title: providers_title,
|
|
all_providers: all_providers,
|
|
pending_providers: pending_providers,
|
|
users_and_partners: users_and_partners,
|
|
garages: garages$1,
|
|
garage_list: garage_list,
|
|
users: users,
|
|
user_list: user_list,
|
|
persons: persons,
|
|
finance: finance,
|
|
packages: packages,
|
|
gamification: gamification,
|
|
game_settings: game_settings,
|
|
point_rules: point_rules,
|
|
levels: levels,
|
|
badges: badges,
|
|
validation_rules: validation_rules,
|
|
events_and_seasons: events_and_seasons,
|
|
seasons: seasons,
|
|
competitions: competitions,
|
|
user_data: user_data,
|
|
statistics: statistics,
|
|
leaderboard: leaderboard,
|
|
points_ledger: points_ledger,
|
|
gamification_hq: gamification_hq,
|
|
system_config: system_config,
|
|
system_parameters: system_parameters,
|
|
system: system,
|
|
permissions: permissions,
|
|
system_logs: system_logs
|
|
};
|
|
|
|
var title$j = "Providers";
|
|
var subtitle$g = "Provider listing, search and moderation";
|
|
var loading$j = "Loading providers...";
|
|
var error$c = "An error occurred while loading providers.";
|
|
var retry$g = "Retry";
|
|
var stats_total = "Total";
|
|
var stats_pending = "Pending";
|
|
var stats_approved = "Approved";
|
|
var stats_rejected = "Rejected";
|
|
var stats_flagged = "Flagged";
|
|
var search_placeholder$3 = "Search by name...";
|
|
var filter_all_status = "All statuses";
|
|
var filter_pending = "Pending";
|
|
var filter_approved = "Approved";
|
|
var filter_rejected = "Rejected";
|
|
var filter_flagged = "Flagged";
|
|
var filter_all_sources = "All sources";
|
|
var source_manual = "Manual";
|
|
var source_ocr = "OCR";
|
|
var source_import = "Import";
|
|
var source_bot = "Bot (Staging)";
|
|
var source_verified_org = "Organization";
|
|
var sort_created_at = "Created at";
|
|
var sort_name = "Name";
|
|
var sort_validation_score = "Validation score";
|
|
var col_id = "ID";
|
|
var col_name = "Name";
|
|
var col_address = "Address";
|
|
var col_status = "Status";
|
|
var col_source = "Source";
|
|
var col_validation = "Validation";
|
|
var col_created = "Created";
|
|
var col_actions = "Actions";
|
|
var no_providers = "No providers to display.";
|
|
var results_count = "{count} results (total: {total})";
|
|
var page = "Page {page}";
|
|
var view_details$1 = "Details";
|
|
var status_pending = "Pending";
|
|
var status_approved = "Approved";
|
|
var status_rejected = "Rejected";
|
|
var status_flagged = "Flagged";
|
|
var provider_detail = "Provider Details";
|
|
var detail_loading = "Loading provider...";
|
|
var detail_not_found = "Provider not found.";
|
|
var detail_back = "Back to providers";
|
|
var detail_provider_number = "Provider #{id}";
|
|
var detail_raw_data = "Raw Data";
|
|
var detail_tab_data = "Data";
|
|
var detail_tab_status = "Status";
|
|
var detail_tab_validations = "Validations";
|
|
var detail_tab_crawler = "Crawler / Raw Data";
|
|
var detail_tab_history = "History";
|
|
var detail_section_basic = "Basic Information";
|
|
var detail_section_address = "Address Information";
|
|
var detail_section_contact = "Contact Information";
|
|
var detail_section_services = "Services";
|
|
var detail_section_vehicle_classes = "Vehicle Classes";
|
|
var detail_section_specializations = "Specializations";
|
|
var detail_section_opening_hours = "Opening Hours";
|
|
var detail_section_evidence = "Evidence Image";
|
|
var detail_section_moderation = "Moderation Actions";
|
|
var detail_section_status_management = "Status Management";
|
|
var detail_section_validation_score = "Validation Score";
|
|
var detail_section_gamification_validations = "Gamification Validations";
|
|
var detail_section_crawler_data = "Crawler / Raw Data";
|
|
var detail_section_history = "Status Change History";
|
|
var detail_field_name = "Name";
|
|
var detail_field_category = "Category";
|
|
var detail_field_source = "Source";
|
|
var detail_field_validation_score = "Validation Score";
|
|
var detail_field_created = "Created";
|
|
var detail_field_submitted_by = "Submitted by User ID";
|
|
var detail_field_full_address = "Full Address";
|
|
var detail_field_city = "City";
|
|
var detail_field_zip = "ZIP Code";
|
|
var detail_field_street = "Street";
|
|
var detail_field_house_number = "House Number";
|
|
var detail_field_plus_code = "Plus Code";
|
|
var detail_field_phone = "Phone";
|
|
var detail_field_email = "Email";
|
|
var detail_field_website = "Website";
|
|
var detail_no_categories = "No categories set";
|
|
var detail_no_vehicle_classes = "No vehicle classes set";
|
|
var detail_no_specializations = "No specializations set";
|
|
var detail_no_opening_hours = "No opening hours set";
|
|
var detail_day_monday = "Monday";
|
|
var detail_day_tuesday = "Tuesday";
|
|
var detail_day_wednesday = "Wednesday";
|
|
var detail_day_thursday = "Thursday";
|
|
var detail_day_friday = "Friday";
|
|
var detail_day_saturday = "Saturday";
|
|
var detail_day_sunday = "Sunday";
|
|
var detail_day_label = "Day";
|
|
var detail_hours_label = "Hours";
|
|
var detail_closed = "Closed";
|
|
var detail_specialization_brands = "Brands";
|
|
var detail_specialization_propulsion = "Propulsion";
|
|
var detail_status_approved = "Approved";
|
|
var detail_status_pending = "Pending";
|
|
var detail_status_research = "Research in progress";
|
|
var detail_status_rejected = "Rejected";
|
|
var detail_status_unknown = "Unknown";
|
|
var detail_status_desc_approved = "The provider is active and visible to users.";
|
|
var detail_status_desc_pending = "The provider has not been approved yet, awaiting moderation.";
|
|
var detail_status_desc_research = "Provider data is still being processed, automated research in progress.";
|
|
var detail_status_desc_rejected = "The provider has been rejected and is not visible to users.";
|
|
var detail_edit = "Edit";
|
|
var detail_approve = "Approve";
|
|
var detail_reject = "Reject";
|
|
var detail_flag = "Flag";
|
|
var detail_delete = "Delete (Soft Delete)";
|
|
var detail_restore = "Restore";
|
|
var detail_status_rejected_or_flagged = "The provider has been {status}.";
|
|
var detail_status_rejected_text = "rejected";
|
|
var detail_status_flagged_text = "flagged";
|
|
var detail_status_form_label = "Status";
|
|
var detail_status_form_score = "Validation Score (0-100)";
|
|
var detail_status_form_reason = "Reason (optional)";
|
|
var detail_status_form_reason_placeholder = "Enter the reason for status change...";
|
|
var detail_status_form_cancel = "Cancel";
|
|
var detail_status_form_save = "Save Status";
|
|
var detail_validation_score_excellent = "Excellent";
|
|
var detail_validation_score_medium = "Medium";
|
|
var detail_validation_score_weak = "Weak";
|
|
var detail_validation_score_desc = "Provider reliability score based on gamification validations.";
|
|
var detail_validation_no_entries = "No validation entries for this provider.";
|
|
var detail_validation_voter = "Voter:";
|
|
var detail_validation_reason = "Reason:";
|
|
var detail_validation_weight = "weight:";
|
|
var detail_crawler_source = "Source:";
|
|
var detail_crawler_trust_score = "Trust Score:";
|
|
var detail_crawler_rejection_reason_title = "Rejection Reason";
|
|
var detail_crawler_raw_data = "Raw Data";
|
|
var detail_crawler_audit_trail = "Audit Trail";
|
|
var detail_history_no_entries = "No history entries for this provider.";
|
|
var detail_history_user = "User #{id}";
|
|
var detail_history_status = "Status:";
|
|
var detail_history_reason = "Reason:";
|
|
var detail_history_detailed_changes = "Detailed Changes";
|
|
var detail_history_old_data = "Old Data";
|
|
var detail_flag_modal_title = "Flag Provider";
|
|
var detail_flag_modal_body = "Are you sure you want to flag {name}?";
|
|
var detail_flag_reason_label = "Reason (optional)";
|
|
var detail_flag_reason_placeholder = "Enter the reason for flagging...";
|
|
var detail_flag_submit = "Flag";
|
|
var detail_toast_approved = "Provider approved!";
|
|
var detail_toast_rejected = "Provider rejected!";
|
|
var detail_toast_restored = "Provider restored!";
|
|
var detail_toast_flagged = "Provider flagged!";
|
|
var detail_toast_deleted = "Provider deleted!";
|
|
var detail_toast_status_updated = "Status updated!";
|
|
var detail_toast_error_approve = "Error approving provider";
|
|
var detail_toast_error_reject = "Error rejecting provider";
|
|
var detail_toast_error_restore = "Error restoring provider";
|
|
var detail_toast_error_flag = "Error flagging provider";
|
|
var detail_toast_error_delete = "Error deleting provider";
|
|
var detail_toast_error_status = "Error saving status";
|
|
var detail_delete_confirm = "Are you sure you want to delete this provider? This action cannot be undone.";
|
|
var detail_vehicle_class_car = "Car";
|
|
var detail_vehicle_class_motorcycle = "Motorcycle";
|
|
var detail_vehicle_class_truck = "Truck";
|
|
var detail_vehicle_class_hgv = "Heavy Goods Vehicle (HGV)";
|
|
var detail_vehicle_class_light_commercial = "Light Commercial Vehicle";
|
|
var detail_vehicle_class_personal = "Personal";
|
|
var detail_vehicle_class_boat = "Boat/Watercraft";
|
|
var detail_vehicle_class_other = "Other";
|
|
var detail_validation_type_phone_verified = "Phone Verified";
|
|
var detail_validation_type_email_verified = "Email Verified";
|
|
var detail_validation_type_address_verified = "Address Verified";
|
|
var detail_validation_type_website_verified = "Website Verified";
|
|
var detail_validation_type_manual_review = "Manual Review";
|
|
var detail_validation_type_community_vouch = "Community Vouch";
|
|
var detail_validation_type_business_hours = "Business Hours Verified";
|
|
var detail_validation_type_photo_evidence = "Photo Evidence";
|
|
var detail_history_action_approve = "Approved";
|
|
var detail_history_action_reject = "Rejected";
|
|
var detail_history_action_restore = "Restored";
|
|
var detail_history_action_flag = "Flagged";
|
|
var detail_history_action_update = "Updated";
|
|
var detail_history_action_delete = "Deleted";
|
|
var detail_history_action_create = "Created";
|
|
var pending_title = "Providers Pending Approval";
|
|
var pending_subtitle = "Community-submitted providers awaiting moderation";
|
|
var pending_loading = "Loading pending providers...";
|
|
var rejected_title = "Rejected Providers";
|
|
var rejected_subtitle = "Restore rejected providers to active searchable providers";
|
|
var rejected_loading = "Loading rejected providers...";
|
|
var approve = "Approve";
|
|
var reject = "Reject";
|
|
var restore = "Restore";
|
|
var details$3 = "Details";
|
|
var reject_modal_title = "Reject Provider";
|
|
var reject_modal_body = "Are you sure you want to reject {name}?";
|
|
var reject_reason_label = "Reason (optional)";
|
|
var reject_reason_placeholder = "Enter the reason for rejection...";
|
|
var restore_modal_title = "Restore Provider";
|
|
var restore_modal_body = "Are you sure you want to restore {name}? After restoration, the provider will be available in search and listings again.";
|
|
var restore_reason_label = "Reason (optional)";
|
|
var restore_reason_placeholder = "Enter the reason for restoration...";
|
|
var no_pending = "No pending providers";
|
|
var no_pending_subtitle = "All submitted providers have been processed.";
|
|
var no_rejected = "No rejected providers";
|
|
var no_rejected_subtitle = "All providers are in approved status.";
|
|
var approved_toast = "\"{name}\" approved successfully";
|
|
var rejected_toast = "\"{name}\" rejected";
|
|
var restored_toast = "\"{name}\" restored successfully";
|
|
var error_prefix = "Error: {detail}";
|
|
var unknown_error$1 = "Unknown error";
|
|
var label_address = "Address:";
|
|
var label_city = "City:";
|
|
var label_category = "Category:";
|
|
var label_validation_score = "Validation Score:";
|
|
var label_submitted = "Submitted:";
|
|
var label_created = "Created:";
|
|
var edit_title$7 = "Edit Provider";
|
|
var edit_loading = "Loading provider...";
|
|
var edit_error = "An error occurred while loading the provider.";
|
|
var edit_not_found = "Provider not found.";
|
|
var edit_back = "Back to provider";
|
|
var edit_raw_data = "Raw Data";
|
|
var edit_tab_basic = "Basic & Contact";
|
|
var edit_tab_matrix = "Services & Vehicles";
|
|
var edit_tab_location = "Location";
|
|
var edit_tab_hours = "Opening Hours";
|
|
var edit_section_basic = "Basic Information";
|
|
var edit_section_contact = "Contact Information";
|
|
var edit_section_matrix = "3D Capability Matrix";
|
|
var edit_section_matrix_desc = "Configure which vehicle classes, service categories and specializations the provider belongs to.";
|
|
var edit_section_vehicle_classes = "Vehicle Classes";
|
|
var edit_section_vehicle_classes_desc = "Which vehicle types does the provider service?";
|
|
var edit_section_expertise_tags = "Service Categories (Expertise Tags)";
|
|
var edit_section_expertise_tags_desc = "Select the categories for the provider from the hierarchical tree.";
|
|
var edit_section_specializations = "Specializations";
|
|
var edit_section_specializations_desc = "Add special brands, propulsion types or other tags.";
|
|
var edit_section_location_extra = "Additional Location Data";
|
|
var edit_section_opening_hours = "Opening Hours";
|
|
var edit_section_opening_hours_desc = "Set the provider's opening hours broken down by day.";
|
|
var edit_field_name = "Name *";
|
|
var edit_field_category = "Category";
|
|
var edit_field_category_placeholder = "e.g. Auto Repair, Tire Service";
|
|
var edit_field_source = "Source";
|
|
var edit_field_phone = "Phone";
|
|
var edit_field_phone_placeholder = "+36 30 123 4567";
|
|
var edit_field_email = "Email";
|
|
var edit_field_email_placeholder = "info{'@'}example.com";
|
|
var edit_field_website = "Website";
|
|
var edit_field_website_placeholder = "https://...";
|
|
var edit_field_full_address = "Full Address";
|
|
var edit_field_full_address_placeholder = "Full address text";
|
|
var edit_field_plus_code = "Plus Code";
|
|
var edit_field_plus_code_placeholder = "8FVC9X8V+XV";
|
|
var edit_field_brands = "Brands";
|
|
var edit_field_brands_placeholder = "e.g. Volvo, Scania";
|
|
var edit_field_propulsion = "Propulsion";
|
|
var edit_field_propulsion_placeholder = "e.g. EV, Hybrid, Diesel";
|
|
var edit_field_add = "Add";
|
|
var edit_always_open = "24/7 opening hours";
|
|
var edit_always_open_desc = "The provider is open 24 hours every day of the week";
|
|
var edit_btn_24_7 = "24/7 Continuous Hours";
|
|
var edit_btn_copy_weekdays = "Copy Weekdays (Mon → Fri)";
|
|
var edit_btn_clear_all = "Clear All";
|
|
var edit_closed = "Closed";
|
|
var edit_has_changes = "● Unsaved changes";
|
|
var edit_no_changes = "No changes";
|
|
var edit_cancel = "Cancel";
|
|
var edit_save = "Save";
|
|
var edit_toast_saved = "Provider updated successfully!";
|
|
var edit_toast_promoted = "Promoted successfully!";
|
|
var edit_toast_error = "Error saving: {message}";
|
|
var edit_copy_weekdays_open_prompt = "Enter opening time (e.g. 08:00):";
|
|
var edit_copy_weekdays_close_prompt = "Enter closing time (e.g. 17:00):";
|
|
var edit_categories_loading = "Loading categories...";
|
|
var edit_level_label = "(Level {level})";
|
|
var edit_source_label = "Source:";
|
|
var edit_trust_score_label = "Trust Score:";
|
|
var edit_raw_data_title = "Raw Data";
|
|
var edit_audit_trail_title = "Audit Trail";
|
|
var edit_rejection_reason_title = "Rejection Reason";
|
|
const locale_providers_46json_03440ec5 = {
|
|
title: title$j,
|
|
subtitle: subtitle$g,
|
|
loading: loading$j,
|
|
error: error$c,
|
|
retry: retry$g,
|
|
stats_total: stats_total,
|
|
stats_pending: stats_pending,
|
|
stats_approved: stats_approved,
|
|
stats_rejected: stats_rejected,
|
|
stats_flagged: stats_flagged,
|
|
search_placeholder: search_placeholder$3,
|
|
filter_all_status: filter_all_status,
|
|
filter_pending: filter_pending,
|
|
filter_approved: filter_approved,
|
|
filter_rejected: filter_rejected,
|
|
filter_flagged: filter_flagged,
|
|
filter_all_sources: filter_all_sources,
|
|
source_manual: source_manual,
|
|
source_ocr: source_ocr,
|
|
source_import: source_import,
|
|
source_bot: source_bot,
|
|
source_verified_org: source_verified_org,
|
|
sort_created_at: sort_created_at,
|
|
sort_name: sort_name,
|
|
sort_validation_score: sort_validation_score,
|
|
col_id: col_id,
|
|
col_name: col_name,
|
|
col_address: col_address,
|
|
col_status: col_status,
|
|
col_source: col_source,
|
|
col_validation: col_validation,
|
|
col_created: col_created,
|
|
col_actions: col_actions,
|
|
no_providers: no_providers,
|
|
results_count: results_count,
|
|
page: page,
|
|
view_details: view_details$1,
|
|
status_pending: status_pending,
|
|
status_approved: status_approved,
|
|
status_rejected: status_rejected,
|
|
status_flagged: status_flagged,
|
|
provider_detail: provider_detail,
|
|
detail_loading: detail_loading,
|
|
detail_not_found: detail_not_found,
|
|
detail_back: detail_back,
|
|
detail_provider_number: detail_provider_number,
|
|
detail_raw_data: detail_raw_data,
|
|
detail_tab_data: detail_tab_data,
|
|
detail_tab_status: detail_tab_status,
|
|
detail_tab_validations: detail_tab_validations,
|
|
detail_tab_crawler: detail_tab_crawler,
|
|
detail_tab_history: detail_tab_history,
|
|
detail_section_basic: detail_section_basic,
|
|
detail_section_address: detail_section_address,
|
|
detail_section_contact: detail_section_contact,
|
|
detail_section_services: detail_section_services,
|
|
detail_section_vehicle_classes: detail_section_vehicle_classes,
|
|
detail_section_specializations: detail_section_specializations,
|
|
detail_section_opening_hours: detail_section_opening_hours,
|
|
detail_section_evidence: detail_section_evidence,
|
|
detail_section_moderation: detail_section_moderation,
|
|
detail_section_status_management: detail_section_status_management,
|
|
detail_section_validation_score: detail_section_validation_score,
|
|
detail_section_gamification_validations: detail_section_gamification_validations,
|
|
detail_section_crawler_data: detail_section_crawler_data,
|
|
detail_section_history: detail_section_history,
|
|
detail_field_name: detail_field_name,
|
|
detail_field_category: detail_field_category,
|
|
detail_field_source: detail_field_source,
|
|
detail_field_validation_score: detail_field_validation_score,
|
|
detail_field_created: detail_field_created,
|
|
detail_field_submitted_by: detail_field_submitted_by,
|
|
detail_field_full_address: detail_field_full_address,
|
|
detail_field_city: detail_field_city,
|
|
detail_field_zip: detail_field_zip,
|
|
detail_field_street: detail_field_street,
|
|
detail_field_house_number: detail_field_house_number,
|
|
detail_field_plus_code: detail_field_plus_code,
|
|
detail_field_phone: detail_field_phone,
|
|
detail_field_email: detail_field_email,
|
|
detail_field_website: detail_field_website,
|
|
detail_no_categories: detail_no_categories,
|
|
detail_no_vehicle_classes: detail_no_vehicle_classes,
|
|
detail_no_specializations: detail_no_specializations,
|
|
detail_no_opening_hours: detail_no_opening_hours,
|
|
detail_day_monday: detail_day_monday,
|
|
detail_day_tuesday: detail_day_tuesday,
|
|
detail_day_wednesday: detail_day_wednesday,
|
|
detail_day_thursday: detail_day_thursday,
|
|
detail_day_friday: detail_day_friday,
|
|
detail_day_saturday: detail_day_saturday,
|
|
detail_day_sunday: detail_day_sunday,
|
|
detail_day_label: detail_day_label,
|
|
detail_hours_label: detail_hours_label,
|
|
detail_closed: detail_closed,
|
|
detail_specialization_brands: detail_specialization_brands,
|
|
detail_specialization_propulsion: detail_specialization_propulsion,
|
|
detail_status_approved: detail_status_approved,
|
|
detail_status_pending: detail_status_pending,
|
|
detail_status_research: detail_status_research,
|
|
detail_status_rejected: detail_status_rejected,
|
|
detail_status_unknown: detail_status_unknown,
|
|
detail_status_desc_approved: detail_status_desc_approved,
|
|
detail_status_desc_pending: detail_status_desc_pending,
|
|
detail_status_desc_research: detail_status_desc_research,
|
|
detail_status_desc_rejected: detail_status_desc_rejected,
|
|
detail_edit: detail_edit,
|
|
detail_approve: detail_approve,
|
|
detail_reject: detail_reject,
|
|
detail_flag: detail_flag,
|
|
detail_delete: detail_delete,
|
|
detail_restore: detail_restore,
|
|
detail_status_rejected_or_flagged: detail_status_rejected_or_flagged,
|
|
detail_status_rejected_text: detail_status_rejected_text,
|
|
detail_status_flagged_text: detail_status_flagged_text,
|
|
detail_status_form_label: detail_status_form_label,
|
|
detail_status_form_score: detail_status_form_score,
|
|
detail_status_form_reason: detail_status_form_reason,
|
|
detail_status_form_reason_placeholder: detail_status_form_reason_placeholder,
|
|
detail_status_form_cancel: detail_status_form_cancel,
|
|
detail_status_form_save: detail_status_form_save,
|
|
detail_validation_score_excellent: detail_validation_score_excellent,
|
|
detail_validation_score_medium: detail_validation_score_medium,
|
|
detail_validation_score_weak: detail_validation_score_weak,
|
|
detail_validation_score_desc: detail_validation_score_desc,
|
|
detail_validation_no_entries: detail_validation_no_entries,
|
|
detail_validation_voter: detail_validation_voter,
|
|
detail_validation_reason: detail_validation_reason,
|
|
detail_validation_weight: detail_validation_weight,
|
|
detail_crawler_source: detail_crawler_source,
|
|
detail_crawler_trust_score: detail_crawler_trust_score,
|
|
detail_crawler_rejection_reason_title: detail_crawler_rejection_reason_title,
|
|
detail_crawler_raw_data: detail_crawler_raw_data,
|
|
detail_crawler_audit_trail: detail_crawler_audit_trail,
|
|
detail_history_no_entries: detail_history_no_entries,
|
|
detail_history_user: detail_history_user,
|
|
detail_history_status: detail_history_status,
|
|
detail_history_reason: detail_history_reason,
|
|
detail_history_detailed_changes: detail_history_detailed_changes,
|
|
detail_history_old_data: detail_history_old_data,
|
|
detail_flag_modal_title: detail_flag_modal_title,
|
|
detail_flag_modal_body: detail_flag_modal_body,
|
|
detail_flag_reason_label: detail_flag_reason_label,
|
|
detail_flag_reason_placeholder: detail_flag_reason_placeholder,
|
|
detail_flag_submit: detail_flag_submit,
|
|
detail_toast_approved: detail_toast_approved,
|
|
detail_toast_rejected: detail_toast_rejected,
|
|
detail_toast_restored: detail_toast_restored,
|
|
detail_toast_flagged: detail_toast_flagged,
|
|
detail_toast_deleted: detail_toast_deleted,
|
|
detail_toast_status_updated: detail_toast_status_updated,
|
|
detail_toast_error_approve: detail_toast_error_approve,
|
|
detail_toast_error_reject: detail_toast_error_reject,
|
|
detail_toast_error_restore: detail_toast_error_restore,
|
|
detail_toast_error_flag: detail_toast_error_flag,
|
|
detail_toast_error_delete: detail_toast_error_delete,
|
|
detail_toast_error_status: detail_toast_error_status,
|
|
detail_delete_confirm: detail_delete_confirm,
|
|
detail_vehicle_class_car: detail_vehicle_class_car,
|
|
detail_vehicle_class_motorcycle: detail_vehicle_class_motorcycle,
|
|
detail_vehicle_class_truck: detail_vehicle_class_truck,
|
|
detail_vehicle_class_hgv: detail_vehicle_class_hgv,
|
|
detail_vehicle_class_light_commercial: detail_vehicle_class_light_commercial,
|
|
detail_vehicle_class_personal: detail_vehicle_class_personal,
|
|
detail_vehicle_class_boat: detail_vehicle_class_boat,
|
|
detail_vehicle_class_other: detail_vehicle_class_other,
|
|
detail_validation_type_phone_verified: detail_validation_type_phone_verified,
|
|
detail_validation_type_email_verified: detail_validation_type_email_verified,
|
|
detail_validation_type_address_verified: detail_validation_type_address_verified,
|
|
detail_validation_type_website_verified: detail_validation_type_website_verified,
|
|
detail_validation_type_manual_review: detail_validation_type_manual_review,
|
|
detail_validation_type_community_vouch: detail_validation_type_community_vouch,
|
|
detail_validation_type_business_hours: detail_validation_type_business_hours,
|
|
detail_validation_type_photo_evidence: detail_validation_type_photo_evidence,
|
|
detail_history_action_approve: detail_history_action_approve,
|
|
detail_history_action_reject: detail_history_action_reject,
|
|
detail_history_action_restore: detail_history_action_restore,
|
|
detail_history_action_flag: detail_history_action_flag,
|
|
detail_history_action_update: detail_history_action_update,
|
|
detail_history_action_delete: detail_history_action_delete,
|
|
detail_history_action_create: detail_history_action_create,
|
|
pending_title: pending_title,
|
|
pending_subtitle: pending_subtitle,
|
|
pending_loading: pending_loading,
|
|
rejected_title: rejected_title,
|
|
rejected_subtitle: rejected_subtitle,
|
|
rejected_loading: rejected_loading,
|
|
approve: approve,
|
|
reject: reject,
|
|
restore: restore,
|
|
details: details$3,
|
|
reject_modal_title: reject_modal_title,
|
|
reject_modal_body: reject_modal_body,
|
|
reject_reason_label: reject_reason_label,
|
|
reject_reason_placeholder: reject_reason_placeholder,
|
|
restore_modal_title: restore_modal_title,
|
|
restore_modal_body: restore_modal_body,
|
|
restore_reason_label: restore_reason_label,
|
|
restore_reason_placeholder: restore_reason_placeholder,
|
|
no_pending: no_pending,
|
|
no_pending_subtitle: no_pending_subtitle,
|
|
no_rejected: no_rejected,
|
|
no_rejected_subtitle: no_rejected_subtitle,
|
|
approved_toast: approved_toast,
|
|
rejected_toast: rejected_toast,
|
|
restored_toast: restored_toast,
|
|
error_prefix: error_prefix,
|
|
unknown_error: unknown_error$1,
|
|
label_address: label_address,
|
|
label_city: label_city,
|
|
label_category: label_category,
|
|
label_validation_score: label_validation_score,
|
|
label_submitted: label_submitted,
|
|
label_created: label_created,
|
|
edit_title: edit_title$7,
|
|
edit_loading: edit_loading,
|
|
edit_error: edit_error,
|
|
edit_not_found: edit_not_found,
|
|
edit_back: edit_back,
|
|
edit_raw_data: edit_raw_data,
|
|
edit_tab_basic: edit_tab_basic,
|
|
edit_tab_matrix: edit_tab_matrix,
|
|
edit_tab_location: edit_tab_location,
|
|
edit_tab_hours: edit_tab_hours,
|
|
edit_section_basic: edit_section_basic,
|
|
edit_section_contact: edit_section_contact,
|
|
edit_section_matrix: edit_section_matrix,
|
|
edit_section_matrix_desc: edit_section_matrix_desc,
|
|
edit_section_vehicle_classes: edit_section_vehicle_classes,
|
|
edit_section_vehicle_classes_desc: edit_section_vehicle_classes_desc,
|
|
edit_section_expertise_tags: edit_section_expertise_tags,
|
|
edit_section_expertise_tags_desc: edit_section_expertise_tags_desc,
|
|
edit_section_specializations: edit_section_specializations,
|
|
edit_section_specializations_desc: edit_section_specializations_desc,
|
|
edit_section_location_extra: edit_section_location_extra,
|
|
edit_section_opening_hours: edit_section_opening_hours,
|
|
edit_section_opening_hours_desc: edit_section_opening_hours_desc,
|
|
edit_field_name: edit_field_name,
|
|
edit_field_category: edit_field_category,
|
|
edit_field_category_placeholder: edit_field_category_placeholder,
|
|
edit_field_source: edit_field_source,
|
|
edit_field_phone: edit_field_phone,
|
|
edit_field_phone_placeholder: edit_field_phone_placeholder,
|
|
edit_field_email: edit_field_email,
|
|
edit_field_email_placeholder: edit_field_email_placeholder,
|
|
edit_field_website: edit_field_website,
|
|
edit_field_website_placeholder: edit_field_website_placeholder,
|
|
edit_field_full_address: edit_field_full_address,
|
|
edit_field_full_address_placeholder: edit_field_full_address_placeholder,
|
|
edit_field_plus_code: edit_field_plus_code,
|
|
edit_field_plus_code_placeholder: edit_field_plus_code_placeholder,
|
|
edit_field_brands: edit_field_brands,
|
|
edit_field_brands_placeholder: edit_field_brands_placeholder,
|
|
edit_field_propulsion: edit_field_propulsion,
|
|
edit_field_propulsion_placeholder: edit_field_propulsion_placeholder,
|
|
edit_field_add: edit_field_add,
|
|
edit_always_open: edit_always_open,
|
|
edit_always_open_desc: edit_always_open_desc,
|
|
edit_btn_24_7: edit_btn_24_7,
|
|
edit_btn_copy_weekdays: edit_btn_copy_weekdays,
|
|
edit_btn_clear_all: edit_btn_clear_all,
|
|
edit_closed: edit_closed,
|
|
edit_has_changes: edit_has_changes,
|
|
edit_no_changes: edit_no_changes,
|
|
edit_cancel: edit_cancel,
|
|
edit_save: edit_save,
|
|
edit_toast_saved: edit_toast_saved,
|
|
edit_toast_promoted: edit_toast_promoted,
|
|
edit_toast_error: edit_toast_error,
|
|
edit_copy_weekdays_open_prompt: edit_copy_weekdays_open_prompt,
|
|
edit_copy_weekdays_close_prompt: edit_copy_weekdays_close_prompt,
|
|
edit_categories_loading: edit_categories_loading,
|
|
edit_level_label: edit_level_label,
|
|
edit_source_label: edit_source_label,
|
|
edit_trust_score_label: edit_trust_score_label,
|
|
edit_raw_data_title: edit_raw_data_title,
|
|
edit_audit_trail_title: edit_audit_trail_title,
|
|
edit_rejection_reason_title: edit_rejection_reason_title
|
|
};
|
|
|
|
var title$i = "Garages CRM";
|
|
var subtitle$f = "Garage list, package management and status changes";
|
|
var total_garages = "Total Garages";
|
|
var private_garages = "Private Garages";
|
|
var corporate_garages = "Corporate Garages";
|
|
var search_placeholder$2 = "Search by name, contact or email...";
|
|
var all_tiers = "All packages";
|
|
var all_types = "All types";
|
|
var type_individual = "Private (Individual)";
|
|
var type_corporate$1 = "Corporate";
|
|
var company_name$1 = "Company Name";
|
|
var email$3 = "Email";
|
|
var status$7 = "Status";
|
|
var current_package = "Current Package";
|
|
var expiration_date = "Expiration Date";
|
|
var actions$9 = "Actions";
|
|
var active$3 = "Active";
|
|
var inactive$3 = "Inactive";
|
|
var suspended = "Suspended";
|
|
var change_package = "Change Package";
|
|
var manage_subscription = "Manage Subscription";
|
|
var view$2 = "View";
|
|
var activate$2 = "Activate";
|
|
var deactivate$1 = "Deactivate";
|
|
var no_results$5 = "No garages match your search.";
|
|
var loading$i = "Loading garages...";
|
|
var retry$f = "Retry";
|
|
var members = "members";
|
|
var free_fallback = "Free / Fallback";
|
|
var expires$1 = "Expires";
|
|
var select_package = "Select Package";
|
|
var select_package_placeholder = "Select a subscription package...";
|
|
var custom_expiration = "Custom Expiration Date";
|
|
var optional = "optional";
|
|
var custom_expiration_hint = "Leave empty for default duration (e.g. 30 days). For 2-5 year B2B deals, set a custom date!";
|
|
var cancel$9 = "Cancel";
|
|
var save$b = "Save";
|
|
var saving$6 = "Saving...";
|
|
var subscription_updated = "subscription updated successfully!";
|
|
var view_details = "Details";
|
|
var indefinite = "Indefinite";
|
|
var addons_title = "Add-ons";
|
|
var addon_vehicles = "Extra Vehicle";
|
|
var addon_branches = "Extra Branch";
|
|
var addon_users = "Extra Employee";
|
|
var active_addons = "Active Add-ons";
|
|
var no_active_addons = "No active add-ons";
|
|
var addon_vehicles_expiration = "Extra Vehicle Expiration";
|
|
var addon_branches_expiration = "Extra Branch Expiration";
|
|
var addon_users_expiration = "Extra Employee Expiration";
|
|
var addon_expiration_hint = "If empty, existing expiration dates remain.";
|
|
const locale_garages_46json_57a15a2c = {
|
|
title: title$i,
|
|
subtitle: subtitle$f,
|
|
total_garages: total_garages,
|
|
private_garages: private_garages,
|
|
corporate_garages: corporate_garages,
|
|
search_placeholder: search_placeholder$2,
|
|
all_tiers: all_tiers,
|
|
all_types: all_types,
|
|
type_individual: type_individual,
|
|
type_corporate: type_corporate$1,
|
|
company_name: company_name$1,
|
|
email: email$3,
|
|
status: status$7,
|
|
current_package: current_package,
|
|
expiration_date: expiration_date,
|
|
actions: actions$9,
|
|
active: active$3,
|
|
inactive: inactive$3,
|
|
suspended: suspended,
|
|
change_package: change_package,
|
|
manage_subscription: manage_subscription,
|
|
view: view$2,
|
|
activate: activate$2,
|
|
deactivate: deactivate$1,
|
|
no_results: no_results$5,
|
|
loading: loading$i,
|
|
retry: retry$f,
|
|
members: members,
|
|
free_fallback: free_fallback,
|
|
expires: expires$1,
|
|
select_package: select_package,
|
|
select_package_placeholder: select_package_placeholder,
|
|
custom_expiration: custom_expiration,
|
|
optional: optional,
|
|
custom_expiration_hint: custom_expiration_hint,
|
|
cancel: cancel$9,
|
|
save: save$b,
|
|
saving: saving$6,
|
|
subscription_updated: subscription_updated,
|
|
view_details: view_details,
|
|
indefinite: indefinite,
|
|
addons_title: addons_title,
|
|
addon_vehicles: addon_vehicles,
|
|
addon_branches: addon_branches,
|
|
addon_users: addon_users,
|
|
active_addons: active_addons,
|
|
no_active_addons: no_active_addons,
|
|
addon_vehicles_expiration: addon_vehicles_expiration,
|
|
addon_branches_expiration: addon_branches_expiration,
|
|
addon_users_expiration: addon_users_expiration,
|
|
addon_expiration_hint: addon_expiration_hint
|
|
};
|
|
|
|
var title$h = "Gamification HQ";
|
|
var subtitle$e = "Gamification system overview dashboard";
|
|
var loading$h = "Loading dashboard...";
|
|
var error$b = "Failed to load dashboard data.";
|
|
var total_users$1 = "Total Users";
|
|
var active_season = "Active Season";
|
|
var pending_contributions = "Pending Contributions";
|
|
var xp_earned_today = "XP Earned Today";
|
|
var none$1 = "None";
|
|
var quick_actions = "Quick Actions";
|
|
var manage_point_rules = "Manage Point Rules";
|
|
var manage_badges = "Manage Badges";
|
|
var manage_seasons = "Manage Seasons";
|
|
var recent_ledger = "Recent Ledger Entries";
|
|
var no_ledger = "No ledger entries yet.";
|
|
var top_5 = "Top 5 Leaderboard";
|
|
var full_leaderboard = "Full Leaderboard →";
|
|
var no_leaderboard = "No leaderboard data yet.";
|
|
var level$4 = "Level";
|
|
var xp$3 = "XP";
|
|
var points$5 = "points";
|
|
const locale_dashboard_46json_d9580386 = {
|
|
title: title$h,
|
|
subtitle: subtitle$e,
|
|
loading: loading$h,
|
|
error: error$b,
|
|
total_users: total_users$1,
|
|
active_season: active_season,
|
|
pending_contributions: pending_contributions,
|
|
xp_earned_today: xp_earned_today,
|
|
none: none$1,
|
|
quick_actions: quick_actions,
|
|
manage_point_rules: manage_point_rules,
|
|
manage_badges: manage_badges,
|
|
manage_seasons: manage_seasons,
|
|
recent_ledger: recent_ledger,
|
|
no_ledger: no_ledger,
|
|
top_5: top_5,
|
|
full_leaderboard: full_leaderboard,
|
|
no_leaderboard: no_leaderboard,
|
|
level: level$4,
|
|
xp: xp$3,
|
|
points: points$5
|
|
};
|
|
|
|
var title$g = "System Config";
|
|
var subtitle$d = "Gamification master configuration editor";
|
|
var loading$g = "Loading configuration...";
|
|
var error$a = "Failed to load configuration.";
|
|
var last_save = "Last saved:";
|
|
var saving$5 = "Saving...";
|
|
var save$a = "Save Configuration";
|
|
var section_xp = "XP Logic";
|
|
var section_conversion = "Conversion Logic";
|
|
var section_penalty = "Penalty Logic";
|
|
var section_rewards = "Level Rewards";
|
|
var calculator = "Impact Calculator";
|
|
var calculator_desc = "Adjust parameters to see estimated impact";
|
|
var estimated_results = "Estimated Results";
|
|
var daily_xp = "Daily XP";
|
|
var xp_for_level = "XP Needed for Level Up";
|
|
var social_to_credit = "Social → Credit";
|
|
var days_to_level = "Days to Level Up";
|
|
var raw_json = "Raw JSON Editor";
|
|
var apply_json = "Apply JSON";
|
|
var updated$6 = "Configuration updated!";
|
|
var save_error$6 = "Failed to save configuration.";
|
|
var json_applied = "JSON applied to form fields!";
|
|
var invalid_json$2 = "Invalid JSON: ";
|
|
const locale_config_46json_994ab42b = {
|
|
title: title$g,
|
|
subtitle: subtitle$d,
|
|
loading: loading$g,
|
|
error: error$a,
|
|
last_save: last_save,
|
|
saving: saving$5,
|
|
save: save$a,
|
|
section_xp: section_xp,
|
|
section_conversion: section_conversion,
|
|
section_penalty: section_penalty,
|
|
section_rewards: section_rewards,
|
|
calculator: calculator,
|
|
calculator_desc: calculator_desc,
|
|
estimated_results: estimated_results,
|
|
daily_xp: daily_xp,
|
|
xp_for_level: xp_for_level,
|
|
social_to_credit: social_to_credit,
|
|
days_to_level: days_to_level,
|
|
raw_json: raw_json,
|
|
apply_json: apply_json,
|
|
updated: updated$6,
|
|
save_error: save_error$6,
|
|
json_applied: json_applied,
|
|
invalid_json: invalid_json$2
|
|
};
|
|
|
|
var title$f = "Badges";
|
|
var subtitle$c = "Badge Management — CRUD";
|
|
var loading$f = "Loading badges...";
|
|
var error$9 = "Failed to load badges.";
|
|
var retry$e = "Retry";
|
|
var create$5 = "New Badge";
|
|
var no_items$5 = "No badges yet.";
|
|
var id$2 = "ID";
|
|
var name$5 = "Name";
|
|
var description$2 = "Description";
|
|
var icon = "Icon";
|
|
var actions$8 = "Actions";
|
|
var edit$6 = "Edit";
|
|
var cancel$8 = "Cancel";
|
|
var save$9 = "Save";
|
|
var create_title$5 = "Create Badge";
|
|
var edit_title$6 = "Edit Badge";
|
|
var name_placeholder$2 = "Badge name";
|
|
var desc_placeholder$1 = "Badge description";
|
|
var icon_placeholder = "Icon URL";
|
|
var icon_hint = "Optional. The icon URL for the badge.";
|
|
var icon_preview = "Icon preview";
|
|
var create_btn$2 = "Create";
|
|
var delete_title$2 = "Delete Badge";
|
|
var delete_confirm$2 = "Are you sure you want to delete this badge?";
|
|
var delete_btn$2 = "Delete";
|
|
var created$2 = "Badge created!";
|
|
var updated$5 = "Badge updated!";
|
|
var deleted$1 = "Badge deleted!";
|
|
var save_error$5 = "Failed to save badge.";
|
|
var delete_error = "Failed to delete badge.";
|
|
var unknown_error = "Unknown error";
|
|
const locale_badges_46json_1ba3918d = {
|
|
title: title$f,
|
|
subtitle: subtitle$c,
|
|
loading: loading$f,
|
|
error: error$9,
|
|
retry: retry$e,
|
|
create: create$5,
|
|
no_items: no_items$5,
|
|
id: id$2,
|
|
name: name$5,
|
|
description: description$2,
|
|
icon: icon,
|
|
actions: actions$8,
|
|
edit: edit$6,
|
|
"delete": "Delete",
|
|
cancel: cancel$8,
|
|
save: save$9,
|
|
create_title: create_title$5,
|
|
edit_title: edit_title$6,
|
|
name_placeholder: name_placeholder$2,
|
|
desc_placeholder: desc_placeholder$1,
|
|
icon_placeholder: icon_placeholder,
|
|
icon_hint: icon_hint,
|
|
icon_preview: icon_preview,
|
|
create_btn: create_btn$2,
|
|
delete_title: delete_title$2,
|
|
delete_confirm: delete_confirm$2,
|
|
delete_btn: delete_btn$2,
|
|
created: created$2,
|
|
updated: updated$5,
|
|
deleted: deleted$1,
|
|
save_error: save_error$5,
|
|
delete_error: delete_error,
|
|
unknown_error: unknown_error
|
|
};
|
|
|
|
var title$e = "Levels";
|
|
var subtitle$b = "Level configuration management — CRUD";
|
|
var loading$e = "Loading levels...";
|
|
var error$8 = "Failed to load level configurations.";
|
|
var retry$d = "Retry";
|
|
var create$4 = "New Level";
|
|
var no_items$4 = "No level configurations yet.";
|
|
var level$3 = "Level";
|
|
var rank = "Rank";
|
|
var min_points = "Min Points";
|
|
var type = "Type";
|
|
var actions$7 = "Actions";
|
|
var penalty$3 = "Penalty";
|
|
var normal = "Normal";
|
|
var tree_diagram = "Level Tree Diagram";
|
|
var no_tree_data = "No levels to display.";
|
|
var points$4 = "points";
|
|
var edit_title$5 = "Edit Level";
|
|
var create_title$4 = "Create Level";
|
|
var level_number = "Level Number";
|
|
var rank_name = "Rank Name";
|
|
var min_points_label = "Minimum Points";
|
|
var is_penalty = "Penalty Level";
|
|
var cancel$7 = "Cancel";
|
|
var save$8 = "Save";
|
|
var saving$4 = "Saving...";
|
|
var updated$4 = "Level updated!";
|
|
var created$1 = "Level created!";
|
|
var duplicate_level = "A configuration with this level number already exists.";
|
|
var save_error$4 = "Failed to save level.";
|
|
const locale_levels_46json_f5b071e8 = {
|
|
title: title$e,
|
|
subtitle: subtitle$b,
|
|
loading: loading$e,
|
|
error: error$8,
|
|
retry: retry$d,
|
|
create: create$4,
|
|
no_items: no_items$4,
|
|
level: level$3,
|
|
rank: rank,
|
|
min_points: min_points,
|
|
type: type,
|
|
actions: actions$7,
|
|
penalty: penalty$3,
|
|
normal: normal,
|
|
tree_diagram: tree_diagram,
|
|
no_tree_data: no_tree_data,
|
|
points: points$4,
|
|
edit_title: edit_title$5,
|
|
create_title: create_title$4,
|
|
level_number: level_number,
|
|
rank_name: rank_name,
|
|
min_points_label: min_points_label,
|
|
is_penalty: is_penalty,
|
|
cancel: cancel$7,
|
|
save: save$8,
|
|
saving: saving$4,
|
|
updated: updated$4,
|
|
created: created$1,
|
|
duplicate_level: duplicate_level,
|
|
save_error: save_error$4
|
|
};
|
|
|
|
var title$d = "Point Rules";
|
|
var subtitle$a = "Gamification point rules management — CRUD";
|
|
var loading$d = "Loading point rules...";
|
|
var error$7 = "Failed to load point rules.";
|
|
var retry$c = "Retry";
|
|
var create$3 = "New Point Rule";
|
|
var no_items$3 = "No point rules yet. Create one with the button above!";
|
|
var id$1 = "ID";
|
|
var action_key = "Action Key";
|
|
var points$3 = "Points";
|
|
var description$1 = "Description";
|
|
var status$6 = "Status";
|
|
var actions$6 = "Actions";
|
|
var active$2 = "Active";
|
|
var inactive$2 = "Inactive";
|
|
var edit$5 = "Edit";
|
|
var edit_title$4 = "Edit Point Rule";
|
|
var create_title$3 = "New Point Rule";
|
|
var action_key_label = "Action Key";
|
|
var action_key_placeholder = "e.g. service_submitted";
|
|
var points_label = "Point Value";
|
|
var points_placeholder = "0";
|
|
var description_label = "Description";
|
|
var description_placeholder = "Short description of the rule...";
|
|
var is_active$1 = "Active";
|
|
var cancel$6 = "Cancel";
|
|
var save$7 = "Save";
|
|
var saving$3 = "Saving...";
|
|
var updated$3 = "Point rule updated!";
|
|
var created = "Point rule created!";
|
|
var deleted = "Point rule deactivated!";
|
|
var duplicate_key = "A rule with this action key already exists.";
|
|
var save_error$3 = "Failed to save point rule.";
|
|
var delete_title$1 = "Delete Point Rule";
|
|
var delete_confirm$1 = "Are you sure you want to deactivate the rule";
|
|
var delete_btn$1 = "Delete";
|
|
var deleting = "Deleting...";
|
|
const locale_point_rules_46json_f0f77f0b = {
|
|
title: title$d,
|
|
subtitle: subtitle$a,
|
|
loading: loading$d,
|
|
error: error$7,
|
|
retry: retry$c,
|
|
create: create$3,
|
|
no_items: no_items$3,
|
|
id: id$1,
|
|
action_key: action_key,
|
|
points: points$3,
|
|
description: description$1,
|
|
status: status$6,
|
|
actions: actions$6,
|
|
active: active$2,
|
|
inactive: inactive$2,
|
|
edit: edit$5,
|
|
"delete": "Delete (soft-delete)",
|
|
edit_title: edit_title$4,
|
|
create_title: create_title$3,
|
|
action_key_label: action_key_label,
|
|
action_key_placeholder: action_key_placeholder,
|
|
points_label: points_label,
|
|
points_placeholder: points_placeholder,
|
|
description_label: description_label,
|
|
description_placeholder: description_placeholder,
|
|
is_active: is_active$1,
|
|
cancel: cancel$6,
|
|
save: save$7,
|
|
saving: saving$3,
|
|
updated: updated$3,
|
|
created: created,
|
|
deleted: deleted,
|
|
duplicate_key: duplicate_key,
|
|
save_error: save_error$3,
|
|
delete_title: delete_title$1,
|
|
delete_confirm: delete_confirm$1,
|
|
delete_btn: delete_btn$1,
|
|
deleting: deleting
|
|
};
|
|
|
|
var title$c = "Seasons";
|
|
var subtitle$9 = "Gamification season management";
|
|
var loading$c = "Loading seasons...";
|
|
var error$6 = "Failed to load seasons.";
|
|
var retry$b = "Retry";
|
|
var create$2 = "New Season";
|
|
var no_items$2 = "No seasons created yet.";
|
|
var create_first$2 = "Create First Season";
|
|
var active$1 = "Active";
|
|
var inactive$1 = "Inactive";
|
|
var created_at$1 = "Created:";
|
|
var activate$1 = "Activate";
|
|
var edit$4 = "Edit";
|
|
var edit_title$3 = "Edit Season";
|
|
var create_title$2 = "New Season";
|
|
var name$4 = "Name";
|
|
var name_placeholder$1 = "e.g. 2026 Q1 Season";
|
|
var start_date$1 = "Start Date";
|
|
var end_date$1 = "End Date";
|
|
var activate_on_create = "Activate on creation";
|
|
var cancel$5 = "Cancel";
|
|
var save$6 = "Save";
|
|
var create_btn$1 = "Create";
|
|
var activate_title = "Activate Season";
|
|
var activate_confirm = "Are you sure you want to activate";
|
|
var activate_warning = "This will deactivate all other seasons.";
|
|
var activating = "Activating...";
|
|
var activate_btn = "Activate";
|
|
var save_error$2 = "Failed to save season.";
|
|
const locale_seasons_46json_2298cb58 = {
|
|
title: title$c,
|
|
subtitle: subtitle$9,
|
|
loading: loading$c,
|
|
error: error$6,
|
|
retry: retry$b,
|
|
create: create$2,
|
|
no_items: no_items$2,
|
|
create_first: create_first$2,
|
|
active: active$1,
|
|
inactive: inactive$1,
|
|
created_at: created_at$1,
|
|
activate: activate$1,
|
|
edit: edit$4,
|
|
edit_title: edit_title$3,
|
|
create_title: create_title$2,
|
|
name: name$4,
|
|
name_placeholder: name_placeholder$1,
|
|
start_date: start_date$1,
|
|
end_date: end_date$1,
|
|
activate_on_create: activate_on_create,
|
|
cancel: cancel$5,
|
|
save: save$6,
|
|
create_btn: create_btn$1,
|
|
activate_title: activate_title,
|
|
activate_confirm: activate_confirm,
|
|
activate_warning: activate_warning,
|
|
activating: activating,
|
|
activate_btn: activate_btn,
|
|
save_error: save_error$2
|
|
};
|
|
|
|
var title$b = "Competitions";
|
|
var subtitle$8 = "Seasonal competition management";
|
|
var loading$b = "Loading competitions...";
|
|
var error$5 = "Failed to load competitions.";
|
|
var retry$a = "Retry";
|
|
var create$1 = "New Competition";
|
|
var no_items$1 = "No competitions created yet.";
|
|
var create_first$1 = "Create First Competition";
|
|
var season_filter = "Season Filter:";
|
|
var all_seasons = "All Seasons";
|
|
var active_badge = "(Active)";
|
|
var status_active$2 = "Active";
|
|
var status_draft = "Draft";
|
|
var status_completed = "Completed";
|
|
var status_cancelled = "Cancelled";
|
|
var view_rules = "View Rules";
|
|
var edit$3 = "Edit";
|
|
var cancel$4 = "Cancel";
|
|
var save$5 = "Save";
|
|
var create_title$1 = "Create Competition";
|
|
var edit_title$2 = "Edit Competition";
|
|
var name$3 = "Name";
|
|
var name_placeholder = "e.g. Q1 Service Submission Contest";
|
|
var description = "Description";
|
|
var desc_placeholder = "Competition description...";
|
|
var season = "Season";
|
|
var select_season = "Select a season";
|
|
var start_date = "Start Date";
|
|
var end_date = "End Date";
|
|
var status$5 = "Status";
|
|
var rules = "Rules (JSON)";
|
|
var rules_placeholder = "type: service_submission, points_multiplier: 1.5";
|
|
var invalid_json$1 = "Invalid JSON format!";
|
|
var create_btn = "Create";
|
|
var season_id_label = "Season ID:";
|
|
var save_error$1 = "Failed to save competition.";
|
|
const locale_competitions_46json_9268c1cb = {
|
|
title: title$b,
|
|
subtitle: subtitle$8,
|
|
loading: loading$b,
|
|
error: error$5,
|
|
retry: retry$a,
|
|
create: create$1,
|
|
no_items: no_items$1,
|
|
create_first: create_first$1,
|
|
season_filter: season_filter,
|
|
all_seasons: all_seasons,
|
|
active_badge: active_badge,
|
|
status_active: status_active$2,
|
|
status_draft: status_draft,
|
|
status_completed: status_completed,
|
|
status_cancelled: status_cancelled,
|
|
view_rules: view_rules,
|
|
edit: edit$3,
|
|
cancel: cancel$4,
|
|
save: save$5,
|
|
create_title: create_title$1,
|
|
edit_title: edit_title$2,
|
|
name: name$3,
|
|
name_placeholder: name_placeholder,
|
|
description: description,
|
|
desc_placeholder: desc_placeholder,
|
|
season: season,
|
|
select_season: select_season,
|
|
start_date: start_date,
|
|
end_date: end_date,
|
|
status: status$5,
|
|
rules: rules,
|
|
rules_placeholder: rules_placeholder,
|
|
invalid_json: invalid_json$1,
|
|
create_btn: create_btn,
|
|
season_id_label: season_id_label,
|
|
save_error: save_error$1
|
|
};
|
|
|
|
var title$a = "Leaderboard";
|
|
var subtitle$7 = "Gamification leaderboard admin view";
|
|
var search$1 = "Search";
|
|
var level$2 = "Level";
|
|
var min_xp$1 = "Min XP";
|
|
var sort = "Sort";
|
|
var sort_xp = "By XP";
|
|
var sort_points = "By Points";
|
|
var sort_social = "By Social Points";
|
|
var sort_level = "By Level";
|
|
var filter$1 = "Filter";
|
|
var reset$1 = "Reset";
|
|
var descending = "Descending";
|
|
var ascending = "Ascending";
|
|
var user$1 = "user";
|
|
var loading$a = "Loading leaderboard...";
|
|
var error$4 = "Failed to load leaderboard.";
|
|
var retry$9 = "Retry";
|
|
var no_results$4 = "No results match your filters.";
|
|
var no_results_hint$1 = "Try different filter criteria.";
|
|
var user_col = "User";
|
|
var email$2 = "Email";
|
|
var xp$2 = "XP";
|
|
var points$2 = "Points";
|
|
var social = "Social";
|
|
var penalty$2 = "Penalty";
|
|
var restriction$1 = "Restriction";
|
|
var discoveries$1 = "Discoveries";
|
|
var services$2 = "Services";
|
|
var updated$2 = "Last Updated";
|
|
var actions$5 = "Actions";
|
|
var details$2 = "Details";
|
|
var prev$4 = "Previous";
|
|
var next$4 = "Next";
|
|
var page_of = "/ page";
|
|
var restriction_mild$1 = "Mild";
|
|
var restriction_moderate$1 = "Moderate";
|
|
var restriction_severe$1 = "Severe";
|
|
const locale_leaderboard_46json_5d6b4d68 = {
|
|
title: title$a,
|
|
subtitle: subtitle$7,
|
|
search: search$1,
|
|
level: level$2,
|
|
min_xp: min_xp$1,
|
|
sort: sort,
|
|
sort_xp: sort_xp,
|
|
sort_points: sort_points,
|
|
sort_social: sort_social,
|
|
sort_level: sort_level,
|
|
filter: filter$1,
|
|
reset: reset$1,
|
|
descending: descending,
|
|
ascending: ascending,
|
|
user: user$1,
|
|
loading: loading$a,
|
|
error: error$4,
|
|
retry: retry$9,
|
|
no_results: no_results$4,
|
|
no_results_hint: no_results_hint$1,
|
|
user_col: user_col,
|
|
email: email$2,
|
|
xp: xp$2,
|
|
points: points$2,
|
|
social: social,
|
|
penalty: penalty$2,
|
|
restriction: restriction$1,
|
|
discoveries: discoveries$1,
|
|
services: services$2,
|
|
updated: updated$2,
|
|
actions: actions$5,
|
|
details: details$2,
|
|
prev: prev$4,
|
|
next: next$4,
|
|
page_of: page_of,
|
|
restriction_mild: restriction_mild$1,
|
|
restriction_moderate: restriction_moderate$1,
|
|
restriction_severe: restriction_severe$1
|
|
};
|
|
|
|
var title$9 = "Points Ledger";
|
|
var subtitle$6 = "Gamification points ledger browser";
|
|
var loading$9 = "Loading ledger...";
|
|
var error$3 = "Failed to load ledger.";
|
|
var user_id$2 = "User ID";
|
|
var date_from = "Date From";
|
|
var date_to = "Date To";
|
|
var reason = "Reason";
|
|
var search = "Search";
|
|
var clear = "Clear";
|
|
var csv = "CSV";
|
|
var no_results$3 = "No results match your filters.";
|
|
var no_results_hint = "Try different filter criteria.";
|
|
var id = "ID";
|
|
var user = "User";
|
|
var points$1 = "Points";
|
|
var penalty$1 = "Penalty";
|
|
var xp$1 = "XP";
|
|
var source = "Source";
|
|
var date = "Date";
|
|
var prev$3 = "Previous";
|
|
var next$3 = "Next";
|
|
var of = "of";
|
|
var showing$2 = "showing";
|
|
var filtered = "(filtered)";
|
|
var no_csv_data = "No data for CSV export.";
|
|
var csv_downloaded = "CSV download started.";
|
|
const locale_ledger_46json_a57c503c = {
|
|
title: title$9,
|
|
subtitle: subtitle$6,
|
|
loading: loading$9,
|
|
error: error$3,
|
|
user_id: user_id$2,
|
|
date_from: date_from,
|
|
date_to: date_to,
|
|
reason: reason,
|
|
search: search,
|
|
clear: clear,
|
|
csv: csv,
|
|
no_results: no_results$3,
|
|
no_results_hint: no_results_hint,
|
|
id: id,
|
|
user: user,
|
|
points: points$1,
|
|
penalty: penalty$1,
|
|
xp: xp$1,
|
|
source: source,
|
|
date: date,
|
|
prev: prev$3,
|
|
next: next$3,
|
|
of: of,
|
|
showing: showing$2,
|
|
filtered: filtered,
|
|
no_csv_data: no_csv_data,
|
|
csv_downloaded: csv_downloaded
|
|
};
|
|
|
|
var title$8 = "System Parameters";
|
|
var subtitle$5 = "Gamification category system parameters";
|
|
var loading$8 = "Loading parameters...";
|
|
var error$2 = "Failed to load system parameters.";
|
|
var retry$8 = "Retry";
|
|
var no_items = "No gamification system parameters.";
|
|
var key = "Key";
|
|
var value = "Value";
|
|
var category = "Category";
|
|
var scope = "Scope";
|
|
var scope_id$1 = "Scope ID";
|
|
var actions$4 = "Actions";
|
|
var edit$2 = "Edit";
|
|
var edit_title$1 = "Edit Parameter";
|
|
var value_label = "Value";
|
|
var value_placeholder = "Parameter value (JSON or plain text)";
|
|
var json_detected = "🔹 JSON format detected";
|
|
var text_value = "🔸 Text value";
|
|
var cancel$3 = "Cancel";
|
|
var save$4 = "Save";
|
|
var saving$2 = "Saving...";
|
|
var invalid_json = "Invalid JSON format: ";
|
|
var save_error = "Failed to save parameter.";
|
|
var updated$1 = "updated!";
|
|
const locale_params_46json_547e4949 = {
|
|
title: title$8,
|
|
subtitle: subtitle$5,
|
|
loading: loading$8,
|
|
error: error$2,
|
|
retry: retry$8,
|
|
no_items: no_items,
|
|
key: key,
|
|
value: value,
|
|
category: category,
|
|
scope: scope,
|
|
scope_id: scope_id$1,
|
|
actions: actions$4,
|
|
edit: edit$2,
|
|
edit_title: edit_title$1,
|
|
value_label: value_label,
|
|
value_placeholder: value_placeholder,
|
|
json_detected: json_detected,
|
|
text_value: text_value,
|
|
cancel: cancel$3,
|
|
save: save$4,
|
|
saving: saving$2,
|
|
invalid_json: invalid_json,
|
|
save_error: save_error,
|
|
updated: updated$1
|
|
};
|
|
|
|
var title$7 = "Package Management";
|
|
var subtitle$4 = "Manage subscription packages and features — Free, Premium, Enterprise";
|
|
var loading$7 = "Loading packages...";
|
|
var retry$7 = "Retry";
|
|
var create_new = "New Package";
|
|
var no_packages = "No packages yet";
|
|
var no_packages_desc = "Create your first subscription package to get started.";
|
|
var create_first = "Create First Package";
|
|
var popular = "Popular";
|
|
var fallback_badge = "Fallback";
|
|
var trial_badge = "Trial";
|
|
var month = "mo";
|
|
var feature_flags$1 = "Available Features";
|
|
var edit$1 = "Edit";
|
|
var duplicate = "Duplicate";
|
|
var set_as_default = "Set as Default";
|
|
var set_as_default_success = "set as default package!";
|
|
var edit_title = "Edit Package";
|
|
var create_title = "Create Package";
|
|
var cancel$2 = "Cancel";
|
|
var save$3 = "Save Changes";
|
|
var create = "Create";
|
|
var save_success = "Package updated successfully!";
|
|
var delete_title = "Delete Package";
|
|
var delete_confirm = "Are you sure you want to delete \"{name}\"?";
|
|
var delete_btn = "Delete";
|
|
var allowances = "Allowances";
|
|
var max_vehicles$1 = "Max Vehicles";
|
|
var max_garages$1 = "Max Garages";
|
|
var max_users = "Max Users";
|
|
var monthly_credits = "Monthly Credits";
|
|
var tier_level$1 = "Level";
|
|
var form_name = "System Name";
|
|
var form_name_placeholder = "e.g. premium_2024";
|
|
var form_display_name = "Display Name";
|
|
var form_display_name_placeholder = "e.g. Premium Plus";
|
|
var form_type = "Type";
|
|
var type_private = "Private";
|
|
var type_corporate = "Corporate";
|
|
var form_tier_level = "Tier Level";
|
|
var form_tier_level_hint = "Higher number = more features and higher rank";
|
|
var form_monthly_price = "Monthly Price";
|
|
var form_yearly_price = "Yearly Price";
|
|
var form_currency = "Currency";
|
|
var form_subtitle = "Subtitle / Description";
|
|
var form_subtitle_placeholder = "e.g. Ideal for small businesses";
|
|
var form_badge = "Badge Text";
|
|
var form_badge_placeholder = "e.g. Most Popular";
|
|
var form_is_custom = "Custom Package (not public)";
|
|
var singleton_rules = "Singleton Rules";
|
|
var form_is_default_fallback = "Default Fallback Package — expired subscriptions fall back to this";
|
|
var form_trial_days = "Trial Days on Signup";
|
|
var form_trial_days_hint = "New organizations get this many free days. Only one package can have > 0.";
|
|
var per_region_pricing = "Per-Region Pricing";
|
|
var smart_calculator = "Smart Price Calculator";
|
|
var calc_net_price = "Net Price";
|
|
var calc_vat_rate = "VAT Rate";
|
|
var calc_currency = "Currency";
|
|
var calc_net = "Net";
|
|
var calc_vat = "VAT";
|
|
var calc_gross = "Gross";
|
|
var calc_apply = "Apply to selected region";
|
|
var add_zone = "Add New Zone";
|
|
var add_zone_select = "Select country code...";
|
|
var add_zone_already_exists = "This region already exists in the package pricing!";
|
|
const locale_packages_46json_136e77b0 = {
|
|
title: title$7,
|
|
subtitle: subtitle$4,
|
|
loading: loading$7,
|
|
retry: retry$7,
|
|
create_new: create_new,
|
|
no_packages: no_packages,
|
|
no_packages_desc: no_packages_desc,
|
|
create_first: create_first,
|
|
popular: popular,
|
|
fallback_badge: fallback_badge,
|
|
trial_badge: trial_badge,
|
|
month: month,
|
|
feature_flags: feature_flags$1,
|
|
edit: edit$1,
|
|
duplicate: duplicate,
|
|
"delete": "Delete",
|
|
set_as_default: set_as_default,
|
|
set_as_default_success: set_as_default_success,
|
|
edit_title: edit_title,
|
|
create_title: create_title,
|
|
cancel: cancel$2,
|
|
save: save$3,
|
|
create: create,
|
|
save_success: save_success,
|
|
delete_title: delete_title,
|
|
delete_confirm: delete_confirm,
|
|
delete_btn: delete_btn,
|
|
allowances: allowances,
|
|
max_vehicles: max_vehicles$1,
|
|
max_garages: max_garages$1,
|
|
max_users: max_users,
|
|
monthly_credits: monthly_credits,
|
|
tier_level: tier_level$1,
|
|
form_name: form_name,
|
|
form_name_placeholder: form_name_placeholder,
|
|
form_display_name: form_display_name,
|
|
form_display_name_placeholder: form_display_name_placeholder,
|
|
form_type: form_type,
|
|
type_private: type_private,
|
|
type_corporate: type_corporate,
|
|
form_tier_level: form_tier_level,
|
|
form_tier_level_hint: form_tier_level_hint,
|
|
form_monthly_price: form_monthly_price,
|
|
form_yearly_price: form_yearly_price,
|
|
form_currency: form_currency,
|
|
form_subtitle: form_subtitle,
|
|
form_subtitle_placeholder: form_subtitle_placeholder,
|
|
form_badge: form_badge,
|
|
form_badge_placeholder: form_badge_placeholder,
|
|
form_is_custom: form_is_custom,
|
|
singleton_rules: singleton_rules,
|
|
form_is_default_fallback: form_is_default_fallback,
|
|
form_trial_days: form_trial_days,
|
|
form_trial_days_hint: form_trial_days_hint,
|
|
per_region_pricing: per_region_pricing,
|
|
smart_calculator: smart_calculator,
|
|
calc_net_price: calc_net_price,
|
|
calc_vat_rate: calc_vat_rate,
|
|
calc_currency: calc_currency,
|
|
calc_net: calc_net,
|
|
calc_vat: calc_vat,
|
|
calc_gross: calc_gross,
|
|
calc_apply: calc_apply,
|
|
add_zone: add_zone,
|
|
add_zone_select: add_zone_select,
|
|
add_zone_already_exists: add_zone_already_exists
|
|
};
|
|
|
|
var title$6 = "Person Management";
|
|
var subtitle$3 = "Person list, search, filters and details";
|
|
var loading$6 = "Loading persons...";
|
|
var retry$6 = "Retry";
|
|
var search_placeholder$1 = "Search by name, phone or email...";
|
|
var all_ghost_statuses = "All ghost statuses";
|
|
var ghost_no = "Not ghost";
|
|
var ghost_yes = "Ghost";
|
|
var all_active_statuses = "All active statuses";
|
|
var active_yes = "Active";
|
|
var active_no = "Inactive";
|
|
var all_user_statuses = "All user statuses";
|
|
var has_user_yes = "Has user";
|
|
var has_user_no = "No user";
|
|
var all_merged_statuses = "All merged statuses";
|
|
var merged_no = "Not merged";
|
|
var merged_yes = "Merged";
|
|
var total_persons = "Total Persons";
|
|
var active_persons = "Active Persons";
|
|
var ghost_persons = "Ghost Persons";
|
|
var merged_persons = "Merged Persons";
|
|
var filtered_results$1 = "Filtered results";
|
|
var name$2 = "Name";
|
|
var phone$1 = "Phone";
|
|
var birth_date$1 = "Birth Date";
|
|
var status$4 = "Status";
|
|
var users_count = "Users";
|
|
var active_user = "Active User";
|
|
var address$2 = "Address";
|
|
var actions$3 = "Actions";
|
|
var active = "Active";
|
|
var inactive = "Inactive";
|
|
var ghost = "Ghost";
|
|
var merged = "Merged";
|
|
var view$1 = "View";
|
|
var no_results$2 = "No persons match your search.";
|
|
var showing$1 = "Showing";
|
|
var prev$2 = "Previous";
|
|
var next$2 = "Next";
|
|
var details$1 = {
|
|
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_persons_46json_9073f88f = {
|
|
title: title$6,
|
|
subtitle: subtitle$3,
|
|
loading: loading$6,
|
|
retry: retry$6,
|
|
search_placeholder: search_placeholder$1,
|
|
all_ghost_statuses: all_ghost_statuses,
|
|
ghost_no: ghost_no,
|
|
ghost_yes: ghost_yes,
|
|
all_active_statuses: all_active_statuses,
|
|
active_yes: active_yes,
|
|
active_no: active_no,
|
|
all_user_statuses: all_user_statuses,
|
|
has_user_yes: has_user_yes,
|
|
has_user_no: has_user_no,
|
|
all_merged_statuses: all_merged_statuses,
|
|
merged_no: merged_no,
|
|
merged_yes: merged_yes,
|
|
total_persons: total_persons,
|
|
active_persons: active_persons,
|
|
ghost_persons: ghost_persons,
|
|
merged_persons: merged_persons,
|
|
filtered_results: filtered_results$1,
|
|
name: name$2,
|
|
phone: phone$1,
|
|
birth_date: birth_date$1,
|
|
status: status$4,
|
|
users_count: users_count,
|
|
active_user: active_user,
|
|
address: address$2,
|
|
actions: actions$3,
|
|
active: active,
|
|
inactive: inactive,
|
|
ghost: ghost,
|
|
merged: merged,
|
|
view: view$1,
|
|
no_results: no_results$2,
|
|
showing: showing$1,
|
|
prev: prev$2,
|
|
next: next$2,
|
|
details: details$1
|
|
};
|
|
|
|
var title$5 = "Permissions Management";
|
|
var subtitle$2 = "Permission Matrix — Role-based access control";
|
|
var loading$5 = "Loading permissions...";
|
|
var error_title = "Failed to load permissions";
|
|
var retry$5 = "Retry";
|
|
var save_changes = "Save Changes";
|
|
var discard = "Discard";
|
|
var modified_count = "{count} changes";
|
|
var domain_filter = "Domain Filter (Rows)";
|
|
var role_filter = "Role Filter (Columns)";
|
|
var select_all = "Select All";
|
|
var deselect_all = "Deselect All";
|
|
var all_domains = "All";
|
|
var permission = "Permission";
|
|
var no_permissions = "No permissions in this domain.";
|
|
var current_tier = "Current Package";
|
|
var expires = "Expires";
|
|
var superadmin = "Superadmin";
|
|
var superadmin_desc = "Full system access — users, billing, robots and system configuration.";
|
|
var garages = "Garages";
|
|
var garages_desc = "Garage-level access — vehicle management, service booking, customer data.";
|
|
var feature_flags = "Feature Flags";
|
|
var feature_flags_desc = "Subscription features — based on your current plan ({tier}).";
|
|
var rbac_title = "RBAC Permission Matrix";
|
|
var rbac_desc = "Role-based access control — which roles can perform which admin actions.";
|
|
var action = "Action";
|
|
const locale_permissions_46json_1a97671f = {
|
|
title: title$5,
|
|
subtitle: subtitle$2,
|
|
loading: loading$5,
|
|
error_title: error_title,
|
|
retry: retry$5,
|
|
save_changes: save_changes,
|
|
discard: discard,
|
|
modified_count: modified_count,
|
|
domain_filter: domain_filter,
|
|
role_filter: role_filter,
|
|
select_all: select_all,
|
|
deselect_all: deselect_all,
|
|
all_domains: all_domains,
|
|
permission: permission,
|
|
no_permissions: no_permissions,
|
|
current_tier: current_tier,
|
|
expires: expires,
|
|
superadmin: superadmin,
|
|
superadmin_desc: superadmin_desc,
|
|
garages: garages,
|
|
garages_desc: garages_desc,
|
|
feature_flags: feature_flags,
|
|
feature_flags_desc: feature_flags_desc,
|
|
rbac_title: rbac_title,
|
|
rbac_desc: rbac_desc,
|
|
action: action
|
|
};
|
|
|
|
var title$4 = "User Management";
|
|
var subtitle$1 = "User list, search, filters and bulk actions";
|
|
var loading$4 = "Loading users...";
|
|
var retry$4 = "Retry";
|
|
var search_placeholder = "Search by email, name or phone...";
|
|
var all_statuses = "All statuses";
|
|
var status_active$1 = "Active";
|
|
var status_inactive$1 = "Inactive";
|
|
var status_deleted = "Deleted";
|
|
var status_banned = "Banned";
|
|
var all_roles = "All roles";
|
|
var role_user = "User";
|
|
var role_admin = "Admin";
|
|
var role_staff = "Staff";
|
|
var role_superadmin = "Superadmin";
|
|
var all_plans = "All plans";
|
|
var plan_free = "Free";
|
|
var plan_premium = "Premium";
|
|
var plan_enterprise = "Enterprise";
|
|
var total_users = "Total Users";
|
|
var active_users = "Active Users";
|
|
var deleted_users = "Deleted Users";
|
|
var banned_users = "Banned Users";
|
|
var new_today = "New Today";
|
|
var filtered_results = "Filtered results";
|
|
var selected_count = "{count} user(s) selected";
|
|
var bulk_activate = "Activate";
|
|
var bulk_deactivate = "Deactivate";
|
|
var clear_selection = "Clear";
|
|
var email$1 = "Email";
|
|
var name$1 = "Name";
|
|
var role$1 = "Role";
|
|
var status$3 = "Status";
|
|
var registration = "Registration";
|
|
var language = "Language";
|
|
var actions$2 = "Actions";
|
|
var view = "View";
|
|
var activate = "Activate";
|
|
var deactivate = "Deactivate";
|
|
var no_results$1 = "No users match your search.";
|
|
var showing = "Showing";
|
|
var prev$1 = "Previous";
|
|
var next$1 = "Next";
|
|
const locale_users_46json_4a4a26a3 = {
|
|
title: title$4,
|
|
subtitle: subtitle$1,
|
|
loading: loading$4,
|
|
retry: retry$4,
|
|
search_placeholder: search_placeholder,
|
|
all_statuses: all_statuses,
|
|
status_active: status_active$1,
|
|
status_inactive: status_inactive$1,
|
|
status_deleted: status_deleted,
|
|
status_banned: status_banned,
|
|
all_roles: all_roles,
|
|
role_user: role_user,
|
|
role_admin: role_admin,
|
|
role_staff: role_staff,
|
|
role_superadmin: role_superadmin,
|
|
all_plans: all_plans,
|
|
plan_free: plan_free,
|
|
plan_premium: plan_premium,
|
|
plan_enterprise: plan_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: selected_count,
|
|
bulk_activate: bulk_activate,
|
|
bulk_deactivate: bulk_deactivate,
|
|
clear_selection: clear_selection,
|
|
email: email$1,
|
|
name: name$1,
|
|
role: role$1,
|
|
status: status$3,
|
|
"package": "Package",
|
|
registration: registration,
|
|
language: language,
|
|
actions: actions$2,
|
|
view: view,
|
|
activate: activate,
|
|
deactivate: deactivate,
|
|
no_results: no_results$1,
|
|
showing: showing,
|
|
prev: prev$1,
|
|
next: next$1
|
|
};
|
|
|
|
var loading$3 = "Loading user details...";
|
|
var retry$3 = "Retry";
|
|
var back$2 = "Back to Users";
|
|
var edit = "Edit User";
|
|
var edit_user = "Edit User";
|
|
var profile_tab = "Profile";
|
|
var memberships_tab = "Memberships";
|
|
var account_info = "Account Information";
|
|
var user_id$1 = "User ID";
|
|
var registration_date = "Registration Date";
|
|
var last_login = "Last Login";
|
|
var ui_mode = "UI Mode";
|
|
var region = "Region";
|
|
var currency = "Currency";
|
|
var subscription_info$1 = "Subscription Information";
|
|
var subscription_expires = "Expires At";
|
|
var scope_level = "Scope Level";
|
|
var scope_id = "Scope ID";
|
|
var max_vehicles = "Max Vehicles";
|
|
var max_garages = "Max Garages";
|
|
var personal_info = "Personal Information";
|
|
var last_name = "Last Name";
|
|
var first_name = "First Name";
|
|
var phone = "Phone";
|
|
var birth_place = "Birth Place";
|
|
var birth_date = "Birth Date";
|
|
var mothers_name = "Mother's Name";
|
|
var mothers_first_name = "Mother's First Name";
|
|
var address$1 = "Address";
|
|
var zip$1 = "ZIP Code";
|
|
var city$1 = "City";
|
|
var street = "Street";
|
|
var house_number$1 = "House Number";
|
|
var no_person_record = "No personal information record found for this user.";
|
|
var memberships = "Organization Memberships";
|
|
var memberships_count = "{count} membership(s)";
|
|
var no_memberships = "This user is not a member of any organization.";
|
|
var org_name = "Organization";
|
|
var org_role = "Role";
|
|
var member_status = "Status";
|
|
var joined_at = "Joined";
|
|
var verified = "Verified";
|
|
var verified_yes = "Yes";
|
|
var verified_no = "No";
|
|
var preferred_language = "Preferred Language";
|
|
var is_active = "Active";
|
|
var is_vip = "VIP";
|
|
var cancel$1 = "Cancel";
|
|
var save$2 = "Save Changes";
|
|
var saving$1 = "Saving...";
|
|
const locale_user_detail_46json_70e3135e = {
|
|
loading: loading$3,
|
|
retry: retry$3,
|
|
back: back$2,
|
|
edit: edit,
|
|
edit_user: edit_user,
|
|
profile_tab: profile_tab,
|
|
memberships_tab: memberships_tab,
|
|
account_info: account_info,
|
|
user_id: user_id$1,
|
|
registration_date: registration_date,
|
|
last_login: last_login,
|
|
ui_mode: ui_mode,
|
|
region: region,
|
|
currency: currency,
|
|
subscription_info: subscription_info$1,
|
|
subscription_expires: subscription_expires,
|
|
scope_level: scope_level,
|
|
scope_id: scope_id,
|
|
max_vehicles: max_vehicles,
|
|
max_garages: max_garages,
|
|
personal_info: personal_info,
|
|
last_name: last_name,
|
|
first_name: first_name,
|
|
phone: phone,
|
|
birth_place: birth_place,
|
|
birth_date: birth_date,
|
|
mothers_name: mothers_name,
|
|
mothers_first_name: mothers_first_name,
|
|
address: address$1,
|
|
zip: zip$1,
|
|
city: city$1,
|
|
street: street,
|
|
house_number: house_number$1,
|
|
no_person_record: no_person_record,
|
|
memberships: memberships,
|
|
memberships_count: memberships_count,
|
|
no_memberships: no_memberships,
|
|
org_name: org_name,
|
|
org_role: org_role,
|
|
member_status: member_status,
|
|
joined_at: joined_at,
|
|
verified: verified,
|
|
verified_yes: verified_yes,
|
|
verified_no: verified_no,
|
|
preferred_language: preferred_language,
|
|
is_active: is_active,
|
|
is_vip: is_vip,
|
|
cancel: cancel$1,
|
|
save: save$2,
|
|
saving: saving$1
|
|
};
|
|
|
|
var title$3 = "Gamification Users";
|
|
var subtitle = "User gamification statistics management";
|
|
var loading$2 = "Loading users...";
|
|
var error$1 = "Failed to load user statistics.";
|
|
var retry$2 = "Retry";
|
|
var no_results = "No user statistics to display.";
|
|
var level$1 = "Level";
|
|
var all_levels = "All Levels";
|
|
var level_n$1 = "Level {n}";
|
|
var min_xp = "Minimum XP";
|
|
var max_xp = "Maximum XP";
|
|
var penalty = "Penalty";
|
|
var any = "Any";
|
|
var only_penalized = "Only penalized";
|
|
var only_clean = "Only clean";
|
|
var filter = "Filter";
|
|
var reset = "Reset";
|
|
var count = "users";
|
|
var user_id = "User ID";
|
|
var xp = "XP";
|
|
var points = "Points";
|
|
var restriction = "Restriction";
|
|
var services$1 = "Services";
|
|
var discoveries = "Discoveries";
|
|
var updated = "Last Updated";
|
|
var actions$1 = "Actions";
|
|
var details = "Details";
|
|
var prev = "Previous";
|
|
var next = "Next";
|
|
var none = "None";
|
|
var restriction_mild = "Mild";
|
|
var restriction_moderate = "Moderate";
|
|
var restriction_severe = "Severe";
|
|
const locale_gamification_users_46json_efe94fdc = {
|
|
title: title$3,
|
|
subtitle: subtitle,
|
|
loading: loading$2,
|
|
error: error$1,
|
|
retry: retry$2,
|
|
no_results: no_results,
|
|
level: level$1,
|
|
all_levels: all_levels,
|
|
level_n: level_n$1,
|
|
min_xp: min_xp,
|
|
max_xp: max_xp,
|
|
penalty: penalty,
|
|
any: any,
|
|
only_penalized: only_penalized,
|
|
only_clean: only_clean,
|
|
filter: filter,
|
|
reset: reset,
|
|
count: count,
|
|
user_id: user_id,
|
|
xp: xp,
|
|
points: points,
|
|
restriction: restriction,
|
|
services: services$1,
|
|
discoveries: discoveries,
|
|
updated: updated,
|
|
actions: actions$1,
|
|
details: details,
|
|
prev: prev,
|
|
next: next,
|
|
none: none,
|
|
restriction_mild: restriction_mild,
|
|
restriction_moderate: restriction_moderate,
|
|
restriction_severe: restriction_severe
|
|
};
|
|
|
|
var back$1 = "Back to list";
|
|
var title$2 = "User Gamification Details";
|
|
var id_label = "ID:";
|
|
var loading$1 = "Loading user...";
|
|
var error = "Failed to load user data.";
|
|
var retry$1 = "Retry";
|
|
var not_found = "User not found.";
|
|
var total_xp = "Total XP";
|
|
var level = "Level";
|
|
var total_points = "Total Points";
|
|
var social_points = "Social Points";
|
|
var penalty_points = "Penalty Points";
|
|
var restriction_level = "Restriction Level";
|
|
var penalty_quota = "Penalty Quota";
|
|
var banned_until = "Banned Until";
|
|
var no = "No";
|
|
var services = "Services";
|
|
var discovered_places = "Discovered Places";
|
|
var validated_places = "Validated Places";
|
|
var added_providers = "Added Providers";
|
|
var penalty_form_title = "Assign Penalty";
|
|
var penalty_points_label = "Penalty Points";
|
|
var penalty_reason_label = "Reason";
|
|
var penalty_reason_placeholder = "Reason for penalty...";
|
|
var penalty_submit = "Assign Penalty";
|
|
var penalty_submitting = "Submitting...";
|
|
var penalty_success = "Penalty successfully assigned: {amount} points.";
|
|
var penalty_error = "Failed to assign penalty.";
|
|
var reward_form_title = "Assign Reward";
|
|
var reward_xp_label = "XP Reward";
|
|
var reward_social_label = "Social Points Reward";
|
|
var reward_reason_label = "Reason";
|
|
var reward_reason_placeholder = "Reason for reward...";
|
|
var reward_submit = "Assign Reward";
|
|
var reward_submitting = "Submitting...";
|
|
var reward_success = "Reward successfully assigned: {xp} XP, {social} social points.";
|
|
var reward_error = "Failed to assign reward.";
|
|
var ledger_title = "Points Ledger";
|
|
var ledger_count = "entries";
|
|
var ledger_loading = "Loading...";
|
|
var ledger_empty = "No ledger entries for this user yet.";
|
|
var ledger_date = "Date";
|
|
var ledger_points = "Points";
|
|
var ledger_penalty = "Penalty";
|
|
var ledger_xp = "XP";
|
|
var ledger_reason = "Reason";
|
|
var ledger_source = "Source";
|
|
const locale_gamification_user_detail_46json_2d359411 = {
|
|
back: back$1,
|
|
title: title$2,
|
|
id_label: id_label,
|
|
loading: loading$1,
|
|
error: error,
|
|
retry: retry$1,
|
|
not_found: 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: penalty_form_title,
|
|
penalty_points_label: penalty_points_label,
|
|
penalty_reason_label: penalty_reason_label,
|
|
penalty_reason_placeholder: penalty_reason_placeholder,
|
|
penalty_submit: penalty_submit,
|
|
penalty_submitting: penalty_submitting,
|
|
penalty_success: penalty_success,
|
|
penalty_error: penalty_error,
|
|
reward_form_title: reward_form_title,
|
|
reward_xp_label: reward_xp_label,
|
|
reward_social_label: reward_social_label,
|
|
reward_reason_label: reward_reason_label,
|
|
reward_reason_placeholder: reward_reason_placeholder,
|
|
reward_submit: reward_submit,
|
|
reward_submitting: reward_submitting,
|
|
reward_success: reward_success,
|
|
reward_error: reward_error,
|
|
ledger_title: ledger_title,
|
|
ledger_count: ledger_count,
|
|
ledger_loading: ledger_loading,
|
|
ledger_empty: ledger_empty,
|
|
ledger_date: ledger_date,
|
|
ledger_points: ledger_points,
|
|
ledger_penalty: ledger_penalty,
|
|
ledger_xp: ledger_xp,
|
|
ledger_reason: ledger_reason,
|
|
ledger_source: ledger_source
|
|
};
|
|
|
|
var loading = "Loading garage details...";
|
|
var retry = "Retry";
|
|
var back = "Back to garages";
|
|
var company_info = "Company Info";
|
|
var company_name = "Company Name";
|
|
var display_name = "Display Name";
|
|
var org_type = "Organization Type";
|
|
var tax_number = "Tax Number";
|
|
var reg_number = "Registration Number";
|
|
var created_at = "Created At";
|
|
var address = "Address";
|
|
var subscription_info = "Subscription Status";
|
|
var tier_name = "Package";
|
|
var tier_level = "Level";
|
|
var level_n = "Level {n}";
|
|
var expires_at = "Expires";
|
|
var asset_limit = "Vehicle Limit";
|
|
var vehicles = "vehicles";
|
|
var no_subscription = "No active subscription";
|
|
var contact_info = "Contact Info";
|
|
var contact_name = "Contact Name";
|
|
var contact_role = "Role";
|
|
var contact_department = "Department";
|
|
var contact_phone = "Contact Phone";
|
|
var no_contact = "No primary contact person";
|
|
var edit_details = "Edit Details";
|
|
var save$1 = "Save";
|
|
var generalTab = "General";
|
|
var employeesTab = "Employees";
|
|
var fleetTab = "Fleet";
|
|
var analyticsTab = "Analytics";
|
|
var subscriptionTab = "Subscription";
|
|
var editBasicTab = "Basic Info";
|
|
var editContactTab = "Contact";
|
|
var editAddressTab = "Addresses";
|
|
var zip = "ZIP Code";
|
|
var city = "City";
|
|
var street_name = "Street";
|
|
var street_type = "Street Type";
|
|
var house_number = "House Number";
|
|
var coming_soon = "This feature will be available soon...";
|
|
var missing_data_title = "Missing Data";
|
|
var missing_data_desc = "The garage profile is incomplete. Please fill in the missing fields.";
|
|
var missing_data_activation_required = "To activate the garage, the following data must be provided:";
|
|
var missing_tax_number = "Tax Number";
|
|
var missing_billing = "Billing Address";
|
|
var missing_contact_email = "Contact Email";
|
|
var missing_contact_phone = "Contact Phone";
|
|
var missing_data_count = "{count} fields missing";
|
|
var contact_person_name = "Contact Person Name";
|
|
var contact_email = "Contact Email";
|
|
var billing_address = "Billing Address";
|
|
var billing_zip = "ZIP Code";
|
|
var billing_city = "City";
|
|
var billing_street_name = "Street";
|
|
var billing_street_type = "Street Type";
|
|
var billing_house_number = "House Number";
|
|
var notification_address = "Notification Address";
|
|
var notification_zip = "ZIP Code";
|
|
var notification_city = "City";
|
|
var notification_street_name = "Street";
|
|
var notification_street_type = "Street Type";
|
|
var notification_house_number = "House Number";
|
|
var tab_basic = "Basic Info";
|
|
var tab_contact = "Contact";
|
|
var tab_addresses = "Addresses";
|
|
var basic_info = "Basic Info";
|
|
var contact_section = "Contact Person";
|
|
var addresses_section = "Addresses";
|
|
var vehicles_used = "Vehicles";
|
|
var branches_used = "Branches";
|
|
var employees_used = "Employees";
|
|
var branches = "branches";
|
|
var employees = "employees";
|
|
var status$2 = "Status";
|
|
var subscription_history = "Subscription History";
|
|
var history_date = "Date";
|
|
var history_package = "Package";
|
|
var history_action = "Action";
|
|
var history_status = "Status";
|
|
var no_subscription_history = "No subscription history yet.";
|
|
const locale_garages_45details_46json_120e8b3b = {
|
|
loading: loading,
|
|
retry: retry,
|
|
back: back,
|
|
company_info: company_info,
|
|
company_name: company_name,
|
|
display_name: display_name,
|
|
org_type: org_type,
|
|
tax_number: tax_number,
|
|
reg_number: reg_number,
|
|
created_at: created_at,
|
|
address: address,
|
|
subscription_info: subscription_info,
|
|
tier_name: tier_name,
|
|
tier_level: tier_level,
|
|
level_n: level_n,
|
|
expires_at: expires_at,
|
|
asset_limit: asset_limit,
|
|
vehicles: vehicles,
|
|
no_subscription: no_subscription,
|
|
contact_info: contact_info,
|
|
contact_name: contact_name,
|
|
contact_role: contact_role,
|
|
contact_department: contact_department,
|
|
contact_phone: contact_phone,
|
|
no_contact: no_contact,
|
|
edit_details: edit_details,
|
|
save: save$1,
|
|
generalTab: generalTab,
|
|
employeesTab: employeesTab,
|
|
fleetTab: fleetTab,
|
|
analyticsTab: analyticsTab,
|
|
subscriptionTab: subscriptionTab,
|
|
editBasicTab: editBasicTab,
|
|
editContactTab: editContactTab,
|
|
editAddressTab: editAddressTab,
|
|
zip: zip,
|
|
city: city,
|
|
street_name: street_name,
|
|
street_type: street_type,
|
|
house_number: house_number,
|
|
coming_soon: coming_soon,
|
|
missing_data_title: missing_data_title,
|
|
missing_data_desc: missing_data_desc,
|
|
missing_data_activation_required: missing_data_activation_required,
|
|
missing_tax_number: missing_tax_number,
|
|
missing_billing: missing_billing,
|
|
missing_contact_email: missing_contact_email,
|
|
missing_contact_phone: missing_contact_phone,
|
|
missing_data_count: missing_data_count,
|
|
contact_person_name: contact_person_name,
|
|
contact_email: contact_email,
|
|
billing_address: billing_address,
|
|
billing_zip: billing_zip,
|
|
billing_city: billing_city,
|
|
billing_street_name: billing_street_name,
|
|
billing_street_type: billing_street_type,
|
|
billing_house_number: billing_house_number,
|
|
notification_address: notification_address,
|
|
notification_zip: notification_zip,
|
|
notification_city: notification_city,
|
|
notification_street_name: notification_street_name,
|
|
notification_street_type: notification_street_type,
|
|
notification_house_number: notification_house_number,
|
|
tab_basic: tab_basic,
|
|
tab_contact: tab_contact,
|
|
tab_addresses: tab_addresses,
|
|
basic_info: basic_info,
|
|
contact_section: contact_section,
|
|
addresses_section: addresses_section,
|
|
vehicles_used: vehicles_used,
|
|
branches_used: branches_used,
|
|
employees_used: employees_used,
|
|
branches: branches,
|
|
employees: employees,
|
|
status: status$2,
|
|
subscription_history: subscription_history,
|
|
history_date: history_date,
|
|
history_package: history_package,
|
|
history_action: history_action,
|
|
history_status: history_status,
|
|
no_subscription_history: no_subscription_history
|
|
};
|
|
|
|
var title$1 = "Employees";
|
|
var total_count = "{count} employees";
|
|
var name = "Name";
|
|
var email_phone = "Email / Phone";
|
|
var role = "Role";
|
|
var status$1 = "Status";
|
|
var actions = "Actions";
|
|
var edit_role = "Edit";
|
|
var remove = "Remove";
|
|
var no_employees = "No employees assigned to this garage.";
|
|
var edit_role_title = "Edit Employee Role";
|
|
var editRoleTitle = "Edit Employee Role";
|
|
var editRoleFor = "Change role for {name}";
|
|
var cancel = "Cancel";
|
|
var save = "Save Changes";
|
|
var saveRole = "Save Role";
|
|
var saving = "Saving...";
|
|
var status_active = "Active";
|
|
var status_inactive = "Inactive";
|
|
var remove_title = "Remove Employee";
|
|
var removeTitle = "Remove Employee";
|
|
var remove_confirm = "Are you sure you want to remove \"{name}\" from this garage?";
|
|
var removeConfirm = "Are you sure you want to remove \"{name}\" from this garage?";
|
|
var remove_btn = "Remove";
|
|
var removing = "Removing...";
|
|
var add_employee = "Add Employee";
|
|
var addTitle = "Add New Employee";
|
|
var email = "Email Address";
|
|
var emailPlaceholder = "Enter email address...";
|
|
var roleMember = "Member";
|
|
var roleManager = "Manager";
|
|
var roleAdmin = "Admin";
|
|
var roleOwner = "Owner";
|
|
var add = "Add Employee";
|
|
var adding = "Adding...";
|
|
const locale_garages_45employees_46json_f286a7ef = {
|
|
title: title$1,
|
|
total_count: total_count,
|
|
name: name,
|
|
email_phone: email_phone,
|
|
role: role,
|
|
status: status$1,
|
|
actions: actions,
|
|
edit_role: edit_role,
|
|
remove: remove,
|
|
no_employees: no_employees,
|
|
edit_role_title: edit_role_title,
|
|
editRoleTitle: editRoleTitle,
|
|
editRoleFor: editRoleFor,
|
|
cancel: cancel,
|
|
save: save,
|
|
saveRole: saveRole,
|
|
saving: saving,
|
|
status_active: status_active,
|
|
status_inactive: status_inactive,
|
|
remove_title: remove_title,
|
|
removeTitle: removeTitle,
|
|
remove_confirm: remove_confirm,
|
|
removeConfirm: removeConfirm,
|
|
remove_btn: remove_btn,
|
|
removing: removing,
|
|
add_employee: add_employee,
|
|
addTitle: addTitle,
|
|
email: email,
|
|
emailPlaceholder: emailPlaceholder,
|
|
roleMember: roleMember,
|
|
roleManager: roleManager,
|
|
roleAdmin: roleAdmin,
|
|
roleOwner: roleOwner,
|
|
add: add,
|
|
adding: adding
|
|
};
|
|
|
|
var title = "Fleet";
|
|
var total_vehicles = "{count} vehicles total";
|
|
var plate = "Plate";
|
|
var brand = "Brand";
|
|
var model = "Model";
|
|
var brand_model = "Brand & Model";
|
|
var year = "Year";
|
|
var status = "Status";
|
|
var vin = "VIN";
|
|
var no_vehicles = "No vehicles assigned to this garage yet.";
|
|
var no_fleet_access = "You don't have permission to view fleet data.";
|
|
const locale_garages_45fleet_46json_ff8a32af = {
|
|
title: title,
|
|
total_vehicles: total_vehicles,
|
|
plate: plate,
|
|
brand: brand,
|
|
model: model,
|
|
brand_model: brand_model,
|
|
year: year,
|
|
status: status,
|
|
vin: vin,
|
|
no_vehicles: no_vehicles,
|
|
no_fleet_access: no_fleet_access
|
|
};
|
|
|
|
var ltv = "Lifetime Value (LTV)";
|
|
var mrr = "Monthly Revenue (MRR)";
|
|
var monthly_recurring = "Monthly recurring revenue";
|
|
var outstanding = "Outstanding";
|
|
var all_settled = "All invoices settled";
|
|
var earned_credits = "Earned Credits";
|
|
var contribution_xp = "XP earned from platform contributions";
|
|
var invited_companies = "Invited Companies";
|
|
var companies_joined = "Companies joined via your invite";
|
|
var validated_garages = "Validated Garages";
|
|
var garages_confirmed = "Garages successfully verified";
|
|
var utilization = "Utilization";
|
|
var vehicle_quota = "Vehicle Quota";
|
|
var employee_quota = "Employee Quota";
|
|
var utilized = "utilized";
|
|
var marketplace_engagement = "Marketplace & Engagement";
|
|
var avg_rating = "Average Rating";
|
|
var reviews = "Reviews";
|
|
var reviews_count = "reviews";
|
|
var last_activity = "Last Activity";
|
|
var last_login_mock = "2 hours ago";
|
|
var services_30d = "Services Completed (30 days)";
|
|
const locale_garages_45analytics_46json_477db261 = {
|
|
ltv: ltv,
|
|
mrr: mrr,
|
|
monthly_recurring: monthly_recurring,
|
|
outstanding: outstanding,
|
|
all_settled: all_settled,
|
|
earned_credits: earned_credits,
|
|
contribution_xp: contribution_xp,
|
|
invited_companies: invited_companies,
|
|
companies_joined: companies_joined,
|
|
validated_garages: validated_garages,
|
|
garages_confirmed: garages_confirmed,
|
|
utilization: utilization,
|
|
vehicle_quota: vehicle_quota,
|
|
employee_quota: employee_quota,
|
|
utilized: utilized,
|
|
marketplace_engagement: marketplace_engagement,
|
|
avg_rating: avg_rating,
|
|
reviews: reviews,
|
|
reviews_count: reviews_count,
|
|
last_activity: last_activity,
|
|
last_login_mock: last_login_mock,
|
|
services_30d: services_30d
|
|
};
|
|
|
|
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_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_dashboard_46json_d0703406",
|
|
load: () => Promise.resolve(locale_dashboard_46json_d0703406),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_config_46json_88e60c59",
|
|
load: () => Promise.resolve(locale_config_46json_88e60c59),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_badges_46json_3e08338d",
|
|
load: () => Promise.resolve(locale_badges_46json_3e08338d),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_levels_46json_ae6f2fe4",
|
|
load: () => Promise.resolve(locale_levels_46json_ae6f2fe4),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_point_rules_46json_bbf72486",
|
|
load: () => Promise.resolve(locale_point_rules_46json_bbf72486),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_seasons_46json_075b46de",
|
|
load: () => Promise.resolve(locale_seasons_46json_075b46de),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_competitions_46json_2f85d252",
|
|
load: () => Promise.resolve(locale_competitions_46json_2f85d252),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_leaderboard_46json_a72f79f0",
|
|
load: () => Promise.resolve(locale_leaderboard_46json_a72f79f0),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_ledger_46json_eba48ff6",
|
|
load: () => Promise.resolve(locale_ledger_46json_eba48ff6),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_params_46json_11c105c4",
|
|
load: () => Promise.resolve(locale_params_46json_11c105c4),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_packages_46json_15bd53c5",
|
|
load: () => Promise.resolve(locale_packages_46json_15bd53c5),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_persons_46json_39baf6d4",
|
|
load: () => Promise.resolve(locale_persons_46json_39baf6d4),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_permissions_46json_10a6b504",
|
|
load: () => Promise.resolve(locale_permissions_46json_10a6b504),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_users_46json_304d0127",
|
|
load: () => Promise.resolve(locale_users_46json_304d0127),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_user_detail_46json_f916c048",
|
|
load: () => Promise.resolve(locale_user_detail_46json_f916c048),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_gamification_users_46json_a890945b",
|
|
load: () => Promise.resolve(locale_gamification_users_46json_a890945b),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_gamification_user_detail_46json_465d14db",
|
|
load: () => Promise.resolve(locale_gamification_user_detail_46json_465d14db),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_garages_45details_46json_c9e5034e",
|
|
load: () => Promise.resolve(locale_garages_45details_46json_c9e5034e),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_garages_45employees_46json_5e5dc9e8",
|
|
load: () => Promise.resolve(locale_garages_45employees_46json_5e5dc9e8),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_garages_45fleet_46json_104aa8bd",
|
|
load: () => Promise.resolve(locale_garages_45fleet_46json_104aa8bd),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_garages_45analytics_46json_bffdef7b",
|
|
load: () => Promise.resolve(locale_garages_45analytics_46json_bffdef7b),
|
|
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_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_dashboard_46json_d9580386",
|
|
load: () => Promise.resolve(locale_dashboard_46json_d9580386),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_config_46json_994ab42b",
|
|
load: () => Promise.resolve(locale_config_46json_994ab42b),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_badges_46json_1ba3918d",
|
|
load: () => Promise.resolve(locale_badges_46json_1ba3918d),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_levels_46json_f5b071e8",
|
|
load: () => Promise.resolve(locale_levels_46json_f5b071e8),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_point_rules_46json_f0f77f0b",
|
|
load: () => Promise.resolve(locale_point_rules_46json_f0f77f0b),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_seasons_46json_2298cb58",
|
|
load: () => Promise.resolve(locale_seasons_46json_2298cb58),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_competitions_46json_9268c1cb",
|
|
load: () => Promise.resolve(locale_competitions_46json_9268c1cb),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_leaderboard_46json_5d6b4d68",
|
|
load: () => Promise.resolve(locale_leaderboard_46json_5d6b4d68),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_ledger_46json_a57c503c",
|
|
load: () => Promise.resolve(locale_ledger_46json_a57c503c),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_params_46json_547e4949",
|
|
load: () => Promise.resolve(locale_params_46json_547e4949),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_packages_46json_136e77b0",
|
|
load: () => Promise.resolve(locale_packages_46json_136e77b0),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_persons_46json_9073f88f",
|
|
load: () => Promise.resolve(locale_persons_46json_9073f88f),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_permissions_46json_1a97671f",
|
|
load: () => Promise.resolve(locale_permissions_46json_1a97671f),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_users_46json_4a4a26a3",
|
|
load: () => Promise.resolve(locale_users_46json_4a4a26a3),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_user_detail_46json_70e3135e",
|
|
load: () => Promise.resolve(locale_user_detail_46json_70e3135e),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_gamification_users_46json_efe94fdc",
|
|
load: () => Promise.resolve(locale_gamification_users_46json_efe94fdc),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_gamification_user_detail_46json_2d359411",
|
|
load: () => Promise.resolve(locale_gamification_user_detail_46json_2d359411),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_garages_45details_46json_120e8b3b",
|
|
load: () => Promise.resolve(locale_garages_45details_46json_120e8b3b),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_garages_45employees_46json_f286a7ef",
|
|
load: () => Promise.resolve(locale_garages_45employees_46json_f286a7ef),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_garages_45fleet_46json_ff8a32af",
|
|
load: () => Promise.resolve(locale_garages_45fleet_46json_ff8a32af),
|
|
cache: true
|
|
},
|
|
{
|
|
key: "locale_garages_45analytics_46json_477db261",
|
|
load: () => Promise.resolve(locale_garages_45analytics_46json_477db261),
|
|
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
|