,
+ );
+
+ await screen.getByRole("button", { name: "set" }).first().click();
+
+ for (const element of screen.getByTestId("ids").elements()) {
+ expect(element).toHaveTextContent("7");
+ }
+ expect(window.localStorage.getItem("test-recent-ids")).toBe("[7]");
+ });
+
+ test("updater form reads the current value", async () => {
+ window.localStorage.setItem("test-recent-ids", "[1,2,3]");
+ const screen = await render();
+
+ await screen.getByRole("button", { name: "prepend" }).click();
+
+ await expect.element(screen.getByTestId("ids")).toHaveTextContent("8,1,2");
+ });
+
+ test("storage events from other tabs sync the value", async () => {
+ const screen = await render();
+
+ window.localStorage.setItem("test-recent-ids", "[4,5]");
+ window.dispatchEvent(
+ new StorageEvent("storage", { key: "test-recent-ids" }),
+ );
+
+ await expect.element(screen.getByTestId("ids")).toHaveTextContent("4,5");
+ });
+});
+
+describe("usePersistedMapState", () => {
+ test("reads all entries under the prefix and syncs entry writes", async () => {
+ window.localStorage.setItem("test-counts__a", "1");
+ const screen = await render();
+
+ await expect.element(screen.getByTestId("counts")).toHaveTextContent("a=1");
+
+ PersistedState.writeMapEntry(counts, "b", 2);
+
+ await expect
+ .element(screen.getByTestId("counts"))
+ .toHaveTextContent("a=1,b=2");
+ });
+});
diff --git a/app/modules/persisted-state/hooks.ts b/app/modules/persisted-state/hooks.ts
new file mode 100644
index 000000000..c0c9e405f
--- /dev/null
+++ b/app/modules/persisted-state/hooks.ts
@@ -0,0 +1,53 @@
+import * as React from "react";
+import type {
+ PersistedDefinition,
+ PersistedMapDefinition,
+} from "./persisted-state";
+import * as PersistedState from "./persisted-state";
+
+const SERVER_MAP_SNAPSHOT: Record = {};
+
+/**
+ * Typed React state backed by a persisted definition. The value stays in sync
+ * across components and browser tabs; the setter accepts a value or an updater.
+ */
+export function usePersistedState(
+ definition: PersistedDefinition,
+): [T, (next: T | ((previous: T) => T)) => void] {
+ const subscribeToDefinition = React.useCallback(
+ (listener: () => void) => PersistedState.subscribe(definition, listener),
+ [definition],
+ );
+ const value = React.useSyncExternalStore(
+ subscribeToDefinition,
+ () => PersistedState.read(definition),
+ () => definition.default,
+ );
+
+ const setValue = (next: T | ((previous: T) => T)) => {
+ PersistedState.write(
+ definition,
+ typeof next === "function"
+ ? (next as (previous: T) => T)(PersistedState.read(definition))
+ : next,
+ );
+ };
+
+ return [value, setValue];
+}
+
+/** Read-only React view of a persisted map definition; write entries via `PersistedState.writeMapEntry`. */
+export function usePersistedMapState(
+ definition: PersistedMapDefinition,
+): Record {
+ const subscribeToDefinition = React.useCallback(
+ (listener: () => void) => PersistedState.subscribeMap(definition, listener),
+ [definition],
+ );
+
+ return React.useSyncExternalStore(
+ subscribeToDefinition,
+ () => PersistedState.readMap(definition),
+ () => SERVER_MAP_SNAPSHOT,
+ );
+}
diff --git a/app/modules/persisted-state/persisted-state-test-utils.ts b/app/modules/persisted-state/persisted-state-test-utils.ts
new file mode 100644
index 000000000..aefa88d74
--- /dev/null
+++ b/app/modules/persisted-state/persisted-state-test-utils.ts
@@ -0,0 +1,40 @@
+import { expect } from "vitest";
+import type {
+ PersistedDefinition,
+ PersistedMapDefinition,
+} from "./persisted-state";
+
+/**
+ * Asserts `decode(encode(x))` deep-equals `x` for every given example value,
+ * and that a missing value decodes to the default. Every feature definition
+ * registers a test with representative and edge-case values.
+ */
+export function assertRoundTrips(
+ definition: PersistedDefinition | PersistedMapDefinition,
+ examples: NoInfer[],
+) {
+ expect
+ .soft(definition.decode(null), "missing → default")
+ .toEqual(definition.default);
+
+ for (const value of examples) {
+ expect
+ .soft(
+ definition.decode(definition.encode(value)),
+ `round trip of ${JSON.stringify(value)}`,
+ )
+ .toEqual(value);
+ }
+}
+
+/** Asserts that each given raw stored string decodes to the definition's default. */
+export function assertDecodesToDefault(
+ definition: PersistedDefinition | PersistedMapDefinition,
+ raws: string[],
+) {
+ for (const raw of raws) {
+ expect
+ .soft(definition.decode(raw), `${JSON.stringify(raw)} → default`)
+ .toEqual(definition.default);
+ }
+}
diff --git a/app/modules/persisted-state/persisted-state.test.ts b/app/modules/persisted-state/persisted-state.test.ts
new file mode 100644
index 000000000..fb0f4e3d8
--- /dev/null
+++ b/app/modules/persisted-state/persisted-state.test.ts
@@ -0,0 +1,75 @@
+import { describe, expect, it } from "vitest";
+import { z } from "zod";
+import * as PersistedState from "./persisted-state";
+import {
+ assertDecodesToDefault,
+ assertRoundTrips,
+} from "./persisted-state-test-utils";
+
+const numberList = PersistedState.define({
+ key: "test-number-list",
+ storage: "local",
+ schema: z.array(z.number()),
+ default: [],
+});
+
+const searchType = PersistedState.define({
+ key: "test-search-type",
+ storage: "local",
+ schema: z.enum(["weapons", "users"]),
+ default: "weapons",
+});
+
+const dismissed = PersistedState.define({
+ key: "test-dismissed",
+ storage: "local",
+ schema: z.boolean(),
+ default: false,
+});
+
+const counts = PersistedState.defineMap({
+ keyPrefix: "test-counts__",
+ storage: "local",
+ schema: z.number(),
+ default: 0,
+});
+
+describe("define", () => {
+ it("round-trips values", () => {
+ assertRoundTrips(numberList, [[], [1, 2, 3]]);
+ assertRoundTrips(searchType, ["weapons", "users"]);
+ assertRoundTrips(dismissed, [true, false]);
+ assertRoundTrips(counts, [0, 42]);
+ });
+
+ it("malformed values decode to defaults", () => {
+ assertDecodesToDefault(numberList, ["not json", '{"a":1}', '["a","b"]']);
+ assertDecodesToDefault(searchType, ["teams", "[1,2]"]);
+ assertDecodesToDefault(dismissed, ["yes"]);
+ assertDecodesToDefault(counts, ["abc", "", "Infinity"]);
+ });
+
+ it("decodes legacy plain-string values where the schema allows them", () => {
+ expect(searchType.decode("users")).toBe("users");
+ expect(dismissed.decode("true")).toBe(true);
+ expect(counts.decode("7")).toBe(7);
+ });
+});
+
+describe("prependToRecentList", () => {
+ it("prepends a new item", () => {
+ expect(PersistedState.prependToRecentList([1, 2], 3, 5)).toEqual([3, 1, 2]);
+ });
+
+ it("moves an existing item to the front", () => {
+ expect(PersistedState.prependToRecentList([1, 2, 3], 2, 5)).toEqual([
+ 2, 1, 3,
+ ]);
+ });
+
+ it("caps the list length", () => {
+ expect(PersistedState.prependToRecentList([1, 2, 3], 4, 3)).toEqual([
+ 4, 1, 2,
+ ]);
+ });
+});
diff --git a/app/modules/persisted-state/persisted-state.ts b/app/modules/persisted-state/persisted-state.ts
new file mode 100644
index 000000000..8fc54fb6e
--- /dev/null
+++ b/app/modules/persisted-state/persisted-state.ts
@@ -0,0 +1,249 @@
+import type { z } from "zod";
+
+const readCaches = new WeakMap<
+ object,
+ { raw: string | null; value: unknown }
+>();
+const mapCaches = new WeakMap>();
+const listenersByDefinition = new WeakMap void>>();
+
+const SERVER_MAP_SNAPSHOT: Record = {};
+
+type StorageKind = "local" | "session";
+
+interface DefinitionBase {
+ storage: StorageKind;
+ default: T;
+ /** Decodes a raw stored string. Total: resolves to the default for missing or malformed values, never throws. */
+ decode: (raw: string | null) => T;
+ /** Encodes a value into its stored string form. */
+ encode: (value: T) => string;
+}
+
+export interface PersistedDefinition extends DefinitionBase {
+ key: string;
+}
+
+export interface PersistedMapDefinition extends DefinitionBase {
+ keyPrefix: string;
+}
+
+/**
+ * Declares a client state persisted in web storage. One definition per stored
+ * key drives reads, writes, cross-tab sync and the `usePersistedState` hook.
+ * Decoding is total: the default resolves for missing or malformed values,
+ * legacy plain-string values are accepted where the schema allows them.
+ */
+export function define(options: {
+ key: string;
+ storage: StorageKind;
+ schema: S;
+ default: z.output;
+}): PersistedDefinition> {
+ return {
+ key: options.key,
+ storage: options.storage,
+ default: options.default,
+ ...codec(options.schema, options.default),
+ };
+}
+
+/**
+ * Declares a keyed family of persisted values sharing a storage key prefix,
+ * for maps whose entries are written independently (e.g. per chat room).
+ */
+export function defineMap(options: {
+ keyPrefix: string;
+ storage: StorageKind;
+ schema: S;
+ default: z.output;
+}): PersistedMapDefinition> {
+ return {
+ keyPrefix: options.keyPrefix,
+ storage: options.storage,
+ default: options.default,
+ ...codec(options.schema, options.default),
+ };
+}
+
+/** Reads the persisted value, resolving to the default on the server or when the stored value is missing or malformed. */
+export function read(definition: PersistedDefinition): T {
+ if (typeof window === "undefined") return definition.default;
+
+ const raw = readRaw(definition.storage, definition.key);
+ const cached = readCaches.get(definition);
+ if (cached && cached.raw === raw) return cached.value as T;
+
+ const value = definition.decode(raw);
+ readCaches.set(definition, { raw, value });
+ return value;
+}
+
+/** Writes the value to web storage and notifies this tab's subscribers (other tabs sync via the `storage` event). */
+export function write(definition: PersistedDefinition, value: T) {
+ try {
+ storageOf(definition.storage).setItem(
+ definition.key,
+ definition.encode(value),
+ );
+ } catch {
+ // web storage may be unavailable
+ }
+ notify(definition);
+}
+
+/** Subscribes to changes of the persisted value, from both this tab's writes and other tabs via the `storage` event. */
+export function subscribe(
+ definition: PersistedDefinition,
+ listener: () => void,
+) {
+ const listeners = listenersOf(definition);
+ listeners.add(listener);
+
+ const handleStorageEvent = (event: StorageEvent) => {
+ if (event.key !== null && event.key !== definition.key) return;
+ listener();
+ };
+ window.addEventListener("storage", handleStorageEvent);
+
+ return () => {
+ listeners.delete(listener);
+ window.removeEventListener("storage", handleStorageEvent);
+ };
+}
+
+/** Reads all entries of a persisted map, keyed by the part of the storage key after the prefix. */
+export function readMap(
+ definition: PersistedMapDefinition,
+): Record {
+ if (typeof window === "undefined") {
+ return SERVER_MAP_SNAPSHOT as Record;
+ }
+
+ const cached = mapCaches.get(definition);
+ if (cached) return cached as Record;
+
+ const value = readMapFromStorage(definition);
+ mapCaches.set(definition, value);
+ return value;
+}
+
+/** Writes one entry of a persisted map and notifies this tab's subscribers (other tabs sync via the `storage` event). */
+export function writeMapEntry(
+ definition: PersistedMapDefinition,
+ entryKey: string,
+ value: T,
+) {
+ try {
+ storageOf(definition.storage).setItem(
+ `${definition.keyPrefix}${entryKey}`,
+ definition.encode(value),
+ );
+ } catch {
+ // web storage may be unavailable
+ }
+ mapCaches.delete(definition);
+ notify(definition);
+}
+
+/** Subscribes to changes of any entry of a persisted map, from both this tab's writes and other tabs via the `storage` event. */
+export function subscribeMap(
+ definition: PersistedMapDefinition,
+ listener: () => void,
+) {
+ const listeners = listenersOf(definition);
+ listeners.add(listener);
+
+ const handleStorageEvent = (event: StorageEvent) => {
+ if (event.key !== null && !event.key.startsWith(definition.keyPrefix)) {
+ return;
+ }
+ mapCaches.delete(definition);
+ listener();
+ };
+ window.addEventListener("storage", handleStorageEvent);
+
+ return () => {
+ listeners.delete(listener);
+ window.removeEventListener("storage", handleStorageEvent);
+ };
+}
+
+/** Moves `item` to the front of a most-recently-used list, deduplicating it and capping the list's length. */
+export function prependToRecentList(
+ items: readonly T[],
+ item: T,
+ maxLength: number,
+): T[] {
+ return [item, ...items.filter((existing) => existing !== item)].slice(
+ 0,
+ maxLength,
+ );
+}
+
+function codec(schema: S, defaultValue: z.output) {
+ return {
+ decode: (raw: string | null): z.output => {
+ if (raw === null) return defaultValue;
+ const parsed = schema.safeParse(rawToJson(raw));
+ return parsed.success ? parsed.data : defaultValue;
+ },
+ encode: (value: z.output) => JSON.stringify(value),
+ };
+}
+
+function rawToJson(raw: string): unknown {
+ try {
+ return JSON.parse(raw);
+ } catch {
+ // legacy values were stored as plain strings
+ return raw;
+ }
+}
+
+function storageOf(kind: StorageKind): Storage {
+ return kind === "local" ? window.localStorage : window.sessionStorage;
+}
+
+function readRaw(kind: StorageKind, key: string): string | null {
+ try {
+ return storageOf(kind).getItem(key);
+ } catch {
+ return null;
+ }
+}
+
+function readMapFromStorage(
+ definition: PersistedMapDefinition,
+): Record {
+ const result: Record = {};
+ try {
+ const storage = storageOf(definition.storage);
+ for (let i = 0; i < storage.length; i++) {
+ const key = storage.key(i);
+ if (!key?.startsWith(definition.keyPrefix)) continue;
+
+ result[key.slice(definition.keyPrefix.length)] = definition.decode(
+ storage.getItem(key),
+ );
+ }
+ } catch {
+ // web storage may be unavailable
+ }
+ return result;
+}
+
+function listenersOf(definition: object): Set<() => void> {
+ let listeners = listenersByDefinition.get(definition);
+ if (!listeners) {
+ listeners = new Set();
+ listenersByDefinition.set(definition, listeners);
+ }
+ return listeners;
+}
+
+function notify(definition: object) {
+ for (const listener of listenersOf(definition)) {
+ listener();
+ }
+}
diff --git a/app/modules/tournament-map-list-generator/balanced-map-list.ts b/app/modules/tournament-map-list-generator/balanced-map-list.ts
index 63a6e5ed5..56fda2407 100644
--- a/app/modules/tournament-map-list-generator/balanced-map-list.ts
+++ b/app/modules/tournament-map-list-generator/balanced-map-list.ts
@@ -88,15 +88,20 @@ function generateWithInput(
source: "TIEBREAKER" as const,
}));
+ // tiebreaker/fallback lists at the last slot get their own key range so
+ // their indices don't collide with the picked indices of the main list
+ const usedStageKeyOffset = stageList === stages ? 0 : stages.length;
+
for (const [i, stage] of stageList.entries()) {
- if (!stageIsOk(stage, i)) continue;
+ const usedStageKey = i + usedStageKeyOffset;
+ if (!stageIsOk(stage, usedStageKey)) continue;
mapList.push(stage);
- usedStages.add(i);
+ usedStages.add(usedStageKey);
const continueSearch = backtrack();
if (!continueSearch) return false;
- usedStages.delete(i);
+ usedStages.delete(usedStageKey);
mapList.pop();
}
diff --git a/app/modules/tournament-map-list-generator/generation.test.ts b/app/modules/tournament-map-list-generator/generation.test.ts
index e7c98d0a7..5b60264f6 100644
--- a/app/modules/tournament-map-list-generator/generation.test.ts
+++ b/app/modules/tournament-map-list-generator/generation.test.ts
@@ -77,6 +77,7 @@ const generateMapsResult = ({
tiebreakerMaps = tiebreakerPicks,
modesIncluded = [...rankedModesShort],
followModeOrder = false,
+ recentlyPlayedMaps,
}: Partial = {}) => {
return generateBalancedMapList({
count,
@@ -85,6 +86,7 @@ const generateMapsResult = ({
tiebreakerMaps,
modesIncluded,
followModeOrder,
+ recentlyPlayedMaps,
});
};
@@ -865,3 +867,25 @@ describe("Recently played maps", () => {
expect(mapList.length).toBe(5);
});
});
+
+describe("Tiebreaker maps vs picked maps index collision", () => {
+ test("generates a full map list when team picks and tiebreakers share list indices", () => {
+ const result = generateMapsResult({
+ count: 3,
+ teams: [
+ { id: 1, maps: new MapPool([{ mode: "SZ", stageId: 4 }]) },
+ { id: 2, maps: new MapPool([{ mode: "SZ", stageId: 5 }]) },
+ ],
+ tiebreakerMaps: new MapPool([
+ { mode: "SZ", stageId: 6 },
+ { mode: "SZ", stageId: 7 },
+ ]),
+ modesIncluded: ["SZ"],
+ });
+
+ const mapList = unwrap(result);
+
+ expect(mapList.length).toBe(3);
+ expect(mapList[2].source).toBe("TIEBREAKER");
+ });
+});
diff --git a/app/utils/action-schemas.ts b/app/utils/action-schemas.ts
new file mode 100644
index 000000000..f5ae3a17e
--- /dev/null
+++ b/app/utils/action-schemas.ts
@@ -0,0 +1,25 @@
+import type { z } from "zod";
+
+/** `_action` literals of an action schema (union or single branch). */
+export type ActionsOf =
+ z.infer extends {
+ _action: infer TAction extends string;
+ }
+ ? TAction
+ : never;
+
+/** Non-`_action` fields of the schema branch matching the given action, in parsed types. */
+export type FieldsOf<
+ TSchema extends z.ZodTypeAny,
+ TAction extends string,
+> = Omit, { _action: TAction }>, "_action">;
+
+/** Serializes a parsed field value into its form data representation. */
+export function serializeFieldValue(value: unknown) {
+ if (typeof value === "string") return value;
+ if (typeof value === "number" || typeof value === "boolean") {
+ return String(value);
+ }
+
+ return JSON.stringify(value);
+}
diff --git a/app/utils/kysely.server.ts b/app/utils/kysely.server.ts
index b013824f5..4307a64d9 100644
--- a/app/utils/kysely.server.ts
+++ b/app/utils/kysely.server.ts
@@ -1,4 +1,5 @@
import {
+ type AliasedRawBuilder,
type ColumnType,
type Expression,
type ExpressionBuilder,
@@ -43,36 +44,84 @@ export function peakXpOverallSql() {
return sql`"SplatoonPlayer"."peakXp" ->> '$.overall'`;
}
+type CommonUserSelectOptions = {
+ alias?: string;
+ prefix?: string;
+ idAs?: string;
+};
+
+type UserTableAlias = O extends { alias: infer A extends string }
+ ? A
+ : "User";
+
+type PrefixedUserColumn = O extends {
+ prefix: infer P extends string;
+}
+ ? `${P}${Capitalize}`
+ : C;
+
+type UserIdColumn = O extends { idAs: infer I extends string }
+ ? I
+ : PrefixedUserColumn;
+
+type CommonUserSelectResult = readonly [
+ `${UserTableAlias}.id as ${UserIdColumn}`,
+ `${UserTableAlias}.username as ${PrefixedUserColumn}`,
+ `${UserTableAlias}.discordId as ${PrefixedUserColumn}`,
+ `${UserTableAlias}.discordAvatar as ${PrefixedUserColumn}`,
+ `${UserTableAlias}.customUrl as ${PrefixedUserColumn}`,
+ AliasedRawBuilder>,
+];
+
/**
* Select list for the fields shared by every user representation across the app. Includes
* `customAvatarUrl`, the full URL of the user's supporter custom avatar (resolved from
- * `User.customAvatarImgId`), or `null` when they have none. `"User"` must be in scope at the call
- * site (it always is, since the other fields reference `User.*`).
+ * `User.customAvatarImgId`), or `null` when they have none. By default reads from `"User"` which
+ * must be in scope at the call site; pass `alias` when the table is joined under another name
+ * (`alias: "LinkedUser"`), `prefix` to prefix every output column (`prefix: "sender"` →
+ * `senderId`, `senderUsername`, ...) and `idAs` to rename only the id column (`idAs: "userId"`).
*/
-export function commonUserSelect(eb: ExpressionBuilder) {
+export function commonUserSelect(
+ eb: ExpressionBuilder,
+ options?: O,
+): CommonUserSelectResult {
+ const alias = options?.alias ?? "User";
+ const prefix = options?.prefix;
+
+ const outputName = (column: string) =>
+ prefix ? `${prefix}${column[0].toUpperCase()}${column.slice(1)}` : column;
+ const idName = options?.idAs ?? outputName("id");
+
return [
- "User.id",
- "User.username",
- "User.discordId",
- "User.discordAvatar",
- "User.customUrl",
- customAvatarUrl(eb).as("customAvatarUrl"),
- ] as const;
+ `${alias}.id as ${idName}`,
+ `${alias}.username as ${outputName("username")}`,
+ `${alias}.discordId as ${outputName("discordId")}`,
+ `${alias}.discordAvatar as ${outputName("discordAvatar")}`,
+ `${alias}.customUrl as ${outputName("customUrl")}`,
+ customAvatarUrl(eb, alias).as(outputName("customAvatarUrl")),
+ ] as unknown as CommonUserSelectResult;
}
/**
* SQL expression resolving to the full URL of a user's supporter custom avatar (from
* `User.customAvatarImgId`), or `null` when they have none. Alias it
- * (`.as("customAvatarUrl")`) when selecting it directly. Prefer {@link commonUserSelect} /
- * {@link commonUserJsonObject}; reach for this only when those don't fit (e.g. prefixed aliases or
- * a hand-built `jsonBuildObject`).
+ * (`.as("customAvatarUrl")`) when selecting it directly. Pass `alias` when the `User` table is
+ * joined under another name. Prefer {@link commonUserSelect} / {@link commonUserJsonObject};
+ * reach for this only when those don't fit (e.g. a hand-built `jsonBuildObject`).
*/
-export function customAvatarUrl(eb: ExpressionBuilder) {
+export function customAvatarUrl(
+ eb: ExpressionBuilder,
+ alias = "User",
+) {
return concatUserSubmittedImagePrefix(
eb
.selectFrom("UserSubmittedImage")
.select("UserSubmittedImage.url")
- .whereRef("UserSubmittedImage.id", "=", "User.customAvatarImgId")
+ .whereRef(
+ "UserSubmittedImage.id",
+ "=",
+ sql.ref(`${alias}.customAvatarImgId`),
+ )
.$asScalar(),
).$castTo();
}
@@ -113,6 +162,30 @@ export function commonUserJsonObject(eb: ExpressionBuilder) {
return jsonBuildObject(commonUserObjectFields(eb));
}
+type ExtractedExpressionTypes>> = {
+ [K in keyof E]: E[K] extends Expression ? T : never;
+};
+
+/**
+ * `json_group_array` aggregate building one object per member row from the {@link CommonUser}
+ * fields plus `extras`. `"User"` must be in scope at the call site. Alias it (`.as("members")`)
+ * when selecting.
+ */
+export function commonUserMembersAgg<
+ E extends Record>,
+>(eb: ExpressionBuilder, extras: E) {
+ return eb.fn
+ .agg("json_group_array", [
+ jsonBuildObject({
+ ...commonUserObjectFields(
+ eb as unknown as ExpressionBuilder,
+ ),
+ ...extras,
+ }),
+ ])
+ .$castTo>>();
+}
+
const USER_SUBMITTED_IMAGE_ROOT =
(process.env.NODE_ENV === "development" && !Config.prodMode) ||
IS_E2E_TEST_RUN ||
@@ -201,6 +274,61 @@ export function tournamentTeamCount(
.where("TournamentTeam.isPlaceholder", "=", 0);
}
+/**
+ * Grouped subquery picking each user's (`by: "userId"`) or team's (`by: "identifier"`) latest
+ * Skill row of a season: `latestId` plus that row's `ordinal`, `matchesCount` and the `by`
+ * column. Wrap it with `.selectFrom(latestSkillPerSeason(...).as("Latest"))`; extra `.where`s
+ * compose before aliasing.
+ */
+export function latestSkillPerSeason({
+ season,
+ by,
+}: {
+ season: number;
+ by: By;
+}) {
+ // The latest row per user/team is picked via SQLite's bare column rule: with a `max()`
+ // aggregate the other selected columns come from the row that produced the max.
+ // A self-join against a `max(id)` subquery is avoided because it lets the planner
+ // pick a nested-loop plan when it misjudges the season's row count (e.g. a freshly
+ // started season whose stats are dwarfed by older seasons), which made this query
+ // take ~12s. This form is plan-stable regardless of stats: a single grouped scan of
+ // the `skill_season_user_id_leaderboard` / `skill_season_identifier_leaderboard`
+ // covering index, no temp b-tree per partition.
+ return db
+ .selectFrom("Skill")
+ .select(({ fn }) => [
+ fn.max("Skill.id").as("latestId"),
+ "Skill.ordinal" as const,
+ "Skill.matchesCount" as const,
+ `Skill.${by}` as `Skill.${By}`,
+ ])
+ .where("Skill.season", "=", season)
+ .where(`Skill.${by}`, "is not", null)
+ .groupBy(`Skill.${by}`);
+}
+
+/**
+ * Predicate for `Skill` rows of the user that represent a played set: either a SendouQ match or
+ * a ranked tournament the user has a result in. Filters out e.g. skills of tournament teams the
+ * user dropped from before results. `"Skill"` must be in scope at the call site.
+ */
+export function skillCountsAsSeasonSet(
+ eb: ExpressionBuilder,
+ userId: number,
+) {
+ return eb.or([
+ eb("Skill.groupMatchId", "is not", null),
+ eb.exists(
+ eb
+ .selectFrom("TournamentResult")
+ .select("TournamentResult.userId")
+ .whereRef("TournamentResult.tournamentId", "=", "Skill.tournamentId")
+ .where("TournamentResult.userId", "=", userId),
+ ),
+ ]);
+}
+
/** Concats the file name (a bit misleadingly called `url` in the DB schema) with the root URL, giving the full URL for the image */
export function concatUserSubmittedImagePrefix(
expr: Expression,
diff --git a/app/utils/string.test.ts b/app/utils/string.test.ts
index 3ef5f9ee4..24cf60662 100644
--- a/app/utils/string.test.ts
+++ b/app/utils/string.test.ts
@@ -21,6 +21,11 @@ describe("pathnameFromPotentialURL()", () => {
"FW4dKrY",
);
});
+
+ test("Resolves a scheme-less URL paste to the path", () => {
+ // otherwise the generated discordUrl becomes https://discord.gg/discord.gg/FW4dKrY
+ expect(pathnameFromPotentialURL("discord.gg/FW4dKrY")).toBe("FW4dKrY");
+ });
});
describe("truncateBySentence()", () => {
@@ -53,6 +58,17 @@ describe("truncateBySentence()", () => {
const text = "First line\nSecond line\nThird line";
expect(truncateBySentence(text, 20)).toBe("First line");
});
+
+ test("Does not treat a period inside a time like 18.00 as a sentence end", () => {
+ const text =
+ "Doors at 18.00, we will be playing five rounds of swiss followed by a top cut.";
+ expect(truncateBySentence(text, 40)).not.toBe("Doors at 18.");
+ });
+
+ test("Does not return a tiny fraction of the budget when a long sentence follows a short one", () => {
+ const text = `Hi. ${"x".repeat(400)}. Everyone is welcome.`;
+ expect(truncateBySentence(text, 300)).not.toBe("Hi.");
+ });
});
describe("removeMarkdown()", () => {
@@ -71,6 +87,11 @@ describe("removeMarkdown()", () => {
expect(removeMarkdown("café & tea")).toBe("café & tea");
});
+ test("Does not throw on an out of range numeric entity", () => {
+ // e.g. an organizer writing a hex color code in the description
+ expect(() => removeMarkdown("background: � here")).not.toThrow();
+ });
+
test("Leaves unknown named entities untouched", () => {
expect(removeMarkdown("AT&T &fakeentity; rules")).toBe(
"AT&T &fakeentity; rules",
diff --git a/app/utils/strings.ts b/app/utils/strings.ts
index 39fbbddb4..6632ae8b5 100644
--- a/app/utils/strings.ts
+++ b/app/utils/strings.ts
@@ -50,19 +50,38 @@ export function gearTypeToInitial(gearType: GearType) {
}
export function pathnameFromPotentialURL(maybeUrl: string) {
+ const parsed = safeParseUrl(maybeUrl);
+ if (parsed) return stripEdgeSlashes(parsed.pathname);
+
+ // handle a URL pasted without a protocol, e.g. "discord.gg/FW4dKrY"
+ const parsedWithProtocol = safeParseUrl(`https://${maybeUrl}`);
+ const pathname = parsedWithProtocol
+ ? stripEdgeSlashes(parsedWithProtocol.pathname)
+ : "";
+
+ return pathname || maybeUrl;
+}
+
+function safeParseUrl(value: string) {
try {
- return new URL(maybeUrl).pathname.replace(/^\/+|\/+$/g, "");
+ return new URL(value);
} catch {
- return maybeUrl;
+ return null;
}
}
+function stripEdgeSlashes(pathname: string) {
+ return pathname.replace(/^\/+|\/+$/g, "");
+}
+
export function truncateBySentence(value: string, max: number) {
if (value.length <= max) {
return value;
}
- const sentences = value.match(/[^.!?\n]+[.!?\n]*/g) || [];
+ // a sentence only ends at a terminator followed by whitespace, so that
+ // e.g. "18.00" does not split in the middle
+ const sentences = value.match(/[\s\S]+?(?:[.!?](?=\s|$)|\n|$)/g) || [];
let result = "";
for (const sentence of sentences) {
@@ -72,7 +91,13 @@ export function truncateBySentence(value: string, max: number) {
result += sentence;
}
- return result.length > 0 ? result.trim() : value.slice(0, max).trim();
+ // when cutting at a sentence boundary would leave most of the budget
+ // unused, a mid-sentence cut that fills it is more informative
+ if (result.length < max / 2) {
+ return value.slice(0, max).trim();
+ }
+
+ return result.trim();
}
// based on https://github.com/zuchka/remove-markdown
@@ -101,9 +126,9 @@ export function removeMarkdown(value: string) {
const codePoint = code.startsWith("x")
? Number.parseInt(code.slice(1), 16)
: Number.parseInt(code, 10);
- return Number.isFinite(codePoint)
- ? String.fromCodePoint(codePoint)
- : "";
+ const isValidCodePoint =
+ Number.isFinite(codePoint) && codePoint >= 0 && codePoint <= 0x10ffff;
+ return isValidCodePoint ? String.fromCodePoint(codePoint) : "";
})
// Remove setext-style headers
.replace(/^[=-]{2,}\s*$/g, "")
diff --git a/app/utils/users.test.ts b/app/utils/users.test.ts
index d46a6b7c1..4763bca8c 100644
--- a/app/utils/users.test.ts
+++ b/app/utils/users.test.ts
@@ -43,6 +43,30 @@ describe("queryToUserIdentifier()", () => {
id: 42,
});
});
+
+ test("gets custom url from url with trailing slash", () => {
+ expect(queryToUserIdentifier("https://sendou.ink/u/sendou/")).toEqual({
+ customUrl: "sendou",
+ });
+ });
+
+ test("gets custom url from profile sub-page url", () => {
+ expect(queryToUserIdentifier("https://sendou.ink/u/sendou/builds")).toEqual(
+ {
+ customUrl: "sendou",
+ },
+ );
+ });
+
+ test("gets discord id from url with query string", () => {
+ expect(
+ queryToUserIdentifier(
+ "https://sendou.ink/u/79237403620945920?utm_source=discord",
+ ),
+ ).toEqual({
+ discordId: "79237403620945920",
+ });
+ });
});
describe("userDiscordIdIsAged()", () => {
diff --git a/app/utils/users.ts b/app/utils/users.ts
index c7fa6ce38..373f2a90a 100644
--- a/app/utils/users.ts
+++ b/app/utils/users.ts
@@ -1,8 +1,8 @@
import { logger } from "./logger";
import { isCustomUrl } from "./urls";
-const longUrlRegExp = /(https:\/\/)?sendou.ink\/u\/(.+)/;
-const shortUrlRegExp = /(https:\/\/)?snd.ink\/(.+)/;
+const longUrlRegExp = /(https:\/\/)?sendou\.ink\/u\/([^/?#]+)/;
+const shortUrlRegExp = /(https:\/\/)?snd\.ink\/([^/?#]+)/;
const DISCORD_ID_MIN_LENGTH = 17;
export function queryToUserIdentifier(
query: string,
diff --git a/biome-plugins/no-raw-action-forms.grit b/biome-plugins/no-raw-action-forms.grit
new file mode 100644
index 000000000..f30b03120
--- /dev/null
+++ b/biome-plugins/no-raw-action-forms.grit
@@ -0,0 +1,25 @@
+language js
+
+// Fixed-field mutations (an `_action` plus hidden inputs) go through
+// `` (app/components/ActionButton.tsx). Real multi-input forms
+// keep their own form but pass `schema` alongside `_action` to `SubmitButton`
+// so the action literal is type checked against the route's zod action schema.
+or {
+ JsxAttribute(name=`_action`) as $attr where {
+ $attr <: not within or {
+ JsxOpeningElement(attributes=contains JsxAttribute(name=`schema`)),
+ JsxSelfClosingElement(attributes=contains JsxAttribute(name=`schema`))
+ } ,
+ register_diagnostic(span=$attr, message="Untyped `_action`. For a fixed-field mutation use ``; for a submit button of a real multi-input form pass `schema={...}` alongside `_action` so the literal is type checked against the route's schema.", severity="error")
+ },
+ `name="_action"` as $attr where {
+ register_diagnostic(span=$attr, message="Do not submit `_action` via a hidden input or button name. Use ``, or a `SubmitButton` with `schema` and `_action` inside a real multi-input form. If neither fits, suppress with `// biome-ignore lint/plugin: `.", severity="error")
+ },
+ `$fetcher.submit($payload, $opts)` as $call where {
+ $payload <: contains `_action: $_`,
+ register_diagnostic(span=$call, message="Do not submit `_action` payloads with a raw fetcher.submit. Use the `useActionSubmit` hook so the action and fields are type checked against the route's schema. Suppress with `// biome-ignore lint/plugin: ` if this cannot go through the hook.", severity="error")
+ },
+ `$formData.append("_action", $value)` as $append where {
+ register_diagnostic(span=$append, message="Do not build `_action` FormData by hand. Use the `useActionSubmit` hook so the action and fields are type checked against the route's schema. Suppress with `// biome-ignore lint/plugin: ` if this payload includes files.", severity="error")
+ }
+}
diff --git a/biome.json b/biome.json
index 97b78e1f4..4eaa48c2a 100644
--- a/biome.json
+++ b/biome.json
@@ -77,6 +77,10 @@
"includes": ["app/**", "!app/modules/search-params/**"],
"plugins": ["./biome-plugins/no-raw-search-params.grit"]
},
+ {
+ "includes": ["app/**", "!app/hooks/useActionSubmit.ts"],
+ "plugins": ["./biome-plugins/no-raw-action-forms.grit"]
+ },
{
"includes": ["**/*.test.ts", "**/*.test.tsx"],
"plugins": ["./biome-plugins/no-raw-db-writes-in-tests.grit"]
diff --git a/content/articles/sws26-recap-westernqualifier2.md b/content/articles/sws26-recap-westernqualifier2.md
new file mode 100644
index 000000000..565451f12
--- /dev/null
+++ b/content/articles/sws26-recap-westernqualifier2.md
@@ -0,0 +1,101 @@
+---
+title: "SWS26 Recap: Western Qualifier #2"
+date: 2026-08-05
+author:
+ - name: YELLOW
+ link: https://sendou.ink/u/great-hero-yellow
+---
+
+#### *Three seats remain on the West’s plane to the global stage. Who will earn the right to join them?*
+
+
+
+On Saturday, July 25, 2026, the second and final Western qualifier in Inkling Performance Labs (IPL)’s Splat World Series 2026 events ran, with a total of 11 full teams competing for one of three last spots on the West’s roster for the main event in August. Streams were held on both IPL’s YouTube and Twitch channels.
+
+Like its predecessor, the Western Qualifier \#2 was a double-elimination Splat Zones-only event with a strike/select system for maps, offering a layer of strategy to counterpicking during the nearly four hours of competitive Splatoon action.
+
+This time, Dark and Zach commentated throughout the entire event, with Ely operating the spectator camera.
+
+### **Winner’s Rounds 1 and 2**
+
+The first match, a Best of Three, was between Takedown, the recent Swim or Sink 234 winners, and OwO, a pickup including a few players from BlankZ. Takedown, living up to their name, took down OwO in a fairly dominant fashion, winning 95–69 at Undertow Spillway, and getting a knockout victory at Shipshape Cargo Co.
+
+Winner’s Round 2—the quarterfinals—saw the return of two teams from last week, Poltergeist and NOnexistenceN, and changed from a Best of Three to a Best of Five.
+
+Across a set that went all the way to a game five, Poltergeist knocked out at Brinewater Springs and Robo ROM-en to start. NOnexistenceN tied the set by winning the next two games: a knockout at Mahi-Mahi Resort and 94–89 at Um’ami Ruins. At Barnacle & Dime, Poltergeist went the distance to stop NOnexistenceN’s reverse sweep and advanced to their qualification match.
+
+## **Winner’s Semifinals 1: Aeternus vs. Ascension (3–2)**
+
+The first qualification match was between Aeternus and Ascension. Both were coming out of the quarterfinals after a 3–1 victory; Aeternus over Takedown, and Ascension over Thriller Bark.
+
+Aeternus started by banning Urchin Underpass and Flounder Heights. Ascension banned Manta Maria and Bluefin Depot; the random map selection was Marlin Airport.
+
+After two delayed wipeouts in a row, Ascension found themselves on their heels as Aeternus surged past their lead, all the way to 2 ticks remaining. Ascension inched their score closer to their opponent’s, but in the final minute, were down three players and unable to mount a defense in time to stop Aeternus from knocking out.
+
+Aeternus’s map strikes were Humpback Pump Track and Undertow Spillway. Ascension opted to go to MakoMart for their runback, and everyone was taken by surprise to see a Custom Goo Tuber on the side of Aeternus.
+
+
+
+*As the match opens, Jay (in-game name: † weapon\!) is seen bringing along a Custom Goo Tuber, a weapon that the commentators weren’t sure if it had ever been seen in high level tournaments.*
+
+Jay’s Custom Goo Tuber didn’t seem like the best play for Aeternus, as they were the first player splatted in the game, leading to two delayed wipeouts in the opening minute. In the latter half of the game, Aeternus recouped enough to take the lead until they found themselves down three players, where Ascension secured control of the zone and knocked out, tying the set 1–1.
+
+For game three, Ascension struck Sturgeon Shipyard and Scorch Gorge. Hagglefish Market was Aeternus’s answer, and it was exactly what they needed. In the first minute, Aeternus wiped out Ascension, then locked Ascension out of the zone, ending the match in a win with 3:40 left on the clock.
+
+Aeternus’s next decision was to strike Eeltail Alley and Inkblot Art Academy. Ascension returned with a Brinewater Springs selection. Early aggression got Aeternus the zone first, but they weren’t able to defend it, losing the lead before one minute had passed. Ascension made their way to 10 ticks remaining before the zone traded hands; in overtime, their lead held out, giving them the 90–84 win, once more tying the set (2–2).
+
+Game five meant after this match, the first of three final slots on the West’s team for Splat World Series would be filled. Ascension banned Mahi-Mahi Resort and Crableg Capital. Aeternus selected Barnacle & Dime as the map.
+
+Aeternus took points by the handful; long holds of the zone gave them an early lead that Ascension struggled to catch up to. It felt like Aeternus had measured control of the game the entire time; they were the victors of the game after a knockout at 1:41, sending Ascension to the Loser’s Bracket for one final shot at a ticket to the Playoffs.
+
+## **Winner’s Semifinals 2: Content Cat vs. Poltergeist (3–1)**
+
+On the other side of the Winner’s Bracket, Content Cat and Poltergeist were ready to fight over the second to last roster slot. The first map strikes were Flounder Heights, Crableg Capital (Content Cat), Wahoo World, and Manta Maria (Poltergeist).
+
+Game one took place at Urchin Underpass. Content Cat took the zone first and followed it up with taking Poltergeist down by three players, not just once, but twice within the span of 30 seconds. While locking Poltergeist out, Content Cat then had most of their players splatted. Despite the setback, Content Cat was able to quickly return and defend the zone, leading to a 100-to-0 knockout.
+
+Content Cat’s next map strikes were to Eeltail Alley and Museum d’Alfonsino. The first few minutes at Um’ami Ruins were messy with zone swaps and lead changes. With a minute and a half to go, Content Cat was one point behind Poltergeist with no penalty points and the zone neutralized. After specials fired off, Content Cat was left standing to take the lead. When the clock reached zero, Content Cat was the victor, 91–77.
+
+
+
+*Poltergeist’s Miner takes care of Content Cat’s Chronos and Hawaiian; with Content Cat down three players, Poltergeist was at least able to avoid losing by knockout.*
+
+Brinewater Springs was the next stage after Content Cat struck Inkblot Art Academy and Marlin Airport. Content Cat continuously pushed at Poltergeist’s elbow, pressuring them back wherever possible. Poltergeist’s Booyah Bomb and Triple Inkstrikes gave them a way to cap the zone from a safe distance. The scores were quite close throughout the game, but after overtime, it was Poltergeist with the 83–81 win.
+
+The last game was at Hagglefish Market, after Poltergeist banned MakoMart and Hammerhead Bridge. Every time Poltergeist took the zone, it was back in Content Cat’s hands before long, and they held it for longer each time. With over a minute and a half to spare, Content Cat took the knockout victory, securing the \#7 spot on the West’s Playoffs roster in a few weeks.
+
+### **Loser’s Quarterfinals: Poltergeist vs. Takedown (2–3)**
+
+Poltergeist returned to the stream to face off against another Tri-Stringer team in Takedown. The set went all the way to game five to determine who would advance to Loser’s Semifinals for the last chance to qualify for the Splat World Series finale.
+
+Takedown won game one at Flounder Heights. Poltergeist tied the set after knocking out at Barnacle & Dime, then followed with another knockout victory at Hagglefish Market. Takedown kept themselves alive in the set with a close 84–83 win in overtime at Urchin Underpass, leading to one last game at Mahi-Mahi Resort, where Takedown took the last victory, 83–68, in an upset from seed \#8 over seed \#3.
+
+## **Loser’s Semifinals: Ascension vs. Takedown (3–1)**
+
+The final chance to join the West at the Splat World Series Playoffs had arrived. Ascension had just defeated NOnexistenceN 3–1 on the other side of the Loser’s Quarterfinals. Takedown had upset both seed \#4 Thriller Bark and seed \#3 Poltergeist to get this far—would they get one last upset over seed \#5?
+
+Ascension’s map strikes were Flounder Heights and Manta Maria. Takedown’s strikes were Museum d’Alfonsino and Crableg Capital. The random selection for game one was Mahi-Mahi Resort.
+
+Takedown struggled to get down from their plat for the first minute and a half of the game; once they were able to, they took the zone from Ascension, stopping them at 14 and wiping them out. Ascension rebounded very quickly, and was able to secure game one as a knockout victory.
+
+The next game was at MakoMart, selected by Takedown after Ascension struck Urchin Underpass and Humpback Pump Track. This one saw more back-and-forth between the teams. Halfway through, Ascension was able to get ahead of Takedown and take the lead to 11\. As the final seconds neared, Ascension stopped Takedown just shy of the lead, resulting in another Ascension win, 89–83.
+
+Sturgeon Shipyard and Wahoo World were Ascension’s map strikes; Takedown selected Hagglefish Market. The first chunk of game three was in Takedown’s favor, able to wipe out Ascension twice. Around the 2-minute mark, Ascension took the lead, but lost it one minute later, and a handful of seconds afterward, Takedown had the win by knockout.
+
+For game four, Takedown struck Brinewater Springs and Eeltail Alley. Ascension selected Um’ami Ruins. After one minute, Ascension claimed the zone from Takedown, stopping them at 47, and from there it was a downhill ride for them. Ascension got the knockout two and a half minutes into the game, rounding out the West’s SWS26 Playoffs roster\!
+
+
+
+*The Winner’s Bracket for the Western Qualifier \#2. Since the top three teams earned their prize, the event only went up to the semifinals in both Winner’s and Loser’s brackets.*
+
+With the Western Qualifiers coming to a close, the final three teams to ride to the Splat World Series 2026 Playoffs have been decided: Aeternus, Content Cat, and Ascension. They will join Rip pig 9, FTWin, and flower man, who were last week’s qualifier winners, and PxG and Milky Way, who were invited after the Global Gauntlet Finals wrapped up.
+
+Five teams from Japan—King of Ham, GaoGao Dragon, Vacuum World, CutieNK, Rush—are known at this time, announced at the same time as PxG and Milky Way’s invitation and on IPL’s social media. The other three JP teams will be announced in the days leading up to the SWS26 Playoffs.
+
+When will the Playoffs take place? Day one of the two-day Playoffs start on August 7th (8 PM PT / 11 PM ET **on Friday evening** for NA; 5 AM CET / 12 PM JT **on Saturday afternoon** for non-NA). Day two for NA starts on Saturday evening on August 8th; for everyone else, it will be early in the day on Sunday, August 9th.
+
+Don’t miss the chance to see who will join The Invincible Fleet Reimaru as the second team to crown themselves the best in the world. You will be able to see that event streamed live on IPL’s [Twitch](https://www.twitch.tv/IPLSplatoon) and [YouTube](https://www.youtube.com/@iplsplatoon) channels; AREA CUP will also have a dual stream in Japanese.
+
+Original Posting Date: August 5, 2026 at [Splatoon Stronghold](https://www.splatoonstronghold.com/news/sws26-recap-western-qualifier-2).
+
+Written and formatted for publication by [YELLOW](https://bsky.app/profile/great-hero-yellow.bsky.social).
diff --git a/e2e/api-public.spec.ts b/e2e/api-public.spec.ts
index 6b3b0e8e8..42b4c8e85 100644
--- a/e2e/api-public.spec.ts
+++ b/e2e/api-public.spec.ts
@@ -319,7 +319,7 @@ test.describe("Public API - Write endpoints", () => {
expect(response.status()).toBe(400);
const data = await response.json();
- expect(data.error).toBe("Unauthorized");
+ expect(data.error).toBe("Not an organizer");
});
});
diff --git a/e2e/global-setup.ts b/e2e/global-setup.ts
index c6f50b37a..9a34a112e 100644
--- a/e2e/global-setup.ts
+++ b/e2e/global-setup.ts
@@ -243,6 +243,10 @@ async function globalSetup(config: FullConfig) {
// no system messages to a shared skalop instance (see build env above)
SKALOP_SYSTEM_MESSAGE_URL: "",
SKALOP_TOKEN: "",
+ // creds from .env must not reach test servers (SyncLiveStreams would
+ // hit the real Twitch API and overwrite factory-seeded streams)
+ TWITCH_CLIENT_ID: "",
+ TWITCH_CLIENT_SECRET: "",
// tests assert webhook payloads by listening on the worker's webhook port
SQ_CANCEL_DISCORD_WEBHOOK_URL: `http://localhost:${e2eWebhookPort(i)}/sq-cancel`,
},
diff --git a/e2e/sendouq-match.spec.ts b/e2e/sendouq-match.spec.ts
index cae329cc0..d2cdb2867 100644
--- a/e2e/sendouq-match.spec.ts
+++ b/e2e/sendouq-match.spec.ts
@@ -220,6 +220,27 @@ test.describe("SendouQ match page", () => {
await expect(page).toHaveURL(SENDOUQ_LOOKING_PAGE);
});
+ test("Rejoin vote: changing a yes vote to no takes effect", async ({
+ page,
+ factories,
+ }) => {
+ const { matchId, alpha } = await createMatch(factories, {
+ isMatchmade: true,
+ isConcluded: true,
+ });
+
+ await impersonate(page, alpha[0].id);
+ const match = new SendouQMatchPage(page);
+ await match.goto(matchId);
+
+ await match.voteYes();
+ await expect(match.locators.votedYes).toHaveCount(1);
+
+ await match.voteNo();
+
+ await expect(match.locators.declinedText).toBeVisible();
+ });
+
test("Rejoin vote: cascade wipes yes on no, revote completes and rejoins", async ({
page,
factories,
diff --git a/e2e/trophies.spec.ts b/e2e/trophies.spec.ts
index 86551926a..98c76028a 100644
--- a/e2e/trophies.spec.ts
+++ b/e2e/trophies.spec.ts
@@ -1,6 +1,7 @@
import { addDays, subDays } from "date-fns";
import { NZAP_TEST_ID } from "~/db/seed/constants";
import { ADMIN_DISCORD_ID, ADMIN_ID } from "~/features/admin/admin-constants";
+import { TROPHY_APPROVALS_REQUIRED } from "~/features/trophies/trophies-constants";
import { decompressFromBase64 } from "~/utils/compression";
import { dateToDatabaseTimestamp } from "~/utils/dates";
import { TROPHIES_PAGE } from "~/utils/urls";
@@ -175,7 +176,9 @@ test.describe("Trophies", () => {
await pending.approve(approvedName);
await expect(
- pending.row(approvedName).getByText("1/2 approvals"),
+ pending
+ .row(approvedName)
+ .getByText(`1/${TROPHY_APPROVALS_REQUIRED} approvals`),
).toBeVisible();
await pending.decline(declinedName, "Does not meet the requirements");
diff --git a/locales/es-ES/analyzer.json b/locales/es-ES/analyzer.json
index 2f6920e20..6d330cc5d 100644
--- a/locales/es-ES/analyzer.json
+++ b/locales/es-ES/analyzer.json
@@ -1,6 +1,6 @@
{
"weaponSelect.label": "Arma a analizar",
- "rawParameters": "",
+ "rawParameters": "Parámetros brutos",
"attribute.weight": "Peso",
"attribute.weight.Fast": "Ligero",
"attribute.weight.Slow": "Pesado",
@@ -23,24 +23,23 @@
"stat.specialPoints": "Puntos para arma especial",
"stat.specialLost": "Especial perdido al ser reventado",
"stat.specialLostSplattedByRP": "Especial perdido al ser reventado por jugador con Castigo Póstumo",
- "stat.tenacitySecondsToSpecial_one": "",
- "stat.tenacitySecondsToSpecial_many": "",
- "stat.tenacitySecondsToSpecial_other": "",
- "stat.tenacitySecondsToSpecial.explanation": "",
- "stat.whiteInk": "Tiempo sin recuperar tinta después de uso",
+ "stat.tenacitySecondsToSpecial_one": "Tiempo para el especial con Ventaja ({{count}} menos)",
+ "stat.tenacitySecondsToSpecial_other": "Tiempo para el especial con Ventaja ({{count}} menos)",
+ "stat.tenacitySecondsToSpecial.explanation": "El tiempo que tarda Ventaja en llenar el medidor especial desde cero mientras tu equipo tiene menos jugadores activos que el rival, ej. {{teamPlayerCount}} contra {{opponentPlayerCount}}. Solo importa la diferencia entre los equipos, por lo que un duelo igualado como 3 contra 3 no carga el medidor en absoluto.",
+ "stat.whiteInk": "Tiempo sin recuperar tinta después de su uso",
"stat.subWeaponInkConsumptionPercentage": "Consumo del tanque de tinta",
- "stat.mainWeaponInkConsumptionPercentage.NORMAL": "",
- "stat.mainWeaponInkConsumptionPercentage.SWING": "",
- "stat.mainWeaponInkConsumptionPercentage.SLOSH": "",
- "stat.mainWeaponInkConsumptionPercentage.VERTICAL_SWING": "",
- "stat.mainWeaponInkConsumptionPercentage.HORIZONTAL_SWING": "",
- "stat.mainWeaponInkConsumptionPercentage.TAP_SHOT": "",
- "stat.mainWeaponInkConsumptionPercentage.FULL_CHARGE": "",
- "stat.mainWeaponInkConsumptionPercentage.SPLATLING_CHARGE": "",
- "stat.mainWeaponInkConsumptionPercentage.SHIELD_LAUNCH": "",
- "stat.mainWeaponInkConsumptionPercentage.DUALIE_ROLL": "",
- "stat.squidFormInkRecoverySeconds": "Tiempo de recuperar completo el tanque de tinta (forma calamar)",
- "stat.humanoidFormInkRecoverySeconds": "Tiempo de recuperar completo el tanque de tinta (forma humana)",
+ "stat.mainWeaponInkConsumptionPercentage.NORMAL": "Consumo por disparo",
+ "stat.mainWeaponInkConsumptionPercentage.SWING": "Consumo por ataque",
+ "stat.mainWeaponInkConsumptionPercentage.SLOSH": "Consumo por salpicadura",
+ "stat.mainWeaponInkConsumptionPercentage.VERTICAL_SWING": "Consumo por ataque cargado",
+ "stat.mainWeaponInkConsumptionPercentage.HORIZONTAL_SWING": "Consumo por ataque sin cargar",
+ "stat.mainWeaponInkConsumptionPercentage.TAP_SHOT": "Consumo por disparo rápido",
+ "stat.mainWeaponInkConsumptionPercentage.FULL_CHARGE": "Consumo por disparo cargado al máximo",
+ "stat.mainWeaponInkConsumptionPercentage.SPLATLING_CHARGE": "Consumo por carga completa",
+ "stat.mainWeaponInkConsumptionPercentage.SHIELD_LAUNCH": "Consumo por lanzamiento de parasol",
+ "stat.mainWeaponInkConsumptionPercentage.DUALIE_ROLL": "Consumo por voltereta",
+ "stat.squidFormInkRecoverySeconds": "Tiempo de recuperación completa del tanque de tinta (forma calamar)",
+ "stat.humanoidFormInkRecoverySeconds": "Tiempo de recuperación completa del tanque de tinta (forma humanoide)",
"stat.quickRespawnTime": "Tiempo de regeneración rápida",
"stat.quickRespawnTimeSplattedByRP": "Tiempo de regeneración rápida (al ser reventado por jugador con Castigo Póstumo)",
"stat.superJumpTimeGround": "Fotogramas vulnerables de supersalto",
@@ -109,7 +108,6 @@
"damage.header.baseDamage.short": "Base",
"damage.header.distance": "Distancia",
"damage.toSplat_one": "{{count}} golpe para liquidar",
- "damage.toSplat_many": "{{count}} golpes para liquidar",
"damage.toSplat_other": "{{count}} golpes para liquidar",
"damage.NORMAL_MIN": "Mínimo",
"damage.NORMAL_MAX": "Máximo",
@@ -169,8 +167,8 @@
"abilityPoints.short": "AP",
"abilityChunks": "Fragmentos de potenciador requeridos",
"torpedoExplanation": "No se puede lanzar más de un torpedo a la vez.",
- "trackingSubDefExplanation": "Tiempos de rastreo de Rastreador, Mina de Tinta y Dardo Resaltador son calculados contra un oponente con 0AP de Resistencia Secundaria.",
- "damageSubDefExplanation": "Daño debido al aspersor y barricada también puede ser reducido con Resistencia secundaria.",
+ "trackingSubDefExplanation": "Tiempos de rastreo de Rastreador, Bomba trampa y Tiralíneas son calculados contra un oponente con 0AP de Resistencia Secundaria.",
+ "damageSubDefExplanation": "Daño debido al aspersor y telón de tinta también puede ser reducido con Resistencia secundaria.",
"distanceInline": "Distancia: {{value}}",
"damageShort": "Daño",
"hitsToDestroyLong": "Disparos para destruir",
@@ -181,9 +179,8 @@
"dmgHtdExplanation": "DPD = Disparos para destruir",
"noDmgData": "No hay información sobre esta arma. Revisa más tarde.",
"perInkTankGrid.header_one": "{{weapon}} disparos después de ×{{count}} arma secundaria usada",
- "perInkTankGrid.header_many": "{{weapon}} disparos después de ×{{count}} armas secundarias usadas",
- "perInkTankGrid.header_other": "{{weapon}} disparos despues de ×{{count}} armas secundarias usadas",
- "bigBubblerExplanation": "Duración de {{weapon}} también es aumentada en conjunto con durabilidad. ",
+ "perInkTankGrid.header_other": "{{weapon}} disparos después de ×{{count}} armas secundarias usadas",
+ "bigBubblerExplanation": "La duración de {{weapon}} también aumenta junto con su durabilidad.",
"button.showChart": "Mostrar gráfico",
"button.showConsumptionGrid": "Mostrar tabla de consumo",
"damageReceiver.suffix.armor": "Armadura de {{weapon}}",
@@ -198,12 +195,11 @@
"comp.groupBy.special": "Arma especial",
"comp.selectWeapons": "Selecciona hasta {{max}} armas",
"comp.removeWeapon": "Eliminar arma",
- "comp.reorderWeapon": "",
+ "comp.reorderWeapon": "Arrastra para reordenar el arma",
"comp.pickWeapon": "Elige un arma",
"comp.showWeaponGrid": "Mostrar selector de armas",
"comp.hideWeaponGrid": "Ocultar selector de armas",
"comp.hits_one": "{{count}} golpe",
- "comp.hits_many": "{{count}} golpes",
"comp.hits_other": "{{count}} golpes",
"comp.enemyRes": "Resistencia a Tinta Rival del enemigo",
"comp.enemySubDef": "Resistencia Secundaria del enemigo",
@@ -226,5 +222,5 @@
"comp.specialCategory.TEAM_BUFF": "Mejora de equipo",
"comp.removeAll": "Eliminar todos",
"comp.addAll": "Añadir todos",
- "comp.singleWeaponCombos": ""
+ "comp.singleWeaponCombos": "Combos de un arma"
}
diff --git a/locales/es-ES/art.json b/locales/es-ES/art.json
index 77c412b62..30faf3801 100644
--- a/locales/es-ES/art.json
+++ b/locales/es-ES/art.json
@@ -1,6 +1,5 @@
{
"pendingApproval_one": "Tienes {{count}} imagen esperando aprobación.",
- "pendingApproval_many": "Tienes {{count}} imágenes esperando aprobación.",
"pendingApproval_other": "Tienes {{count}} imágenes esperando aprobación.",
"madeBy": "Creada por",
"radios.all": "Todos",
@@ -21,8 +20,8 @@
"forms.tags.addNew.placeholder": "Crear una nueva etiqueta",
"forms.tags.search.placeholder": "Buscar etiquetas...",
"forms.tags.placeholder": "Selecciona una etiqueta",
- "forms.tags.maxReached": "Limite máximo de etiquetas",
+ "forms.tags.maxReached": "Límite máximo de etiquetas",
"delete.title": "¿Seguro que quieres eliminar este arte?",
"unlink.title": "¿Seguro que quieres desvincular este arte de tu perfil? (solo {{username}} puede volver a añadirlo)",
- "noArtForTag": ""
+ "noArtForTag": "No se ha encontrado arte subido para #{{tag}}"
}
diff --git a/locales/es-ES/badges.json b/locales/es-ES/badges.json
index ffdb90d65..f406ead7a 100644
--- a/locales/es-ES/badges.json
+++ b/locales/es-ES/badges.json
@@ -3,7 +3,6 @@
"patreon+": "Supporter+ de sendou.ink en Patreon",
"xp": "Recibido por alcanzar {{xpText}}",
"tournament_one": "Recibido por ganar {{tournament}}",
- "tournament_many": "Recibido por ganar {{tournament}} (×{{count}})",
"tournament_other": "Recibido por ganar {{tournament}} (×{{count}})",
"forYourEvent": "¿Insignia para tu evento?",
"managedBy": "Administrado por <0>",
diff --git a/locales/es-ES/builds.json b/locales/es-ES/builds.json
index 7d53c0f09..ef543d4ad 100644
--- a/locales/es-ES/builds.json
+++ b/locales/es-ES/builds.json
@@ -7,13 +7,13 @@
"buildCard.info": "Info",
"buildCard.edit": "Editar",
"forms.title": "Título",
- "forms.modes": "Estilos",
+ "forms.modes": "Modos",
"forms.weapons": "Armas",
"forms.gear.HEAD": "Accesorios",
"forms.gear.CLOTHES": "Ropa",
"forms.gear.SHOES": "Calzado",
"forms.abilities": "Habilidades",
- "forms.private.info": "Builds privados son visibles solo para tí.",
+ "forms.private.info": "Las builds privadas solo son visibles para ti.",
"deleteConfirm": "¿Borrar build '{{title}}'?",
"stats.count.title": "Estadísticas de {{count}} builds para {{weapon}}",
"stats.ap.title": "Promedios de puntos de potenciadores",
diff --git a/locales/es-ES/calendar.json b/locales/es-ES/calendar.json
index 8dffe7044..39317dd05 100644
--- a/locales/es-ES/calendar.json
+++ b/locales/es-ES/calendar.json
@@ -10,10 +10,8 @@
"results": "Resultados",
"createMapList": "Crear lista de mapas",
"count.teams_one": "{{count}} equipo",
- "count.teams_many": "{{count}} equipos",
"count.teams_other": "{{count}} equipos",
"count.players_one": "{{count}} jugador",
- "count.players_many": "{{count}} jugadores",
"count.players_other": "{{count}} jugadores",
"forms.dates": "Fechas",
"forms.bracketUrl": "Enlace de cuadros",
@@ -22,8 +20,8 @@
"forms.tags.placeholder": "Elegir etiquetas",
"forms.badges": "Premios de insignia",
"forms.badges.placeholder": "Elige un premio de insignia",
- "forms.trophy": "",
- "forms.trophy.placeholder": "",
+ "forms.trophy": "Premio de trofeo",
+ "forms.trophy.placeholder": "Elige un trofeo como premio",
"forms.mapPool": "Grupo de mapas",
"forms.reportResultsHeader": "Anunciando resultados para {{eventName}}",
"forms.reportResultsInfo": "Tú decides cuántos resultados reportar. Puede ser solo el equipo ganador, los 3 primeros o lo que quieras.",
@@ -46,7 +44,7 @@
"tag.desc.S1": "El juego es Splatoon 1.",
"tag.desc.S2": "El juego es Splatoon 2.",
"tag.desc.SR": "Evento de Salmon Run",
- "tag.desc.CARDS": "Evento de Combate territorial",
+ "tag.desc.CARDS": "Evento de Lucha carterritorial",
"icalFeed": "iCal",
"filter.button": "Filtrar",
"filter.heading": "Filtrar eventos del calendario",
@@ -77,13 +75,13 @@
"forms.draft": "Borrador",
"forms.draftInfo": "Los torneos en borrador están ocultos y solo son visibles para los organizadores. El torneo debe abrirse (desactivando esta opción) antes de que pueda iniciarse cualquier cuadro.",
"forms.draftBracketStartBlocked": "El torneo está en modo borrador. Edita el torneo y desactiva la opción de borrador antes de iniciar el cuadro.",
- "events.title": "",
- "events.view.registered": "",
- "events.view.hosting": "",
- "events.view.scrims": "",
- "events.view.saved": "",
- "events.view.organization": "",
- "events.empty": "",
- "events.emptyAll": "",
- "events.findOnCalendar": ""
+ "events.title": "Mis eventos",
+ "events.view.registered": "Registrado",
+ "events.view.hosting": "Organizando",
+ "events.view.scrims": "Scrims",
+ "events.view.saved": "Guardados",
+ "events.view.organization": "Organización",
+ "events.empty": "No hay eventos en esta categoría",
+ "events.emptyAll": "No tienes próximos eventos.",
+ "events.findOnCalendar": "¡Busca un evento en el calendario para participar!"
}
diff --git a/locales/es-ES/common.json b/locales/es-ES/common.json
index 3034df699..9bd40a180 100644
--- a/locales/es-ES/common.json
+++ b/locales/es-ES/common.json
@@ -2,7 +2,7 @@
"pages.admin": "Administrador",
"pages.api": "API",
"pages.articles": "Artículos",
- "pages.trophies": "",
+ "pages.trophies": "Trofeos",
"pages.badges": "Insignias",
"pages.plus": "Servidor Plus",
"pages.contributors": "Colaboradores",
@@ -19,9 +19,9 @@
"pages.t": "Equipos",
"pages.support": "Apoyar",
"pages.vods": "Vídeos",
- "pages.popularBuilds": "",
- "pages.abilityStats": "",
- "pages.params": "",
+ "pages.popularBuilds": "Builds populares",
+ "pages.abilityStats": "Estadísticas de potenciadores",
+ "pages.params": "Parámetros",
"pages.xsearch": "Top Búsqueda",
"pages.leaderboards": "Clasificaciones",
"pages.links": "Enlaces",
@@ -32,10 +32,10 @@
"pages.settings": "Ajustes",
"pages.tier-list-maker": "Creador de Tier Lists",
"pages.luti": "LUTI",
- "pages.welcome": "",
+ "pages.welcome": "Bienvenida",
"header.profile": "Perfil",
"header.logout": "Cerrar sesión",
- "header.login.discord": "",
+ "header.login.discord": "Iniciar sesión con Discord",
"header.language": "Idioma",
"header.loggedInAs": "Conectado como {{userName}}",
"header.theme": "Tema",
@@ -50,7 +50,7 @@
"header.adder.art": "Arte",
"header.adder.vod": "VoD",
"header.adder.plusSuggestion": "Sugerencia Plus",
- "header.adder.trophy": "",
+ "header.adder.trophy": "Trofeo",
"notifications.title": "Notificaciones",
"notifications.empty": "Nada aún, vuelve más tarde",
"notifications.seeAll": "Ver todas",
@@ -72,12 +72,12 @@
"notifications.text.BADGE_ADDED": "Nueva insignia ({{badgeName}})",
"notifications.title.BADGE_MANAGER_ADDED": "Derechos de Gestor Concedidos",
"notifications.text.BADGE_MANAGER_ADDED": "Tienes derechos de gestor para la insignia {{badgeName}}",
- "notifications.title.TROPHY_SUBMITTED": "",
- "notifications.text.TROPHY_SUBMITTED": "",
- "notifications.title.TROPHY_SUBMISSION_ACCEPTED": "",
- "notifications.text.TROPHY_SUBMISSION_ACCEPTED": "",
- "notifications.title.TROPHY_SUBMISSION_DECLINED": "",
- "notifications.text.TROPHY_SUBMISSION_DECLINED": "",
+ "notifications.title.TROPHY_SUBMITTED": "Nuevo trofeo enviado",
+ "notifications.text.TROPHY_SUBMITTED": "{{submitterUsername}} ha enviado el trofeo {{trophyName}} para revisión",
+ "notifications.title.TROPHY_SUBMISSION_ACCEPTED": "Trofeo aceptado",
+ "notifications.text.TROPHY_SUBMISSION_ACCEPTED": "Tu trofeo {{trophyName}} ha sido aceptado",
+ "notifications.title.TROPHY_SUBMISSION_DECLINED": "Trofeo rechazado",
+ "notifications.text.TROPHY_SUBMISSION_DECLINED": "Tu trofeo {{trophyName}} ha sido rechazado",
"notifications.title.PLUS_VOTING_STARTED": "Votación Plus Iniciada",
"notifications.text.PLUS_VOTING_STARTED": "La votación del Servidor Plus de la temporada {{seasonNth}} ha comenzado",
"notifications.title.PLUS_SUGGESTION_ADDED": "Sugerencia Plus Añadida",
@@ -89,27 +89,27 @@
"notifications.title.SCRIM_NEW_REQUEST": "Nueva Solicitud de Scrim",
"notifications.text.SCRIM_NEW_REQUEST": "{{fromUsername}} ha solicitado un scrim",
"notifications.title.SCRIM_SCHEDULED": "Scrim Programado",
- "notifications.text.SCRIM_SCHEDULED": "",
+ "notifications.text.SCRIM_SCHEDULED": "Nueva scrim programada contra {{opponentTeamName}}",
"notifications.title.SCRIM_CANCELED": "Scrim Cancelado",
- "notifications.text.SCRIM_CANCELED": "",
+ "notifications.text.SCRIM_CANCELED": "La scrim contra {{opponentTeamName}} se ha cancelado",
"notifications.title.SCRIM_STARTING_SOON": "El scrim empieza pronto",
- "notifications.text.SCRIM_STARTING_SOON": "",
- "notifications.title.SCRIM_AUTO_DELETED": "",
- "notifications.text.SCRIM_AUTO_DELETED": "",
+ "notifications.text.SCRIM_STARTING_SOON": "Tu scrim contra {{opponentTeamName}} empieza pronto",
+ "notifications.title.SCRIM_AUTO_DELETED": "Publicación de scrim eliminada",
+ "notifications.text.SCRIM_AUTO_DELETED": "Tu publicación de scrim se ha eliminado automáticamente porque has reservado una scrim sobre esa hora (± 1 hora)",
"notifications.title.COMMISSIONS_CLOSED": "Comisiones Cerradas",
"notifications.text.COMMISSIONS_CLOSED": "Si tus comisiones siguen abiertas, por favor vuelve a activarlas",
- "notifications.title.FRIEND_REQUEST_RECEIVED": "",
- "notifications.text.FRIEND_REQUEST_RECEIVED": "",
- "notifications.title.TO_LIKE_RECEIVED": "",
- "notifications.text.TO_LIKE_RECEIVED": "",
- "notifications.title.TO_LIKE_ACCEPTED": "",
- "notifications.text.TO_LIKE_ACCEPTED": "",
+ "notifications.title.FRIEND_REQUEST_RECEIVED": "Solicitud de amistad",
+ "notifications.text.FRIEND_REQUEST_RECEIVED": "{{senderUsername}} te ha enviado una solicitud de amistad",
+ "notifications.title.TO_LIKE_RECEIVED": "Invitación de grupo recibida",
+ "notifications.text.TO_LIKE_RECEIVED": "{{likerUsername}} ha invitado a tu grupo en {{tournamentName}}",
+ "notifications.title.TO_LIKE_ACCEPTED": "Invitación de grupo aceptada",
+ "notifications.text.TO_LIKE_ACCEPTED": "{{accepterUsername}} ha aceptado tu invitación de grupo en {{tournamentName}}",
"auth.errors.aborted": "Inicio de Sesión Cancelado",
"auth.errors.failed": "Error al Iniciar Sesión",
"auth.errors.discordPermissions": "Para tu perfil de sendou.ink, el sitio necesita acceso al nombre, avatar y conexiones sociales de tu perfil de Discord.",
- "auth.errors.discordOverloaded": "",
- "auth.errors.unverifiedEmail": "",
- "auth.errors.browserPrivacy": "",
+ "auth.errors.discordOverloaded": "Discord está sobrecargado en este momento. Por favor, inténtalo de nuevo más tarde. Si eres Supporter, también puedes usar el comando /login en nuestro Discord para obtener un enlace de inicio de sesión directo:",
+ "auth.errors.unverifiedEmail": "Tu cuenta de Discord no tiene una dirección de correo verificada. Por favor, verifica tu correo en Discord y vuelve a intentarlo.",
+ "auth.errors.browserPrivacy": "Parece que tu navegador está bloqueando las cookies necesarias para iniciar sesión. Comprueba la configuración de privacidad del navegador, desactiva las extensiones que bloqueen cookies o prueba con otro navegador.",
"auth.errors.unknown": "Error desconocido, inténtalo de nuevo más tarde. Verifica también que tu cuenta de Discord tenga un correo electrónico verificado. Para obtener ayuda, contáctanos en el canal #helpdesk de nuestro Discord:",
"toasts.error": "Error",
"toasts.success": "Éxito",
@@ -118,10 +118,10 @@
"footer.discord.subtitle": "Ayuda y comentarios",
"footer.patreon.subtitle": "Apoyar",
"footer.thanks": "Gracias a los mecenas por su apoyo",
- "footer.version": "",
- "actions.share": "",
+ "footer.version": "Versión",
+ "actions.share": "Compartir",
"actions.save": "Guardar",
- "actions.unsave": "",
+ "actions.unsave": "No guardar",
"actions.saveChanges": "Guardar cambios",
"actions.submit": "Enviar",
"actions.edit": "Editar",
@@ -129,17 +129,17 @@
"actions.addNew": "Añadir nuevo",
"actions.remove": "Quitar",
"actions.delete": "Eliminar",
- "actions.leave": "",
+ "actions.leave": "Abandonar",
"actions.reset": "Restablecer",
"actions.loadMore": "Cargar más",
"actions.showMore": "Mostrar más",
"actions.showLess": "Mostrar menos",
"actions.copyToClipboard": "Copiar al portapapeles",
- "actions.copied": "",
+ "actions.copied": "¡Copiado!",
"actions.copyTimestampForDiscord": "Copiar timestamp para Discord",
"actions.create": "Crear",
"actions.close": "Cerrar",
- "actions.dismiss": "",
+ "actions.dismiss": "Descartar",
"actions.cancel": "Cancelar",
"actions.loading": "Cargando...",
"actions.clear": "Limpiar",
@@ -149,35 +149,35 @@
"actions.outlined": "Con borde",
"actions.noOutline": "Sin borde",
"actions.join": "Unirse",
- "imageExport.export": "",
- "imageExport.download": "",
- "imageExport.theme.light": "",
- "imageExport.theme.dark": "",
- "imageExport.theme.lightCustom": "",
- "imageExport.theme.darkCustom": "",
- "imageExport.qrCode": "",
- "imageExport.buildTitle": "",
- "imageExport.abilityPoints": "",
- "imageExport.abilityChunks": "",
- "host": "",
- "seed": "",
+ "imageExport.export": "Exportar imagen",
+ "imageExport.download": "Descargar",
+ "imageExport.theme.light": "Claro",
+ "imageExport.theme.dark": "Oscuro",
+ "imageExport.theme.lightCustom": "Claro (personalizado)",
+ "imageExport.theme.darkCustom": "Oscuro (personalizado)",
+ "imageExport.qrCode": "Código QR",
+ "imageExport.buildTitle": "Título de la build",
+ "imageExport.abilityPoints": "Puntos de potenciador",
+ "imageExport.abilityChunks": "Fragmentos",
+ "host": "Host",
+ "seed": "Seed {{number}}",
"actions.nevermind": "Olvídalo",
"actions.clickHere": "Haz clic aquí",
"actions.goBack": "Volver atrás",
"actions.enable": "Activar",
"actions.disable": "Desactivar",
"actions.accept": "Aceptar",
- "actions.decline": "",
- "actions.refuse": "",
+ "actions.decline": "Rechazar",
+ "actions.refuse": "Denegar",
"actions.confirm": "Confirmar",
"actions.next": "Siguiente",
"actions.previous": "Anterior",
"actions.back": "Atrás",
- "actions.viewAll": "",
+ "actions.viewAll": "Ver todo",
"actions.hide": "Ocultar",
- "actions.showAll": "",
+ "actions.showAll": "Mostrar todo",
"actions.settings": "Ajustes",
- "actions.reveal": "",
+ "actions.reveal": "Revelar",
"noResults": "Sin resultados",
"maps.createMapList": "Crear lista de mapas",
"maps.halfSz": "50% Pintazonas",
@@ -209,10 +209,10 @@
"forms.userSearch.noResults": "Ningún usuario que coincida con tu búsqueda",
"forms.tournamentSearch.placeholder": "Buscar torneos por nombre...",
"forms.tournamentSearch.noResults": "Ningún torneo que coincida con tu búsqueda",
- "forms.organizationSearch.placeholder": "",
- "forms.organizationSearch.noResults": "",
- "forms.teamSearch.placeholder": "",
- "forms.teamSearch.noResults": "",
+ "forms.organizationSearch.placeholder": "Buscar organizaciones por nombre...",
+ "forms.organizationSearch.noResults": "No se encontraron organizaciones que coincidan con tu búsqueda",
+ "forms.teamSearch.placeholder": "Buscar equipos por nombre...",
+ "forms.teamSearch.noResults": "No se encontraron equipos que coincidan con tu búsqueda",
"forms.weaponSearch.placeholder": "Selecciona un arma",
"forms.weaponSearch.search.placeholder": "Buscar arma...",
"forms.weaponSearch.quickSelect": "Recientes",
@@ -220,7 +220,7 @@
"forms.gearSearch.search.placeholder": "Buscar equipamiento...",
"forms.stageSearch.placeholder": "Selecciona un escenario",
"forms.stageSearch.search.placeholder": "Buscar escenario...",
- "select.any": "",
+ "select.any": "Cualquiera",
"tag.name.SPECIAL": "Reglas especiales",
"tag.name.ART": "Premios de arte",
"tag.name.MONEY": "Premios en metálico",
@@ -255,9 +255,9 @@
"plans.bgStyle.OVER": "Vista aérea",
"plans.bgStyle.MINI": "Minimapa",
"plans.adder.objective": "Objetivo",
- "plans.ranges": "",
- "plans.waterLevel.up": "",
- "plans.waterLevel.down": "",
+ "plans.ranges": "Rangos",
+ "plans.waterLevel.up": "Marea alta",
+ "plans.waterLevel.down": "Marea baja",
"articles.by": "por {{author}}",
"theme.light": "Claro",
"theme.dark": "Oscuro",
@@ -265,10 +265,10 @@
"websiteSubtitle": "Centro Competitivo de Splatoon",
"upload.imageToUpload": "Imagen a subir",
"support.intro.first": "¡Hola! Soy Sendou y sendou.ink es mi proyecto para proporcionar herramientas y recursos a la comunidad de Splatoon. El objetivo es ayudar a todos a mejorar y disfrutar de Splatoon, ya sean principiantes o veteranos.",
- "support.intro.second": "Si te gusta lo que hago, esta página detalla cómo puedes apoyar mi trabajo y obtener ventajas. Tu apoyo me ayuda a pagar el alojamiento y me permite dedicar tiempo a mejorar continuamente el proyecto.",
+ "support.intro.second": "Si te gusta lo que hago, esta página detalla cómo puedes apoyar mi trabajo y obtener ventajas. Tu apoyo me ayuda a cubrir el alojamiento y dedicar más tiempo a mejorar el proyecto.",
"support.action": "Apoyar en Patreon",
"support.footer": "Después de convertirte en mecenas, debes conectar <2>tu Discord en Patreon.com. Las ventajas se activarán en el plazo de una hora. Si tienes alguna duda, contacta con Sendou.",
- "support.perk.supportMyWork": "Apoyar mi trabajo",
+ "support.perk.supportMyWork": "Apóyame",
"support.perk.adFree": "Navegación sin anuncios",
"support.perk.nameInFooter": "Nombre en el pie de página",
"support.perk.discordColorRole": "Rol de color en Discord",
@@ -278,12 +278,12 @@
"support.perk.seePlusPercentage": "Ver porcentaje de votación de Plus",
"support.perk.seePlusPercentage.extra": "Normalmente, solo las sugerencias rechazadas ven su porcentaje de votación. Con esto, siempre podrás ver tu propio porcentaje.",
"support.perk.autoValidatePictures": "Validación automática de imágenes",
- "support.perk.autoValidatePictures.extra": "Ten en cuenta que esto no se aplica a imágenes que ya fueron enviadas anteriormente.",
+ "support.perk.autoValidatePictures.extra": "Las imágenes que subas (ej. foto de perfil o banner del equipo) se validan automáticamente. Normalmente necesitan la aprobación de un moderador. Ten en cuenta que esto no se aplica a imágenes que ya fueron enviadas anteriormente.",
"support.perk.userShortLink": "Enlace corto de perfil",
"support.perk.userShortLink.extra": "En lugar de sendou.ink/u/sendou también puedes usar snd.ink/sendou al enlazar a tu perfil de usuario.",
"support.perk.customizedColorsUser": "Colores personalizados (perfil)",
- "support.perk.customAvatar": "",
- "support.perk.customAvatar.extra": "",
+ "support.perk.customAvatar": "Avatar personalizado",
+ "support.perk.customAvatar.extra": "Sube un avatar personalizado para usarlo en lugar de tu avatar de Discord.",
"support.perk.favoriteBadges": "Fijar insignias favoritas",
"support.perk.favoriteBadges.extra": "Puedes elegir qué insignias aparecen en la página principal de tu perfil y en qué orden.",
"support.perk.customizedColorsTeam": "Colores personalizados (equipo)",
@@ -299,8 +299,8 @@
"support.perk.useBotToLogIn": "Iniciar sesión con el bot de Discord",
"support.perk.useBotToLogIn.extra": "Solicita un enlace de inicio de sesión al bot Lohi como alternativa a iniciar sesión desde la web.",
"support.perk.earlyAccess": "Acceso anticipado a nuevas funciones",
- "support.perk.seasonSummaryImage": "",
- "support.perk.seasonSummaryImage.extra": "",
+ "support.perk.seasonSummaryImage": "Exportar la imagen de resumen de cualquier temporada",
+ "support.perk.seasonSummaryImage.extra": "Exporta una imagen de resumen de cualquier temporada de SendouQ que hayas jugado. Todo el mundo puede exportar la imagen de la última temporada finalizada durante la pretemporada.",
"custom.colors.title": "Colores personalizados",
"custom.colors.bg": "Fondo",
"custom.colors.bg-darker": "Fondo más oscuro",
@@ -321,14 +321,14 @@
"xsearch.unlink.title": "¿Seguro que quieres desvincular? Esto eliminará las clasificaciones de tu perfil así como la insignia asociada (solo el staff de sendou.ink puede volver a vincularla).",
"xsearch.unlink.action.long": "Desvincular tu usuario",
"xsearch.unlink.action.short": "Desvincular",
- "xsearch.link.trigger": "",
- "xsearch.link.about.title": "",
- "xsearch.link.about.endPower": "",
- "xsearch.link.about.notPeak": "",
- "xsearch.link.about.wait": "",
- "xsearch.link.example": "",
- "xsearch.link.exampleRequest": "",
- "xsearch.link.noScreenshots": "",
+ "xsearch.link.trigger": "Cómo vincular tus resultados del combate X",
+ "xsearch.link.about.title": "Sobre el top 500:",
+ "xsearch.link.about.endPower": "solo cuenta el poder con el que terminaste, si no quedaste en el top 500 no estás en el sistema",
+ "xsearch.link.about.notPeak": "no tiene en cuenta tu máximo, solo el poder con el que terminaste",
+ "xsearch.link.about.wait": "si la temporada acaba de terminar tienes que esperar a que los poderes se suban a la web",
+ "xsearch.link.example": "Publica este mensaje reemplazando el enlace en nuestro Discord (<1>discord.gg/sendou), en el canal #helpdesk:",
+ "xsearch.link.exampleRequest": "Por favor, vinculad mis resultados del combate X:",
+ "xsearch.link.noScreenshots": "No se puede tener en cuenta la solicitud sin un enlace a la página de jugador. No hace falta adjuntar capturas a menos que se pidan.",
"build.private": "Privado",
"or": "O",
"yes": "Sí",
@@ -341,7 +341,7 @@
"leaderboard.updateInfo": "La clasificación se actualiza cada 30 minutos",
"leaderboard.qualification": "Clasificación para la Final de Temporada",
"leaderboard.qualification.info": "Cada jugador de la plantilla debe jugar 7 sets de SendouQ durante la temporada. Cada alineación única de 4 jugadores tiene sus propios puntos.",
- "chat.expired": "",
+ "chat.expired": "La sala ha caducado, ahora es de solo lectura",
"chat.connected": "Conectado",
"chat.connecting": "Conectando...",
"chat.disconnected": "Desconectado",
@@ -351,24 +351,24 @@
"chat.systemMsg.scoreConfirmed": "{{name}} ha confirmado el resultado. La partida está cerrada",
"chat.systemMsg.cancelReported": "{{name}} pidió cancelar la partida",
"chat.systemMsg.cancelConfirmed": "{{name}} confirmó cancelar la partida. La partida está cerrada",
- "chat.systemMsg.cancelRefused": "",
+ "chat.systemMsg.cancelRefused": "{{name}} ha rechazado cancelar la partida",
"chat.systemMsg.userLeft": "{{name}} abandonó el grupo",
- "chat.systemMsg.mapReplayed": "",
- "chat.systemMsg.mapPicked": "",
+ "chat.systemMsg.mapReplayed": "{{name}} ha repetido el escenario anterior",
+ "chat.systemMsg.mapPicked": "{{name}} ha elegido un escenario",
"chat.newMessages": "Nuevos mensajes",
- "chat.sidebar.title": "",
- "chat.sidebar.noActiveChats": "",
+ "chat.sidebar.title": "Chat",
+ "chat.sidebar.noActiveChats": "No hay chats activos",
"fc.title": "Clave de amigo",
"fc.whereToFind": "Encuentra tu clave de amigo en tu Nintendo Switch (2)",
"fc.onceSetStaffOnly": "Una vez guardada, solo un miembro del staff puede modificarla.",
- "fc.set": "",
- "fc.altingWarning": "",
- "fc.changeHelp": "",
+ "fc.set": "Añadir clave de amigo",
+ "fc.altingWarning": "Debes jugar siempre en la cuenta vinculada a esta clave de amigo. Jugar en otra cuenta se considera uso de multicuentas, lo que va contra las reglas.",
+ "fc.changeHelp": "Si necesitas cambiar tu clave de amigo, ponte en contacto con el equipo en nuestro canal de ayuda de Discord.",
"settings.UPDATE_DISABLE_BUILD_ABILITY_SORTING.label": "Builds: Desactivar orden automático de potenciadores",
"settings.UPDATE_DISABLE_BUILD_ABILITY_SORTING.bottomText": "Fuera de tu perfil, los potenciadores se agrupan. Activa esta opción para verlos siempre en el orden en que los creaste.",
- "settings.DISALLOW_SCRIM_PICKUPS_FROM_UNTRUSTED.label": "Scrims: No permitir invitaciones de usuarios no verificados",
+ "settings.DISALLOW_SCRIM_PICKUPS_FROM_UNTRUSTED.label": "Scrims: No permitir que usuarios que no sean amigos te añadan a pickups",
"settings.DISALLOW_SCRIM_PICKUPS_FROM_UNTRUSTED.bottomText": "Por defecto, cualquiera puede añadirte a un pickup. Activa esto para limitarlo a jugadores de confianza.",
- "settings.UPDATE_NO_SCREEN.label": "[Accesibilidad] Evitar Pantalla entintada",
+ "settings.UPDATE_NO_SCREEN.label": "[Accesibilidad] Evitar Pantintalla",
"settings.UPDATE_NO_SCREEN.bottomText": "Afecta a torneos, scrims y SendouQ.",
"settings.notifications.title": "Notificaciones push",
"settings.notifications.description": "Recibe notificaciones en tu dispositivo aunque no tengas sendou.ink abierto.",
@@ -376,39 +376,39 @@
"settings.notifications.browserNotSupported": "Tu navegador no es compatible con las notificaciones push.",
"settings.notifications.permissionDenied": "El permiso de notificaciones fue denegado. Actívalo en la configuración de tu navegador.",
"settings.clockFormat": "Formato de hora",
- "settings.theme": "",
- "settings.themeInfo": "",
- "settings.locales": "",
- "settings.preferences": "",
- "settings.customTheme.colors": "",
- "settings.customTheme.radius": "",
- "settings.customTheme.sizes": "",
- "settings.customTheme.borders": "",
- "settings.customTheme.baseHue": "",
- "settings.customTheme.baseChroma": "",
- "settings.customTheme.accentHue": "",
- "settings.customTheme.accentChroma": "",
- "settings.customTheme.chatHueToggle": "",
- "settings.customTheme.chatHue": "",
- "settings.customTheme.boxes": "",
- "settings.customTheme.fields": "",
- "settings.customTheme.selectors": "",
- "settings.customTheme.spacings": "",
- "settings.customTheme.borderWidth": "",
- "settings.customTheme.shareCode": "",
- "settings.customTheme.copy": "",
- "settings.customTheme.paste": "",
- "settings.customTheme.patreonText": "",
- "settings.customTheme.joinPatreon": "",
+ "settings.theme": "Tema",
+ "settings.themeInfo": "Esto también determina los colores de tu página de usuario para los demás",
+ "settings.locales": "Idioma",
+ "settings.preferences": "Preferencias",
+ "settings.customTheme.colors": "Colores",
+ "settings.customTheme.radius": "Radio",
+ "settings.customTheme.sizes": "Tamaños",
+ "settings.customTheme.borders": "Bordes",
+ "settings.customTheme.baseHue": "Tono base",
+ "settings.customTheme.baseChroma": "Croma base",
+ "settings.customTheme.accentHue": "Tono de contraste",
+ "settings.customTheme.accentChroma": "Croma de contraste",
+ "settings.customTheme.chatHueToggle": "Usar color de nombre personalizado en el chat",
+ "settings.customTheme.chatHue": "Color del nombre en el chat",
+ "settings.customTheme.boxes": "Cajas",
+ "settings.customTheme.fields": "Campos",
+ "settings.customTheme.selectors": "Selectores",
+ "settings.customTheme.spacings": "Espaciados",
+ "settings.customTheme.borderWidth": "Grosor del borde",
+ "settings.customTheme.shareCode": "Código para compartir",
+ "settings.customTheme.copy": "Copiar código del tema",
+ "settings.customTheme.paste": "Pegar código del tema",
+ "settings.customTheme.patreonText": "¡Hazte Supporter en Patreon para personalizar los temas!",
+ "settings.customTheme.joinPatreon": "Únete al Patreon",
"clockFormat.auto": "Automático (usar idioma por defecto)",
"clockFormat.24h": "24 horas",
"clockFormat.12h": "12 horas (AM/PM)",
"badges.selector.none": "Ninguna insignia seleccionada",
"badges.selector.select": "Seleccionar insignia a añadir",
"badges.selector.noneAvailable": "No hay insignias disponibles. Los miembros de la organización deben ser gestores de insignias para poder añadirlas.",
- "trophies.selector.none": "",
- "trophies.selector.select": "",
- "trophies.selector.noneAvailable": "",
+ "trophies.selector.none": "Ningún trofeo seleccionado",
+ "trophies.selector.select": "Selecciona un trofeo para añadir",
+ "trophies.selector.noneAvailable": "No hay trofeos disponibles.",
"api.title": "Acceso a la API",
"api.description": "Genera un token para acceder a la API de sendou.ink. Consulta la <1>documentación para ver ejemplos.",
"api.noAccess": "No tienes acceso a la API. El acceso se concede a seguidores (nivel Supporter o superior) y a admins, organizadores o streamers de organizaciones de torneos establecidas.",
@@ -421,19 +421,19 @@
"api.regenerate.button": "Regenerar token",
"api.regenerate.confirm": "Confirmar regeneración",
"api.generate": "Generar token",
- "search": "",
- "search.placeholder": "",
- "search.type.users": "",
- "search.type.teams": "",
- "search.type.organizations": "",
- "search.type.tournaments": "",
- "search.type.weapons": "",
- "search.noResults": "",
- "search.hint": "",
- "search.searching": "",
- "weaponArt.title": "",
+ "search": "Buscar",
+ "search.placeholder": "Buscar...",
+ "search.type.users": "Usuarios",
+ "search.type.teams": "Equipos",
+ "search.type.organizations": "Organizaciones",
+ "search.type.tournaments": "Torneos",
+ "search.type.weapons": "Armas",
+ "search.noResults": "No se encontraron resultados",
+ "search.hint": "Empieza a escribir para buscar",
+ "search.searching": "Buscando...",
+ "weaponArt.title": "Arte de la comunidad",
"tier.tentative": "Tier {{tierName}} provisional",
"tier.confirmed": "Tier {{tierName}} confirmado",
- "spoilerFree.showResults": "",
- "spoilerFree.hideResults": ""
+ "spoilerFree.showResults": "Mostrar resultados",
+ "spoilerFree.hideResults": "Ocultar resultados"
}
diff --git a/locales/es-ES/contributions.json b/locales/es-ES/contributions.json
index 8c1908be1..211d232bf 100644
--- a/locales/es-ES/contributions.json
+++ b/locales/es-ES/contributions.json
@@ -1,13 +1,13 @@
{
- "project": "Sendou.ink es un proyecto hecho por Sendou con ayuda de contribuidores:",
- "code": "Ver todos los contribuidores",
+ "project": "Sendou.ink es un proyecto hecho por Sendou con ayuda de colaboradores:",
+ "code": "Ver todos los colaboradores",
"lean": "Ayudó a descubrir partes internas de Splatoon y creó el bot Lanista",
"borzoic": "Creó insignias, íconos y el arte de la página principal",
"toripng": "Creó íconos",
"uberu": "Dibujó el pequeño emoji the Justino abrazando un corazón",
"yaga": "Proporcionó íconos de armas secundarias y especiales",
"centritide": "Cálculos de alcance de armas",
- "antariska": "Proporcionó las imagenes para el planeador",
+ "antariska": "Proporcionó las imágenes para el planeador",
"splatoon3ink": "Da información de resultados de Combate X",
"translation": "Traducción",
"sounds": "Efectos de sonido"
diff --git a/locales/es-ES/faq.json b/locales/es-ES/faq.json
index 44aeceb83..9a1773a5c 100644
--- a/locales/es-ES/faq.json
+++ b/locales/es-ES/faq.json
@@ -4,11 +4,11 @@
"q2": "¿Cómo puedo obtener un premio de insignia para mi evento?",
"a2": "Desde septiembre de 2024, las insignias pueden ser creadas por cualquier persona con las habilidades necesarias. Consulta el enlace al final de la página de insignias para más información.",
"q3": "¿Cómo puedo actualizar mi avatar o nombre de usuario?",
- "a3": "Si actualizas tu nombre de usuario o avatar en Discord, no cambian de inmediato en sendou.ink. Para que eso suceda tienes dos opciones:\n\n1) Si eres miembro del Discord de este sitio o del Plus Server, simplemente puedes esperar. Hay una rutina diaria que se encarga de la actualización.\n\n2) Alternativamente, si deseas actualizarlos de inmediato, puede cerrar la sesión y reiniciarla en sendou.ink.",
+ "a3": "Si actualizas tu nombre de usuario o avatar en Discord, no se actualizan de inmediato en sendou.ink. Para que eso ocurra, tienes dos opciones:\\n\\n1) Si eres miembro del Discord de este sitio o del Plus Server, simplemente puedes esperar. Hay una rutina diaria que se encarga de la actualización.\\n\\n2) Para que se actualicen de inmediato, puedes usar el comando /update-profile del bot de Discord Lohi.",
"q4": "Estoy suscrito en Patreon pero no he visto cambio en el sitio.",
- "a4": "Asegura que tu Discord esté conectado en Patreon.com. Después de hacerlo, puede tardar 2 horas para que el sitio se actualice. Si aún hay un problema, envía un mensaje a Sendou directamente por Discord para obtener ayuda.",
+ "a4": "Asegúrate de conectar tu cuenta de Discord en Patreon.com. Después de hacerlo, puede tardar hasta 2 horas en actualizarse en el sitio.",
"q5": "¿Hay un app de sendou.ink?",
- "a5": "No, pero sendou.ink se puede instalar como una 'aplicación web progresiva' (PWA) que obtiene muchos de los mismos beneficios, como pantalla completa, un ícono en la pantalla de inicio y un proceso separado. Busque en Google 'cómo instalar PWA en *su navegador*' para encontrar instrucciones.",
+ "a5": "Busca en Google 'cómo instalar PWA en tu navegador' para obtener instrucciones.",
"q6": "¿Cómo puedo agregar Twitch/Bluesky/YouTube a mi perfil?",
"a6": "Usamos tu perfil de Discord para eso. Conéctalos y verifícalos a través de Discord. Luego, cierra tu sesión y vuelve a iniciar tu sesión en sendou.ink para actualizar.",
"q7": "¿Cómo puedo agregar videos?",
diff --git a/locales/es-ES/forms.json b/locales/es-ES/forms.json
index f5b431c8a..f52471b67 100644
--- a/locales/es-ES/forms.json
+++ b/locales/es-ES/forms.json
@@ -2,42 +2,42 @@
"submit": "Finalizar",
"labels.name": "Nombre",
"labels.bio": "Biografía",
- "labels.logo": "",
- "labels.banner": "",
- "labels.bannerStage": "",
- "labels.bannerImage": "",
- "labels.shortBio": "",
- "labels.unverifiedXp": "",
- "labels.hideXp": "",
- "labels.hideDiv": "",
- "options.bannerType.COLOR": "",
- "options.bannerType.STAGE": "",
- "options.bannerType.URL": "",
- "options.xpDivision.WEST": "",
- "options.xpDivision.JPN": "",
- "bottomTexts.unverifiedXp": "",
- "bottomTexts.reportMatchId": "",
- "errors.unverifiedXpNotAboveVerified": "",
- "labels.link": "",
+ "labels.logo": "Logo",
+ "labels.banner": "Banner",
+ "labels.bannerStage": "Escenario del banner",
+ "labels.bannerImage": "Imagen del banner",
+ "labels.shortBio": "Biografía breve",
+ "labels.unverifiedXp": "Récord de energía no verificado",
+ "labels.hideXp": "Ocultar energía X",
+ "labels.hideDiv": "Ocultar división de LUTI",
+ "options.bannerType.COLOR": "Color",
+ "options.bannerType.STAGE": "Imagen de escenario",
+ "options.bannerType.URL": "Subir imagen",
+ "options.xpDivision.WEST": "Tentatek",
+ "options.xpDivision.JPN": "Takoroka",
+ "bottomTexts.unverifiedXp": "Reporta un récord de energía hasta 200 puntos superior a tu energía en combate X verificada. Requiere tener resultados del combate X vinculados para poder compararlo.",
+ "bottomTexts.reportMatchId": "Partida de SendouQ a la que se refiere este reporte (opcional).",
+ "errors.unverifiedXpNotAboveVerified": "El récord de energía debe ser superior a tu energía en combate X verificada, por un máximo de 200 puntos. Vincula tus resultados del combate X primero.",
+ "labels.link": "Enlace",
"labels.tag": "Etiqueta",
"labels.teamBsky": "Bluesky del equipo",
"labels.teamEditor": "Editor",
- "labels.teamMemberRole": "",
- "labels.teamMemberCustomRole": "",
- "labels.teamMemberRoleType": "",
+ "labels.teamMemberRole": "Rol",
+ "labels.teamMemberCustomRole": "Rol personalizado",
+ "labels.teamMemberRoleType": "Tipo de rol",
"labels.clockFormat": "Formato de hora",
"labels.disableBuildAbilitySorting": "Builds: Desactivar orden automático de potenciadores",
"labels.disallowScrimPickupsFromUntrusted": "No permitir invitaciones de usuarios no verificados",
"labels.noScreen": "[Accesibilidad] Evitar Pantintalla",
- "labels.spoilerFreeMode": "",
- "bottomTexts.imageModeration": "",
+ "labels.spoilerFreeMode": "Modo sin spoilers",
+ "bottomTexts.imageModeration": "A menos que seas Supporter, las imágenes nuevas subidas solo se muestran públicamente cuando las haya revisado un moderador.",
"bottomTexts.name": "Nota que si cambias el nombre de tu equipo, el nombre y la URL estarán libres para que otro equipo los tome",
"bottomTexts.tag": "Normalmente se usa antes del nombre en el juego para indicar pertenencia a un equipo (ej. [TAG] NombreJugador)",
"bottomTexts.disableBuildAbilitySorting": "Fuera de tu perfil, los potenciadores se agrupan. Activa esta opción para verlos siempre en el orden en que los creaste.",
- "bottomTexts.disallowScrimPickupsFromUntrusted": "Solo aplica si estás en el lobby como líder de grupo. Otros líderes de grupo aún pueden añadirte.",
+ "bottomTexts.disallowScrimPickupsFromUntrusted": "Si se activa, solo tus amigos podrán añadirte a un pickup de scrim.",
"bottomTexts.noScreen": "Afecta a torneos, scrims y SendouQ.",
- "bottomTexts.spoilerFreeMode": "",
- "bottomTexts.languageClockTimeNote": "",
+ "bottomTexts.spoilerFreeMode": "Oculta los resultados de torneos de la última semana",
+ "bottomTexts.languageClockTimeNote": "El formato del reloj y la hora usan la configuración de idioma del navegador",
"options.clockFormat.auto": "Automático",
"options.clockFormat.24h": "24 horas",
"options.clockFormat.12h": "12 horas",
@@ -53,35 +53,34 @@
"options.teamMemberRole.SUB": "Suplente",
"options.teamMemberRole.COACH": "Entrenador",
"options.teamMemberRole.CHEERLEADER": "Animador",
- "options.teamMemberRole.CUSTOM": "",
- "options.teamMemberRoleType.PLAYER": "",
- "options.teamMemberRoleType.OTHER": "",
+ "options.teamMemberRole.CUSTOM": "Personalizado...",
+ "options.teamMemberRoleType.PLAYER": "Jugador",
+ "options.teamMemberRoleType.OTHER": "Otro",
"errors.required": "Este campo es obligatorio",
"errors.minLength": "Debe tener al menos {{min}} caracteres",
"errors.maxLength": "Debe tener como máximo {{max}} caracteres",
- "errors.mustBeWholeNumber": "",
- "errors.matchNotFound": "",
+ "errors.mustBeWholeNumber": "Debe ser un número entero (sin decimales)",
+ "errors.matchNotFound": "No se ha encontrado ninguna partida de SendouQ con esta ID",
"errors.invalidUrl": "Debe ser una URL válida",
"errors.notAllowedCharacters": "Contiene caracteres no permitidos",
- "errors.imageTooLarge": "",
+ "errors.imageTooLarge": "La imagen es demasiado grande. Prueba con un archivo más pequeño.",
"errors.atLeastOneOption": "Debe seleccionarse al menos una opción",
"errors.duplicateName": "Ya existe un equipo con ese nombre",
- "errors.duplicateOrgName": "",
+ "errors.duplicateOrgName": "Ya hay una organización con este nombre",
"errors.noOnlySpecialCharacters": "El nombre no puede ser solo caracteres especiales",
- "errors.customRoleRequired": "",
+ "errors.customRoleRequired": "Introduce un nombre para el rol personalizado",
"labels.weaponPool": "Selección de armas",
"placeholders.weaponPoolFull": "Selección llena - elimina un arma para añadir más",
- "placeholders.vodStartTimestamp": "",
"labels.voiceChat": "Puede usar chat de voz",
"labels.languages": "Tus idiomas",
"options.voiceChat.yes": "Sí",
"options.voiceChat.no": "No",
"options.voiceChat.listenOnly": "Solo escuchar",
"labels.buildTitle": "Título",
- "labels.buildModes": "Estilos",
+ "labels.buildModes": "Modos",
"labels.buildPrivate": "Privado",
"labels.buildWeapons": "Armas",
- "bottomTexts.buildPrivate": "Builds privados son visibles solo para ti.",
+ "bottomTexts.buildPrivate": "Las builds privadas solo son visibles para ti.",
"modes.TW": "Territorial",
"modes.SZ": "Pintazonas",
"modes.TC": "Torre",
@@ -96,18 +95,16 @@
"bottomTexts.scrimStartFlexibility": "Si se establece, permite solicitudes para cualquier hora entre el inicio y el fin",
"labels.scrimManagedByAnyone": "Cualquiera puede gestionar",
"bottomTexts.scrimManagedByAnyone": "Si se activa, todos los usuarios de esta publicación pueden aceptar solicitudes y eliminarla, no solo el propietario.",
- "labels.castTwitchAccounts": "",
- "placeholders.castTwitchAccounts": "",
- "bottomTexts.castTwitchAccounts": "",
+ "labels.castTwitchAccounts": "Cuentas de Twitch",
+ "bottomTexts.castTwitchAccounts": "Cuenta de Twitch donde se retransmite el torneo. Los directos de los jugadores se añaden automáticamente basándose en la información de su perfil.",
"labels.scrimMaps": "Mapas",
"labels.scrimMaxDiv": "Div. máxima",
"labels.scrimMinDiv": "Div. mínima",
- "labels.scrimMapSource": "",
- "labels.scrimMapPool": "",
+ "labels.scrimMapSource": "Fuente",
+ "labels.scrimMapPool": "Rotación de escenarios",
"labels.scrimMapsTournament": "Torneo",
- "placeholders.scrimMapPool": "",
- "options.scrimMapSource.POOL": "",
- "options.scrimMapSource.TOURNAMENT": "",
+ "options.scrimMapSource.POOL": "URL de la rotación",
+ "options.scrimMapSource.TOURNAMENT": "Torneo",
"options.scrimFlexibility.notFlexible": "Sin flexibilidad",
"options.scrimFlexibility.+30min": "+30 minutos",
"options.scrimFlexibility.+1hour": "+1 hora",
@@ -129,10 +126,10 @@
"errors.dateTooFarInFuture": "La fecha no puede ser más de 2 semanas en el futuro",
"errors.minUsersExcludingYourself": "Debe haber al menos {{min}} usuarios sin contarte a ti",
"errors.usersMustBeUnique": "Los usuarios deben ser únicos",
- "errors.staffCannotBeAuthor": "",
+ "errors.staffCannotBeAuthor": "El autor del torneo ya es organizador",
"errors.divBothOrNeither": "Deben establecerse tanto la div. mínima como la máxima, o ninguna",
- "errors.invalidMapPool": "",
- "errors.scrimTournamentRequired": "",
+ "errors.invalidMapPool": "Rotación de escenarios no válida",
+ "errors.scrimTournamentRequired": "Por favor, selecciona un torneo",
"errors.tournamentMustBeSelected": "Debe seleccionarse un torneo cuando los mapas son de torneo",
"errors.visibilityMustBeDifferent": "La visibilidad de 'no encontrado' debe ser diferente a la visibilidad base",
"errors.visibilityNotAllowedWhenPublic": "La visibilidad de 'no encontrado' no puede establecerse si la visibilidad base es pública",
@@ -164,18 +161,18 @@
"options.orgRole.MEMBER": "Miembro",
"options.orgRole.ORGANIZER": "Organizador",
"options.orgRole.STREAMER": "Streamer",
- "labels.staff": "",
- "labels.staffRole": "",
- "bottomTexts.staffRolesInfo": "",
- "options.staffRole.ORGANIZER": "",
- "options.staffRole.STREAMER": "",
+ "labels.staff": "Staff",
+ "labels.staffRole": "Rol",
+ "bottomTexts.staffRolesInfo": "Un organizador tiene tus mismos permisos, pero no puede añadir ni quitar al staff. Un streamer solo puede hablar en los chats y ver la contraseña y rotación de la sala.",
+ "options.staffRole.ORGANIZER": "Organizador",
+ "options.staffRole.STREAMER": "Streamer",
"labels.vodYoutubeUrl": "Enlace de YouTube",
"labels.vodTitle": "Título de video",
"labels.vodDate": "Fecha de video",
"labels.vodTeamSize": "Tamaño del equipo",
"labels.vodStartTimestamp": "Tiempo de comienzo",
"labels.vodMode": "Modo",
- "labels.vodStage": "Mapa",
+ "labels.vodStage": "Escenario",
"labels.vodWeapon": "Arma",
"labels.vodWeaponsTeamOne": "Armas (Equipo 1)",
"labels.vodWeaponsTeamTwo": "Armas (Equipo 2)",
@@ -195,7 +192,7 @@
"labels.tagsIncluded": "Etiquetas incluidas",
"labels.tagsExcluded": "Etiquetas excluidas",
"labels.onlySendouEvents": "Solo eventos organizados en sendou.ink",
- "labels.onlyRankedEvents": "Solo eventos anárquicos",
+ "labels.onlyRankedEvents": "Solo eventos competitivos",
"labels.minTeamCount": "Mínimo de equipos",
"labels.orgsIncluded": "Organizaciones visibles",
"labels.orgsExcluded": "Organizaciones ocultas",
@@ -224,23 +221,23 @@
"options.tag.S1": "Splatoon 1",
"options.tag.S2": "Splatoon 2",
"options.tag.SR": "Salmon Run",
- "options.tag.CARDS": "Batallón de cartas",
+ "options.tag.CARDS": "Lucha carterritorial",
"labels.player": "Jugador",
"labels.banUserNote": "Nota privada",
"bottomTexts.banUserNoteHelp": "Esta nota solo es visible para los administradores de la organización.",
"labels.banUserExpiresAt": "Fecha de expiración del baneo",
"bottomTexts.banUserExpiresAtHelp": "Deja vacío para un baneo permanente",
- "labels.reportCategory": "",
- "labels.reportMatchId": "",
- "options.userReportCategory.INAPPROPRIATE_CONTENT": "",
- "options.userReportCategory.ALTING": "",
- "options.userReportCategory.HARASSMENT": "",
- "options.userReportCategory.CHEATING": "",
- "options.userReportCategory.OTHER": "",
+ "labels.reportCategory": "Categoría",
+ "labels.reportMatchId": "ID de la partida",
+ "options.userReportCategory.INAPPROPRIATE_CONTENT": "Contenido inapropiado",
+ "options.userReportCategory.ALTING": "Multicuentas",
+ "options.userReportCategory.HARASSMENT": "Acoso",
+ "options.userReportCategory.CHEATING": "Trampas",
+ "options.userReportCategory.OTHER": "Otro",
"labels.scrimCancelReason": "Motivo de la cancelación",
"bottomTexts.scrimCancelReasonHelp": "Explica por qué cancelas el scrim. Esto será visible para el otro equipo.",
"bottomTexts.bioMarkdown": "Compatible con Markdown",
- "bottomTexts.tournamentStartTime": "",
+ "bottomTexts.tournamentStartTime": "La hora de inicio de los brackets adicionales se establece en la sección de formato del torneo a continuación",
"labels.division": "División",
"options.division.both": "Ambas divisiones",
"options.division.tentatek": "Solo Tentatek",
@@ -259,177 +256,176 @@
"options.controller.grip": "Soporte para Joy-Con",
"options.controller.handheld": "Modo portátil",
"labels.tierListUrl": "URL de Tier List",
- "labels.plusTier": "",
+ "labels.plusTier": "Tier",
"labels.comment": "Comentario",
- "errors.plusAlreadySuggested": "",
- "errors.plusAlreadyMember": "",
- "errors.plusCannotSuggest": "",
- "labels.profileCustomAvatar": "",
- "labels.profileCustomName": "",
+ "errors.plusAlreadySuggested": "Este usuario ya ha sido sugerido",
+ "errors.plusAlreadyMember": "Este usuario ya es miembro de este nivel",
+ "errors.plusCannotSuggest": "No se puede hacer una sugerencia ahora mismo",
+ "labels.profileCustomAvatar": "Avatar personalizado",
+ "labels.profileCustomName": "Nombre personalizado",
"labels.profileCustomUrl": "Enlace personalizado",
"labels.inGameName": "Nombre en el juego",
- "labels.profileBattlefy": "",
+ "labels.profileBattlefy": "Nombre de cuenta de Battlefy",
"labels.profileMotionSens": "Sens del giroscopio",
"labels.profileStickSens": "Sens de palanca",
"labels.profileCountry": "País/Región",
- "labels.profileFavoriteBadges": "",
+ "labels.profileFavoriteBadges": "Insignias favoritas",
"labels.profileShowDiscordUniqueName": "Mostrar usuario de Discord",
"labels.profileCommissionsOpen": "Comisiones abiertas",
"labels.profileCommissionText": "Info de comisiones",
- "labels.profileNewProfileEnabled": "",
- "bottomTexts.profileCustomAvatar": "",
- "bottomTexts.profileCustomName": "",
- "bottomTexts.profileCustomUrl": "",
- "bottomTexts.profileInGameName": "",
- "bottomTexts.profileBattlefy": "",
- "bottomTexts.profileShowDiscordUniqueName": "¿Mostrar tu nombre de Discord ({{discordUniqueName}}) publicamente?",
- "bottomTexts.profileCommissionsOpen": "",
- "bottomTexts.profileCommissionText": "Precio, espacios abiertos, o cualquier otra información sobre tus comiciones.",
- "bottomTexts.profileNewProfileEnabled": "",
+ "labels.profileNewProfileEnabled": "Nueva página de perfil",
+ "bottomTexts.profileCustomAvatar": "Los mecenas (Supporter y superior) pueden subir una imagen para usarla en lugar del avatar de Discord",
+ "bottomTexts.profileCustomName": "Si está vacío, se mostrará tu nombre de Discord",
+ "bottomTexts.profileCustomUrl": "Para los mecenas (Supporter y superior) hay un enlace corto disponible. Ej. en lugar de sendou.ink/u/sendou, se puede usar snd.ink/sendou.",
+ "bottomTexts.profileInGameName": "Formato: Nombre#disc (ej. Jugador#1234)",
+ "bottomTexts.profileBattlefy": "Se usa para el seed y la verificación en algunos torneos",
+ "bottomTexts.profileShowDiscordUniqueName": "¿Mostrar tu nombre de Discord ({{discordUniqueName}}) públicamente?",
+ "bottomTexts.profileCommissionsOpen": "Las comisiones se cierran automáticamente después de un mes",
+ "bottomTexts.profileCommissionText": "Precio, espacios abiertos, o cualquier otra información sobre tus comisiones.",
+ "bottomTexts.profileNewProfileEnabled": "Habilitar la nueva página de perfil basada en widgets (solo para supporter)",
"errors.profileCustomUrlStrangeChar": "Enlace personalizado no puede contener caracteres especiales",
- "errors.profileCustomUrlNumbers": "Enlace personalizado no puede ser solo numeros",
+ "errors.profileCustomUrlNumbers": "El enlace personalizado no puede ser solo números",
"errors.profileCustomUrlDuplicate": "Alguien ya tiene ese enlace personalizado",
- "errors.profileSensBothOrNeither": "Motion sens can't be set if R-stick sens isn't",
- "errors.profileInGameName": "",
- "inGameName.addCharacter": "",
- "inGameName.categories.symbols": "",
- "inGameName.categories.accented": "",
- "inGameName.categories.greek": "",
- "inGameName.categories.cyrillic": "",
- "inGameName.categories.hiragana": "",
- "inGameName.categories.katakana": "",
- "inGameName.categories.cjkSymbols": "",
- "labels.pronoun": "",
- "bottomTexts.profilePronouns": "",
- "errors.profilePronounsBothOrNeither": "",
- "labels.friendUser": "",
- "errors.cannotFriendSelf": "",
- "errors.alreadyFriends": "",
- "errors.friendRequestExists": "",
- "labels.type": "",
- "labels.visibility": "",
- "labels.note": "",
- "labels.stayAsSub": "",
- "bottomTexts.stayAsSub": "",
- "labels.regLinkedTeam": "",
- "labels.regTeamName": "",
- "labels.regTeam": "",
- "labels.regCaptain": "",
- "labels.regSignUpAs": "",
- "labels.regPickUpName": "",
- "labels.regPrefersNotToHost": "",
- "errors.regLinkedTeamRequired": "",
- "errors.regTeamNameRequired": "",
- "errors.regOwnerMustBeMember": "",
- "errors.regTeamNameTaken": "",
- "errors.regTooManyMembers": "",
- "errors.regMemberInvalid": "",
- "errors.regMemberNoFriendCode": "",
- "errors.regMemberNoInGameName": "",
- "errors.regMemberBanned": "",
- "errors.regMemberOnAnotherTeam": "",
- "errors.regCannotRemoveParticipatedPlayer": "",
- "errors.regCheckedInBelowMinRoster": "",
- "regImportTeam": "",
- "labels.regImportSourceTournament": "",
- "errors.regImportTournamentRequired": "",
- "labels.organization": "",
- "labels.rules": "",
- "labels.dates": "",
- "labels.date": "",
- "labels.bracketUrl": "",
- "labels.discordInvite": "",
- "labels.tags": "",
- "labels.badges": "",
- "labels.regClosesAt": "",
- "labels.playersCount": "",
- "labels.maxTeamSize": "",
- "labels.ranked": "",
- "labels.splattercolorScreenToggle": "",
- "labels.lfgTab": "",
- "labels.autonomousSubs": "",
- "labels.requireInGameNames": "",
- "labels.invitational": "",
- "labels.test": "",
- "labels.draft": "",
- "labels.requireSendouQ": "",
- "labels.mapPickingStyle": "",
- "bottomTexts.regClosesAt": "",
- "bottomTexts.maxTeamSize": "",
- "bottomTexts.avatarValidation": "",
- "bottomTexts.ranked": "",
- "bottomTexts.splattercolorScreen": "",
- "bottomTexts.lfgTab": "",
- "bottomTexts.autonomousSubs": "",
- "bottomTexts.requireInGameNames": "",
- "bottomTexts.invitational": "",
- "bottomTexts.test": "",
- "bottomTexts.draftInfo": "",
- "bottomTexts.requireSendouQ": "",
- "options.toToolsMode.ALL": "",
- "options.toToolsMode.SZ": "",
- "options.toToolsMode.TC": "",
- "options.toToolsMode.RM": "",
- "options.toToolsMode.CB": "",
- "options.toToolsMode.TO": "",
- "options.regClosesAt.0": "",
- "options.regClosesAt.5min": "",
- "options.regClosesAt.10min": "",
- "options.regClosesAt.15min": "",
- "options.regClosesAt.30min": "",
- "options.regClosesAt.1h": "",
- "options.regClosesAt.1h30min": "",
- "options.regClosesAt.2h": "",
- "options.regClosesAt.3h": "",
- "options.regClosesAt.6h": "",
- "options.regClosesAt.12h": "",
- "options.regClosesAt.18h": "",
- "options.regClosesAt.24h": "",
- "options.regClosesAt.48h": "",
- "options.regClosesAt.72h": "",
- "errors.allModePool": "",
- "errors.bracketUrlRequired": "",
- "errors.bracketProgressionRequired": "",
- "errors.maxMembersRange": "",
+ "errors.profileSensBothOrNeither": "No se puede configurar la sensibilidad del giroscopio sin configurar la de la palanca derecha",
+ "errors.profileInGameName": "Debe coincidir con el formato: Nombre#disc (1-10 caracteres, #, 4-5 alfanuméricos)",
+ "inGameName.addCharacter": "Añadir carácter especial",
+ "inGameName.categories.symbols": "Símbolos",
+ "inGameName.categories.accented": "Acentuados",
+ "inGameName.categories.greek": "Griegos",
+ "inGameName.categories.cyrillic": "Cirílicos",
+ "inGameName.categories.hiragana": "Hiragana",
+ "inGameName.categories.katakana": "Katakana",
+ "inGameName.categories.cjkSymbols": "Símbolos CJK",
+ "labels.pronoun": "Pronombre",
+ "bottomTexts.profilePronouns": "¡Este ajuste es opcional! Tus pronombres se mostrarán en tu perfil, rosters de torneos, grupos de SendouQ y canales de texto.",
+ "errors.profilePronounsBothOrNeither": "Selecciona ambos pronombres o ninguno",
+ "labels.friendUser": "Usuario",
+ "errors.cannotFriendSelf": "No puedes enviarte una solicitud de amistad a ti mismo",
+ "errors.alreadyFriends": "Ya eres amigo de este usuario",
+ "errors.friendRequestExists": "Ya existe una solicitud de amistad entre tú y este usuario",
+ "labels.type": "Tipo",
+ "labels.visibility": "Visibilidad",
+ "labels.note": "Nota",
+ "labels.stayAsSub": "Quedarse como sub",
+ "bottomTexts.stayAsSub": "Si no encuentras miembros para el equipo antes de que termine la inscripción, te quedarás como sub en solitario durante el torneo",
+ "labels.regLinkedTeam": "Vincular a equipo de sendou.ink",
+ "labels.regTeamName": "Nombre del equipo",
+ "labels.regTeam": "Equipo",
+ "labels.regCaptain": "Capitán",
+ "labels.regSignUpAs": "El equipo se inscribe como",
+ "labels.regPickUpName": "Nombre del pick-up",
+ "labels.regPrefersNotToHost": "Mi equipo prefiere no hostear salas",
+ "errors.regLinkedTeamRequired": "Selecciona un equipo",
+ "errors.regTeamNameRequired": "El nombre del equipo es obligatorio",
+ "errors.regOwnerMustBeMember": "El capitán debe ser uno de los jugadores",
+ "errors.regTeamNameTaken": "Este nombre de equipo ya está en uso",
+ "errors.regTooManyMembers": "Demasiados jugadores en el roster",
+ "errors.regMemberInvalid": "Jugador inválido",
+ "errors.regMemberNoFriendCode": "Este jugador no tiene código de amigo",
+ "errors.regMemberNoInGameName": "Este jugador no tiene nombre en el juego",
+ "errors.regMemberBanned": "Este jugador está baneado actualmente de sendou.ink",
+ "errors.regMemberOnAnotherTeam": "Este jugador ya está en otro equipo",
+ "errors.regCannotRemoveParticipatedPlayer": "No se puede eliminar a un jugador que ya ha participado en el torneo",
+ "errors.regCheckedInBelowMinRoster": "Un equipo con check-in no puede tener menos del tamaño mínimo del roster",
+ "regImportTeam": "Importar equipo",
+ "labels.regImportSourceTournament": "Torneo",
+ "errors.regImportTournamentRequired": "Selecciona un torneo",
+ "labels.organization": "Organización",
+ "labels.rules": "Reglas",
+ "labels.dates": "Fechas",
+ "labels.date": "Fecha",
+ "labels.bracketUrl": "URL del bracket",
+ "labels.discordInvite": "URL de invitación al servidor de Discord",
+ "labels.tags": "Etiquetas",
+ "labels.badges": "Premios de insignias",
+ "labels.regClosesAt": "La inscripción cierra a las",
+ "labels.playersCount": "Número de jugadores",
+ "labels.maxTeamSize": "Tamaño máximo del equipo",
+ "labels.ranked": "Competitivo",
+ "labels.splattercolorScreenToggle": "Alternar Pantintalla",
+ "labels.lfgTab": "Pestaña LFG",
+ "labels.autonomousSubs": "Subs autónomos",
+ "labels.requireInGameNames": "Requerir nombres en el juego",
+ "labels.invitational": "Invitacional",
+ "labels.test": "Prueba",
+ "labels.draft": "Borrador",
+ "labels.requireSendouQ": "Requerir participación en SendouQ",
+ "labels.mapPickingStyle": "Estilo de selección de escenario",
+ "bottomTexts.regClosesAt": "Todos los horarios son relativos a la hora de inicio del torneo. Ej. \"30 minutos\" significa \"30 minutos antes del inicio del evento\". Una vez cerrada la inscripción, solo los TOs pueden cambiar los rosters.",
+ "bottomTexts.maxTeamSize": "Número máximo de jugadores que pueden registrarse por equipo. No aplica a los organizadores del torneo. El valor por defecto es 6.",
+ "bottomTexts.avatarValidation": "Ten en cuenta que para los no mecenas hay un proceso de validación antes de que se muestre el avatar.",
+ "bottomTexts.ranked": "Los torneos competitivos afectan al Sendou Power. Los torneos sin inscripción abierta (con límite de nivel) o \"torneos gimmick\" deben ser siempre no competitivos. Cualquier torneo durante la off-season es no competitivo independientemente de lo que se elija aquí.",
+ "bottomTexts.splattercolorScreen": "Banear Pantintalla en los combates según las preferencias de los equipos.",
+ "bottomTexts.lfgTab": "Permitir a los participantes buscar más miembros a través de la función LFG e inscribirse como subs (después del cierre de inscripciones).",
+ "bottomTexts.autonomousSubs": "Si está activado, los equipos pueden añadir subs por su cuenta durante el torneo. Si está desactivado, deben hacerlo los TOs.",
+ "bottomTexts.requireInGameNames": "Si está activado, los jugadores no pueden unirse al torneo sin un nombre en el juego (ej. Sendou#1234). Los jugadores no pueden cambiar los IGN después del cierre de inscripciones.",
+ "bottomTexts.invitational": "Sin inscripción abierta ni lista de subs. Todos los equipos deben ser añadidos por el organizador.",
+ "bottomTexts.test": "Los torneos de prueba no aparecen en el calendario, no envían notificaciones a los jugadores y no se mostrarán en los perfiles ni resultados de los jugadores",
+ "bottomTexts.draftInfo": "Los torneos borrador están ocultos y solo son visibles para los organizadores. El torneo debe abrirse (desactivando esta opción) antes de poder empezar cualquier bracket.",
+ "bottomTexts.requireSendouQ": "Los jugadores deben haber jugado suficientes combates de SendouQ esta temporada para inscribirse",
+ "options.toToolsMode.ALL": "Preseleccionado por los equipos - Todos los modos",
+ "options.toToolsMode.SZ": "Preseleccionado por los equipos - Solo Pintazonas",
+ "options.toToolsMode.TC": "Preseleccionado por los equipos - Solo Torre",
+ "options.toToolsMode.RM": "Preseleccionado por los equipos - Solo Pez dorado",
+ "options.toToolsMode.CB": "Preseleccionado por los equipos - Solo Asalto Almeja",
+ "options.toToolsMode.TO": "Seleccionado por el TO",
+ "options.regClosesAt.0": "A la hora de inicio",
+ "options.regClosesAt.5min": "5 minutos",
+ "options.regClosesAt.10min": "10 minutos",
+ "options.regClosesAt.15min": "15 minutos",
+ "options.regClosesAt.30min": "30 minutos",
+ "options.regClosesAt.1h": "1 hora",
+ "options.regClosesAt.1h30min": "1 hora 30 minutos",
+ "options.regClosesAt.2h": "2 horas",
+ "options.regClosesAt.3h": "3 horas",
+ "options.regClosesAt.6h": "6 horas",
+ "options.regClosesAt.12h": "12 horas",
+ "options.regClosesAt.18h": "18 horas",
+ "options.regClosesAt.24h": "24 horas",
+ "options.regClosesAt.48h": "48 horas",
+ "options.regClosesAt.72h": "72 horas",
+ "errors.allModePool": "La rotación de escenarios debe contener un escenario para cada modo competitivo si se usa \"Preseleccionado por los equipos - Todos los modos\"",
+ "errors.bracketUrlRequired": "La URL del bracket es obligatoria",
+ "errors.bracketProgressionRequired": "La progresión del bracket debe configurarse para los torneos",
+ "errors.maxMembersRange": "El tamaño máximo del equipo debe estar entre 4 y 10",
"labels.participantCount": "Participantes",
- "labels.teams": "",
+ "labels.teams": "Equipos",
"labels.teamName": "Nombre de equipo",
"labels.placement": "Lugar",
"errors.emptyTeam": "Cada equipo requiere por lo menos un jugador.",
"errors.duplicatePlayer": "No se puede tener el mismo jugador dos veces en el mismo equipo.",
"errors.uniqueTeamName": "Cada equipo requiere un nombre único.",
- "errors.numberOutOfRange": "",
+ "errors.numberOutOfRange": "El número está fuera del rango permitido",
"labels.sentiment": "Opinión",
"bottomTexts.sentiment": "Opinión positiva o negativa afecta el orden de otros en la fila",
"options.sentiment.POSITIVE": "Positivo",
"options.sentiment.NEUTRAL": "Neutral",
"options.sentiment.NEGATIVE": "Negativo",
- "labels.adminOldUser": "",
- "labels.adminNewUser": "",
- "labels.adminPlayerId": "",
- "labels.friendCode": "",
- "labels.patronTier": "",
- "labels.patronExpiresAt": "",
- "labels.reason": "",
- "labels.cancelNominatedPlayers": "",
- "bottomTexts.cancelNominatedPlayers": "",
- "bottomTexts.adminMigrateNewUser": "",
- "errors.invalidFriendCode": "",
- "options.patronTier.1": "",
- "options.patronTier.2": "",
- "options.patronTier.3": "",
- "placeholders.friendCode": "",
- "unsavedChanges.title": "",
- "unsavedChanges.body": "",
- "unsavedChanges.discard": "",
- "labels.trophyName": "",
- "labels.trophyModel": "",
- "labels.trophyOrganization": "",
- "labels.trophyManager": "",
- "labels.trophyInformation": "",
- "labels.profileFavoriteTrophies": "",
- "labels.profileHiddenTrophies": "",
- "bottomTexts.trophyModel": "",
- "errors.trophyNameTaken": "",
- "errors.trophyWithBadges": ""
+ "labels.adminOldUser": "Usuario antiguo",
+ "labels.adminNewUser": "Usuario nuevo",
+ "labels.adminPlayerId": "ID del jugador",
+ "labels.friendCode": "Código de amigo",
+ "labels.patronTier": "Nivel de mecenas",
+ "labels.patronExpiresAt": "Mecenas hasta",
+ "labels.reason": "Motivo",
+ "labels.cancelNominatedPlayers": "Jugador(es) responsable(s) de la cancelación",
+ "bottomTexts.cancelNominatedPlayers": "Si todos están disponibles para jugar pero, por ejemplo, hay mantenimiento en la red de Switch, marca a todos.",
+ "bottomTexts.adminMigrateNewUser": "Los datos del nuevo usuario se eliminarán (ej. builds)",
+ "errors.invalidFriendCode": "Código de amigo inválido",
+ "options.patronTier.1": "Support",
+ "options.patronTier.2": "Supporter",
+ "options.patronTier.3": "Supporter+",
+ "unsavedChanges.title": "Cambios sin guardar",
+ "unsavedChanges.body": "¿Estás seguro de que quieres salir? Los cambios que has hecho no se guardarán.",
+ "unsavedChanges.discard": "Salir de la página",
+ "labels.trophyName": "Nombre",
+ "labels.trophyModel": "Estado del modelo 3D",
+ "labels.trophyOrganization": "Organización",
+ "labels.trophyManager": "Mánager",
+ "labels.trophyInformation": "Información adicional",
+ "labels.profileFavoriteTrophies": "Trofeos favoritos",
+ "labels.profileHiddenTrophies": "Trofeos ocultos",
+ "bottomTexts.trophyModel": "El estado del modelo 3D exportado desde el",
+ "errors.trophyNameTaken": "Ya existe un trofeo con este nombre",
+ "errors.trophyWithBadges": "No se pueden combinar trofeo e insignias"
}
diff --git a/locales/es-ES/friends.json b/locales/es-ES/friends.json
index fbce6b594..734f60e83 100644
--- a/locales/es-ES/friends.json
+++ b/locales/es-ES/friends.json
@@ -1,27 +1,26 @@
{
- "incomingRequests.title": "",
- "sendRequest.title": "",
- "sendRequest.submit": "",
- "pendingRequests.title": "",
- "friendsList.title": "",
- "friendsList.empty": "",
- "friendsList.friendSince": "",
- "friendsList.viewUserPage": "",
- "friendsList.viewTournament": "",
- "friendsList.viewMatch": "",
- "friendsList.live": "",
- "friendsList.inMatch": "",
- "friendsList.nextMatch": "",
- "friendsList.watchStream": "",
- "friendsList.joinSendouQ": "",
- "friendsList.deleteFriend": "",
- "friendsList.deleteConfirm": "",
- "view.label": "",
- "view.friends": "",
- "view.teamMembers": "",
- "view.all": "",
- "teamMembers.empty": "",
- "unseenRequests_one": "",
- "unseenRequests_many": "",
- "unseenRequests_other": ""
+ "incomingRequests.title": "Solicitudes entrantes",
+ "sendRequest.title": "Enviar solicitud de amistad",
+ "sendRequest.submit": "Enviar solicitud",
+ "pendingRequests.title": "Solicitudes pendientes",
+ "friendsList.title": "Amigos",
+ "friendsList.empty": "Aún no hay amigos",
+ "friendsList.friendSince": "Amigos desde el {{date}}",
+ "friendsList.viewUserPage": "Ver página de usuario",
+ "friendsList.viewTournament": "Ver torneo",
+ "friendsList.viewMatch": "Ver combate",
+ "friendsList.live": "En directo",
+ "friendsList.inMatch": "Combate",
+ "friendsList.nextMatch": "Siguiente",
+ "friendsList.watchStream": "Ver stream",
+ "friendsList.joinSendouQ": "Unirse a SendouQ",
+ "friendsList.deleteFriend": "Eliminar amigo",
+ "friendsList.deleteConfirm": "¿Eliminar a {{name}} de tus amigos?",
+ "view.label": "Filtro de vista",
+ "view.friends": "Amigos",
+ "view.teamMembers": "Miembros del equipo",
+ "view.all": "Todos",
+ "teamMembers.empty": "Aún no hay miembros en el equipo",
+ "unseenRequests_one": "{{count}} solicitud de amistad sin ver",
+ "unseenRequests_other": "{{count}} solicitudes de amistad sin ver"
}
diff --git a/locales/es-ES/front.json b/locales/es-ES/front.json
index 417357962..43a78b935 100644
--- a/locales/es-ES/front.json
+++ b/locales/es-ES/front.json
@@ -1,14 +1,14 @@
{
- "nav.play": "",
- "nav.tools": "",
- "nav.community": "",
- "nav.weapons": "",
- "welcomeBanner": "",
+ "nav.play": "Jugar",
+ "nav.tools": "Herramientas",
+ "nav.community": "Comunidad",
+ "nav.weapons": "Armas",
+ "welcomeBanner": "¡¿Nuevo en el competitivo de Splatoon?! ¡Empieza aquí!",
"sq.season": "Temporada {{nth}}",
"sq.prepare": "¡Prepárate ahora!",
"sq.participate": "¡Participa ahora!",
- "showcase.card.ranked": "Anárquico",
- "showcase.card.unranked": "Sin rango",
+ "showcase.card.ranked": "Competitivo",
+ "showcase.card.unranked": "No competitivo",
"showcase.card.winner": "Ganador",
"showcase.results": "Resultados recientes",
"showcase.viewAll": "Ver todos los torneos",
@@ -17,40 +17,40 @@
"leaderboards.viewFull": "Ver clasificación completa",
"updates.header": "Actualizaciones",
"updates.viewPast": "Ver actualizaciones anteriores",
- "sideNav.myCalendar": "",
- "sideNav.noEvents": "",
- "sideNav.noStreams": "",
- "sideNav.friends": "",
- "sideNav.friends.notLoggedIn": "",
- "sideNav.friends.noFriends": "",
- "sideNav.streams": "",
- "sideNav.streams.upcoming": "",
- "sideNav.scrimVs": "",
- "sideNav.lookingForScrim": "",
- "sideNav.scrimRequestPending": "",
- "mobileNav.menu": "",
- "mobileNav.friends": "",
- "mobileNav.you": "",
- "mobileNav.chat": "",
- "mobileNav.login": "",
- "mobileNav.queue": "",
- "rotations.header": "",
- "rotations.series": "",
- "rotations.open": "",
- "rotations.x": "",
- "rotations.current": "",
- "rotations.nextLabel": "",
- "rotations.credit": "",
- "rotations.filter.all": "",
- "discover.header": "",
- "install.button": "",
- "install.header": "",
- "install.banner.title": "",
- "install.banner.description": "",
- "install.ios.step1": "",
- "install.ios.step2": "",
- "install.ios.step3": "",
- "install.safari.step1": "",
- "install.safari.step2": "",
- "install.safari.step3": ""
+ "sideNav.myCalendar": "Eventos",
+ "sideNav.noEvents": "Sin eventos próximos",
+ "sideNav.noStreams": "Sin transmisiones actualmente",
+ "sideNav.friends": "Amigos",
+ "sideNav.friends.notLoggedIn": "Inicia sesión para seguir la actividad de tus amigos",
+ "sideNav.friends.noFriends": "Añade amigos para ver su actividad aquí",
+ "sideNav.streams": "Transmisiones",
+ "sideNav.streams.upcoming": "Próximas",
+ "sideNav.scrimVs": "vs. {{opponent}}",
+ "sideNav.lookingForScrim": "Buscando scrim",
+ "sideNav.scrimRequestPending": "Solicitud pendiente",
+ "mobileNav.menu": "Menú",
+ "mobileNav.friends": "Amigos",
+ "mobileNav.you": "Tú",
+ "mobileNav.chat": "Chat",
+ "mobileNav.login": "Iniciar sesión",
+ "mobileNav.queue": "Cola",
+ "rotations.header": "Rotaciones",
+ "rotations.series": "Caótico en serie",
+ "rotations.open": "Caótico abierto",
+ "rotations.x": "Combate X",
+ "rotations.current": "Ahora",
+ "rotations.nextLabel": "Siguiente",
+ "rotations.credit": "Datos de splatoon3.ink",
+ "rotations.filter.all": "Todas",
+ "discover.header": "Descubre todas las funciones",
+ "install.button": "Instalar aplicación",
+ "install.header": "Instalar sendou.ink",
+ "install.banner.title": "Obtén la aplicación sendou.ink",
+ "install.banner.description": "Añade sendou.ink a tu pantalla de inicio para un acceso rápido",
+ "install.ios.step1": "Toca el botón compartir en tu navegador",
+ "install.ios.step2": "Selecciona \"Añadir a la pantalla de inicio\"",
+ "install.ios.step3": "Toca \"Añadir\"",
+ "install.safari.step1": "Haz clic en el botón compartir en la barra de herramientas de Safari",
+ "install.safari.step2": "Selecciona \"Añadir al Dock\"",
+ "install.safari.step3": "Haz clic en \"Añadir\""
}
diff --git a/locales/es-ES/gear.json b/locales/es-ES/gear.json
index 6aeb5bfb1..c6c3ff6c5 100644
--- a/locales/es-ES/gear.json
+++ b/locales/es-ES/gear.json
@@ -552,13 +552,13 @@
"C_7024": "Jersey algas y estrellas",
"C_7025": "Sudadera pez feroz",
"H_8000": "Máscara antigás",
- "C_8000": "Camisa cuadros ocres",
+ "C_8000": "Camisa de cuadros leñador",
"S_8000": "Suela extra blanca",
"H_8001": "Máscara protectora",
"C_8001": "Camisa de época",
"S_8001": "Suela extra rosa",
"H_8002": "Pañuelo clásico",
- "C_8002": "Camisa cuadros verdes",
+ "C_8002": "Camisa de cuadros verdes",
"S_8002": "Suela extra turquesa",
"H_8003": "Pañuelo calavera",
"C_8003": "Camisa blanca",
@@ -570,7 +570,7 @@
"C_8005": "Camisa tropical",
"S_8005": "Zapato doble hebilla",
"H_8006": "Mascarilla octo Theutik",
- "C_8006": "Camisa cuadros rojos",
+ "C_8006": "Camisa de cuadros rojos",
"S_8006": "Zapato elegante",
"H_8007": "Mascarilla calamar",
"C_8007": "Camisa medusas",
@@ -582,7 +582,7 @@
"C_8009": "Camisa tonos grises",
"S_8009": "Zapato doble hebilla negro",
"H_8010": "Cubrenariz motocross",
- "C_8010": "Camisa cuadros retro",
+ "C_8010": "Camisa de cuadros retro",
"S_8010": "Suela extra Annak",
"H_8011": "Mascarilla Forima",
"C_8011": "Camisa cuello redondo",
@@ -657,11 +657,11 @@
"C_10001": "Sudadera verde",
"C_10002": "Sudadera Ezko",
"H_10003": "Pendientes tentáculo",
- "C_10004": "Sudadera con camisa",
+ "C_10004": "Sudadera azul con camisa",
"C_10005": "Sudadera morada Theutik",
"C_10006": "Sudadera gris con capucha",
"C_10007": "Sudadera plantas",
- "C_10008": "Sudadera rosa con camisa",
+ "C_10008": "Sudadera rosa",
"C_10009": "Sudadera Ezko oliva",
"C_10010": "Sudadera negra con capucha",
"C_10012": "Sudadera de jerga roja",
diff --git a/locales/es-ES/lfg.json b/locales/es-ES/lfg.json
index b55a0224f..39b6e1fd5 100644
--- a/locales/es-ES/lfg.json
+++ b/locales/es-ES/lfg.json
@@ -4,11 +4,11 @@
"types.TEAM_FOR_PLAYER": "Buscando jugadores",
"types.TEAM_FOR_COACH": "Buscando entrenador de equipo",
"types.TEAM_FOR_SCRIM": "Buscando compañeros para practicar",
- "types.COACH_FOR_TEAM": "Ofrecer entrenamiento",
+ "types.COACH_FOR_TEAM": "Ofreciendo entrenamiento",
"post.lastActive": "hace",
"noPosts": "Sin publicaciones que coincidan con el filtro",
"expiring": "La publicación caduca. ¿Sigues buscando?",
- "addFilter": "",
+ "addFilter": "Añadir filtro",
"filters.Weapon": "Grupo de armas",
"filters.Type": "Tipo de publicación",
"filters.Timezone": "Diferencia horaria",
@@ -18,7 +18,7 @@
"filters.MinTier": "Nivel mínimo",
"filters.suffix": "filtro",
"filters.orAbove": "o más",
- "new.noMorePosts": "No puede crear más publicaciones",
+ "new.noMorePosts": "No puedes crear más publicaciones",
"new.type.header": "Tipo",
"new.timezone.header": "Zona horaria",
"new.text.header": "Texto",
diff --git a/locales/es-ES/org.json b/locales/es-ES/org.json
index 79624c803..45a1e9d6d 100644
--- a/locales/es-ES/org.json
+++ b/locales/es-ES/org.json
@@ -20,8 +20,8 @@
"edit.form.series.seriesName.title": "Nombre de la serie",
"edit.form.series.showLeaderboard.title": "Mostrar tablas de posición",
"edit.form.badges.title": "Insignias",
- "edit.form.rewards.title": "",
- "edit.form.errors.noUnadmin": "No se puede eliminar como admin",
+ "edit.form.rewards.title": "Recompensas",
+ "edit.form.errors.noUnadmin": "No puedes quitarte el rol de admin",
"edit.form.customTheme.title": "",
"banned.title": "Jugadores baneados",
"banned.empty": "Actualmente no hay jugadores baneados en esta organización.",
@@ -46,7 +46,7 @@
"leave.soleAdmin": "Eres el único admin de esta organización. Añade otro admin primero o pide a un administrador del sitio que la elimine.",
"new.heading": "Nueva organización",
"new.noPermissions": "Sin permisos para añadir organizaciones. Las organizaciones pueden ser creadas por usuarios con permisos de organizador de torneos.",
- "stats.title": "",
- "stats.established.title": "",
- "stats.established.help": ""
+ "stats.title": "Estadísticas",
+ "stats.established.title": "Estado establecido",
+ "stats.established.help": "Media de jugadores activos en los últimos {{months}} meses. Alcanza {{gain}} para establecerte, baja de {{lose}} para perderlo. Consulta la página de FAQ para más información sobre las organizaciones establecidas."
}
diff --git a/locales/es-ES/params.json b/locales/es-ES/params.json
index 27b54df67..ceee1a826 100644
--- a/locales/es-ES/params.json
+++ b/locales/es-ES/params.json
@@ -1,14 +1,14 @@
{
- "tab.params": "",
- "tab.patches": "",
- "noPatches": "",
- "patches.showSubSpecial": "",
- "header.parameter": "",
- "legend.title": "",
- "legend.damage": "",
- "legend.frames": "",
- "legend.powerUp": "",
- "compare.action": "",
- "compare.heading": "",
- "dataCredit.lean": ""
+ "tab.params": "Parámetros",
+ "tab.patches": "Historial de parches",
+ "noPatches": "Aún no hay cambios de balance registrados para este arma.",
+ "patches.showSubSpecial": "Mostrar cambios de secundarias y especiales",
+ "header.parameter": "Parámetro",
+ "legend.title": "Notas",
+ "legend.damage": "Los valores de daño se almacenan ×10, por lo que un valor de 450 significa 45.0 de daño.",
+ "legend.frames": "Los tiempos se miden en frames, donde 60 frames = 1 segundo.",
+ "legend.powerUp": "Bajo, Medio y Alto muestran el mismo valor con ninguno, una cantidad moderada y la cantidad máxima de la habilidad de potenciación relevante equipada (Aumento de especial para especiales, Mejora de secundaria para secundarias).",
+ "compare.action": "Comparar entre armas",
+ "compare.heading": "{{parameter}} entre armas",
+ "dataCredit.lean": "Créditos de datos: Lean"
}
diff --git a/locales/es-ES/q.json b/locales/es-ES/q.json
index 9e604b948..802f062b8 100644
--- a/locales/es-ES/q.json
+++ b/locales/es-ES/q.json
@@ -17,16 +17,16 @@
"front.cities.nyc": "Nueva York",
"front.cities.paris": "París",
"front.cities.tokyo": "Tokio",
- "front.inviteCodeWrong": "El codigo de invitación no coincide con ningun equipo activo",
- "front.noFriendCode": "Ingresa clave de amigo antes de unirte al grupo",
- "front.noFriendCodeHelp": "",
+ "front.inviteCodeWrong": "El código de invitación no coincide con ningún equipo activo",
+ "front.noFriendCode": "Configura tu clave de amigo antes de unirte al grupo",
+ "front.noFriendCodeHelp": "Necesitas guardar tu código de amigo para jugar SendouQ",
"front.upcomingSeason.header": "¡Es fuera de temporada!",
"front.upcomingSeason.date": "Únete a la Temporada {{nth}} empezando {{date}}",
- "front.noUpcomingSeason": "La empieza de la próxima Temporada está por anunciar",
+ "front.noUpcomingSeason": "El inicio de la próxima Temporada está por anunciar",
"front.nav.rules.title": "Reglas",
- "front.nav.rules.description": "Leelas antes de jugar",
+ "front.nav.rules.description": "Léelas antes de jugar",
"front.nav.info.title": "Información",
- "front.nav.info.description": "Qué es SendouQ y como usarlo",
+ "front.nav.info.description": "Qué es SendouQ y cómo usarlo",
"front.nav.settings.title": "Preferencias",
"front.nav.settings.description": "Preferencias de mapas, grupos de armas, chat de voz, y sonidos",
"front.nav.leaderboards.title": "Tablas de posición",
@@ -38,18 +38,18 @@
"front.actions.logIn": "Ingresa al sitio para unirte a SendouQ",
"front.actions.joinWithGroup": "Unirte con amigos",
"front.actions.joinSolo": "Unirte solo",
- "front.freshAccountWait": "",
+ "front.freshAccountWait": "Como cuenta nueva, por favor espera antes de unirte a la cola. Puedes unirte a las {{time}}",
"front.join.header": "¿Unirte al grupo con {{members}}?",
"front.join.joinAction": "Únete",
- "front.join.friendSuggestion": "",
+ "front.join.friendSuggestion": "Consejo: si añades como amigo al usuario que te invitó, podrá añadirte directamente la próxima vez",
"front.seasonOpen": "Temporada {{nth}} está abierta",
"front.preview": "Ver avance de grupos en fila sin unirte",
- "front.preview.explanation": "Esta función solo es disponible para Patrons a nivel Supporter (o más alto) de sendou.ink",
+ "front.preview.explanation": "Esta función solo está disponible para mecenas de nivel Supporter (o superior) de sendou.ink",
"looking.joiningGroupError": "Antes de unirte a otro grupo, deja el grupo actual",
"looking.goToSettingsPrompt": "Para encontrar grupos más fácil, elige tu grupo de armas y estado de chat en la página de preferencias",
"looking.inactiveGroup.soon": "Grupo será marcado como inactivo. ¿Aún estás buscando?",
"looking.inactiveGroup": "Grupo oculto por inactividad. ¿Aún estás buscando?",
- "looking.inactiveGroup.action": "Haz click aquí",
+ "looking.inactiveGroup.action": "Haz clic aquí",
"looking.lastUpdatedAt": "Se actualizó {{time}}",
"looking.columns.invited": "Invitado",
"looking.columns.challenged": "Desafiado",
@@ -68,37 +68,37 @@
"looking.groups.actions.removeManager": "Quitar mánager",
"looking.groups.actions.kick": "Expulsar",
"looking.groups.actions.leaveGroup": "Dejar grupo",
- "looking.groups.actions.leaveGroup.confirm": "",
- "looking.groups.actions.stopLooking": "",
- "looking.groups.actions.stopLooking.confirm": "",
- "looking.groups.actions.organizerRemove.confirm": "",
+ "looking.groups.actions.leaveGroup.confirm": "¿Abandonar este grupo?",
+ "looking.groups.actions.stopLooking": "Dejar de buscar",
+ "looking.groups.actions.stopLooking.confirm": "¿Quieres dejar de buscar (se eliminarán las invitaciones dadas/recibidas)?",
+ "looking.groups.actions.organizerRemove.confirm": "¿Eliminar a {{name}} de LFG?",
"looking.groups.actions.leaveQ": "Dejar fila",
"looking.groups.actions.goBack": "Regresar",
- "looking.groups.adder.quickAdd": "Añadir rapido",
+ "looking.groups.adder.quickAdd": "Añadir rápido",
"looking.groups.adder.error": "Ese usuario ya está en un grupo",
"looking.groups.adder.others": "Otros",
"looking.groups.adder.inviteLink": "Enlace de invitación",
"looking.groups.adder.select": "Seleccionar usuario...",
"looking.groups.editNote": "Editar nota",
"looking.groups.addNote": "Añadir nota",
- "looking.groups.stayAsSub": "",
+ "looking.groups.stayAsSub": "Sub",
"looking.replay": "Repetir",
"looking.teamSP": "Fuerza Sendou de Equipo",
"looking.teamSP.calculated": "Fuerza Sendou de Equipo calculada",
"looking.teamSP.calculating": "Calculando Fuerza Sendou de Equipo...",
"looking.sp.calculated": "Calculada",
"looking.sp.calculating": "Calculando...",
- "looking.rankCalculating": "Menos de {{count}} sets jugados. Rango aún se está calculando...",
+ "looking.rankCalculating": "Menos de {{count}} sets jugados. El rango aún se está calculando...",
"looking.allTiers": "Todos los niveles",
"looking.joinQPrompt": "Únete a la fila para encontrar un grupo",
- "looking.joinQPromptTeam": "",
- "looking.joinQPromptMembers": "",
+ "looking.joinQPromptTeam": "Buscar un equipo",
+ "looking.joinQPromptMembers": "Buscar más miembros",
"looking.range.or": "o",
"looking.range.or.explanation": "Serás emparejado con un grupo cuyo rango promedio sea uno de estos. El rango exacto no se muestra para evitar que los grupos jueguen únicamente contra niveles inferiores al suyo.",
- "match.header": "Partido #{{number}}",
- "match.subtitle": "",
- "match.mapVoters.header": "",
- "match.spInfo": "Fuerza Sendou será ajustada despues de que ambos equipos informen el mismo resultado",
+ "match.header": "Set #{{number}}",
+ "match.subtitle": "SendouQ Temporada {{nth}}",
+ "match.mapVoters.header": "Votaron por este escenario",
+ "match.spInfo": "La Fuerza Sendou se ajustará después de que ambos equipos reporten el mismo resultado",
"match.dispute.button": "¿Disputar?",
"match.dispute.p1": "Si hay un error, contacta al otro equipo para que lo corrijan. El resultado puede ser informado libremente hasta que ambos equipos informen el mismo resultado.",
"match.dispute.p2": "Si hay un problema comunicandote con el otro equipo, contacta a un mod en el 'helpdesk' del Discord de sendou.ink. Proporciona screenshots que demuestren el resultado correcto.",
@@ -116,19 +116,19 @@
"match.report.weaponLabel": "Arma",
"match.sides.alpha": "Alfa",
"match.sides.bravo": "Bravo",
- "match.groupAlpha": "",
- "match.groupBravo": "",
+ "match.groupAlpha": "Grupo Alpha",
+ "match.groupBravo": "Grupo Bravo",
"match.helpdesk": "Helpdesk",
"match.pool": "Grupo",
- "match.password.short": "Codigo",
- "match.cancelMatch": "Cancelar partido",
- "match.canceled": "Partido cancelado",
- "match.canceled.detail": "",
+ "match.password.short": "Código",
+ "match.cancelMatch": "Cancelar set",
+ "match.canceled": "Set cancelado",
+ "match.canceled.detail": "El set fue cancelado a petición de {{requester}} y aceptado por {{accepter}}",
"match.cancelRequested": "Cancelación pedida",
"match.reportedBy": "Informado por {{name}} a",
"match.cancelPendingConfirmation": "Esperando confirmación del otro equipo",
- "match.cancelMatch.explanation": "",
- "match.adminCancel.confirm": "",
+ "match.cancelMatch.explanation": "Cancelar el combate solo es posible si ambos equipos están de acuerdo. Abusar de esta función conllevará un ban.",
+ "match.adminCancel.confirm": "¿Cancelar este combate como admin?",
"match.tabs.reportScore": "Informar resultado",
"match.errors.cantCancel": "No se puede cancelar ya que el oponente ha informado el resultado para este partido. Ver instrucciones para disputar al inicio de la página.",
"match.errors.different": "Informaste resultados diferentes a los de tu oponente. Revisa que la información es correcta, o ve las instrucciones para disputar al inicio de la página.",
@@ -140,72 +140,72 @@
"match.won": "{{side}} ganó",
"match.reporting": "Informando {{score}} {{outcome}}",
"match.outcome.win": "victoria",
- "match.outcome.loss": "perdida",
+ "match.outcome.loss": "pérdida",
"match.screen.ban": "Armas con {{special}} son prohibidas para este partido",
"match.screen.allowed": "Armas con {{special}} se permiten para este partido",
- "match.subbedOut": "",
- "match.action.selectWinner": "",
- "match.action.myTeam": "",
- "match.action.opponent": "",
- "match.action.ko": "",
- "match.action.confirmSetEnding": "",
- "match.action.requestCancel": "",
- "match.action.adminCancel": "",
- "match.action.acceptCancelingSet": "",
- "match.action.pickStage": "",
- "match.action.banStage": "",
- "match.action.pickMode": "",
- "match.action.banMode": "",
- "match.action.pickerUs": "",
- "match.action.pickerThem": "",
- "match.action.pickerBoth": "",
- "match.action.pickBanPrompt": "",
- "match.action.pickBanWaiting": "",
- "match.action.picking": "",
- "match.action.banning": "",
- "match.cancelRequested.subtitle": "",
- "match.timeline.win": "",
- "match.timeline.loss": "",
- "match.timeline.out": "",
- "match.timeline.in": "",
- "match.timeline.ongoing": "",
- "match.timeline.picked": "",
- "match.timeline.explainer.picked": "",
- "match.timeline.explainer.pick": "",
- "match.timeline.explainer.ban": "",
- "match.timeline.explainer.substitution": "",
- "match.timeline.explainer.spChange": "",
- "match.waitingForConfirmation": "",
- "match.undoReport": "",
- "match.weapon.yourWeapon": "",
- "match.weapon.undoWeapon": "",
- "match.confirmScore": "",
- "match.confirmScore.wrongHint": "",
- "match.rematch.prompt": "",
- "match.rematch.resolved": "",
- "match.rematch.vote.yes": "",
- "match.rematch.vote.no": "",
- "match.rematch.vote.noConfirm": "",
- "match.rematch.declined": "",
- "match.rematch.fizzled": "",
- "match.rematch.waitingCaptain": "",
- "match.rematch.rejoinQueue": "",
- "match.rematch.backToQueue": "",
- "match.rematch.offSeason": "",
- "match.banner.final": "",
- "match.banner.bestOf": "",
- "match.banner.playAll": "",
- "match.banner.vs": "",
- "match.tabs.rosters": "",
- "match.tabs.action": "",
- "match.tabs.result": "",
- "match.tabs.stats": "",
+ "match.subbedOut": "Sustituido",
+ "match.action.selectWinner": "Selecciona el ganador",
+ "match.action.myTeam": "Mi equipo",
+ "match.action.opponent": "Oponente",
+ "match.action.ko": "Pleno",
+ "match.action.confirmSetEnding": "Este resultado finalizará el set. Por favor, confírmalo abajo.",
+ "match.action.requestCancel": "Solicitar cancelación",
+ "match.action.adminCancel": "Cancelación de admin",
+ "match.action.acceptCancelingSet": "¿Aceptar cancelar el set?",
+ "match.action.pickStage": "Elegir un escenario",
+ "match.action.banStage": "Banear un escenario",
+ "match.action.pickMode": "Elegir un modo",
+ "match.action.banMode": "Banear un modo",
+ "match.action.pickerUs": "Nosotros",
+ "match.action.pickerThem": "Ellos",
+ "match.action.pickerBoth": "Ambos",
+ "match.action.pickBanPrompt": "Haz tu selección arriba",
+ "match.action.pickBanWaiting": "Esperando a que el capitán de {{teamName}} haga su selección",
+ "match.action.picking": "Eligiendo",
+ "match.action.banning": "Baneando",
+ "match.cancelRequested.subtitle": "{{teamName}} ha solicitado cancelar el set",
+ "match.timeline.win": "Victoria",
+ "match.timeline.loss": "Derrota",
+ "match.timeline.out": "Fuera",
+ "match.timeline.in": "Dentro",
+ "match.timeline.ongoing": "EN CURSO",
+ "match.timeline.picked": "Elegido",
+ "match.timeline.explainer.picked": "Mapa elegido por este equipo",
+ "match.timeline.explainer.pick": "Mapa o modo elegido",
+ "match.timeline.explainer.ban": "Mapa o modo baneado",
+ "match.timeline.explainer.substitution": "Sustitución de jugador",
+ "match.timeline.explainer.spChange": "Actualizaciones de SP",
+ "match.waitingForConfirmation": "Esperando a que el otro equipo confirme el resultado",
+ "match.undoReport": "Deshacer reporte",
+ "match.weapon.yourWeapon": "Tu arma",
+ "match.weapon.undoWeapon": "Deshacer arma",
+ "match.confirmScore": "Confirmar resultado",
+ "match.confirmScore.wrongHint": "¿Resultado incorrecto? Pide al otro equipo que deshaga su reporte y lo ajuste.",
+ "match.rematch.prompt": "¿Continuar en la cola con el grupo de {{count}}?",
+ "match.rematch.resolved": "Nuevo grupo de {{count}} formado",
+ "match.rematch.vote.yes": "Sí, continuar",
+ "match.rematch.vote.no": "No, he terminado",
+ "match.rematch.vote.noConfirm": "¿Votar no? No podrás cambiar tu voto después.",
+ "match.rematch.declined": "Rechazaste continuar",
+ "match.rematch.fizzled": "Nadie quiso continuar",
+ "match.rematch.waitingCaptain": "Esperando a que el capitán decida si volver a la cola",
+ "match.rematch.rejoinQueue": "Volver a la cola",
+ "match.rematch.backToQueue": "Volver a la cola",
+ "match.rematch.offSeason": "La temporada ha terminado. La cola volverá a abrir cuando empiece la siguiente temporada.",
+ "match.banner.final": "Final",
+ "match.banner.bestOf": "Al mejor de {{count}}",
+ "match.banner.playAll": "Jugar los {{count}}",
+ "match.banner.vs": "vs.",
+ "match.tabs.rosters": "Plantillas",
+ "match.tabs.action": "Acción",
+ "match.tabs.result": "Resultado",
+ "match.tabs.stats": "Estadísticas",
"preparing.joinQ": "Unirte a la fila",
"tiers.currentCriteria": "Criterios actuales",
"tiers.info.p1": "Por ejemplo, Leviathan se encuentra entre el 5% de los mejores jugadores. Diamond es el percentil 85, etc.",
"tiers.info.p2": "NOTA: Nadie tiene rango Leviathan antes de tener al menos {{usersMin}} jugadores en las tablas (o al menos {{teamsMin}} para equipos)",
"tiers.info.p3": "Cada rango también tiene un nivel plus (ver BRONCE+ de ejemplo). Significa que estás en el 50% superior de ese rango.",
"streams.noStreams": "No hay streams de partidos recientes",
- "streams.ownStreamInfo": "¿Falta tu stream? Asegura que tu cuenta de Twitch esté conectada y que tu juego es Splatoon 3.",
- "streams.ownStreamInfo.linkText": "Ver el FAQ para más información como sobre conectar tu cuenta de Twitch."
+ "streams.ownStreamInfo": "¿Falta tu stream? Asegúrate de que tu cuenta de Twitch esté conectada y el juego configurado en Splatoon 3.",
+ "streams.ownStreamInfo.linkText": "Consulta las Preguntas frecuentes para más información sobre cómo conectar tu cuenta de Twitch."
}
diff --git a/locales/es-ES/scrims.json b/locales/es-ES/scrims.json
index 61832f906..afba148f0 100644
--- a/locales/es-ES/scrims.json
+++ b/locales/es-ES/scrims.json
@@ -31,15 +31,15 @@
"actions.viewRequest": "Petición pendiente...",
"actions.contact": "Contactar",
"deleteModal.title": "¿Eliminar la publicación del scrim?",
- "cancelRequestModal.title": "",
- "cancelRequestModal.requester": "",
+ "cancelRequestModal.title": "¿Cancelar la solicitud?",
+ "cancelRequestModal.requester": "Solicitante",
"cancelModal.scrim.title": "¿Cancelar el scrim?",
"cancelModal.scrim.reasonLabel": "Motivo de la cancelación",
"cancelModal.scrim.reasonExplanation": "Explica por qué cancelas el scrim. Esto será visible para el otro equipo.",
"acceptModal.title": "¿Aceptar la petición de scrim de {{groupName}} y rechazar las demás (si las hay)?",
"acceptModal.prevented": "Pide a la persona que publicó el scrim que acepte esta petición",
"acceptModal.confirmFor": "Confirmar para: {{time}}",
- "autoCancelInfo": "",
+ "autoCancelInfo": "Una vez se reserva una scrim, las publicaciones y solicitudes con una diferencia de ±1 hora que compartan jugadores se eliminan automáticamente para evitar reservas dobles.",
"postModal.footer": "Publicación creada a las {{time}}",
"forms.title": "Creando una nueva publicación de scrim",
"forms.with.title": "Con",
@@ -60,7 +60,7 @@
"forms.text.title": "Texto",
"forms.visibility.title": "Visibilidad",
"forms.visibility.public": "Pública",
- "forms.visibility.friends": "",
+ "forms.visibility.friends": "Solo amigos",
"forms.visibility.noneAvailable": "No hay asociaciones disponibles. Crea una para buscar un scrim en un grupo más reducido.",
"forms.notFoundVisibility.title": "Si no se encuentra antes de",
"forms.notFoundVisibility.explanation": "Déjalo en blanco si no quieres que la visibilidad de tu publicación cambie con el tiempo",
@@ -73,7 +73,7 @@
"forms.maps.allModes": "Todos los modos",
"forms.maps.tournament": "Torneo...",
"page.scheduledScrim": "Scrim programado",
- "page.vs": "",
+ "page.vs": "vs. {{opponent}}",
"associations.title": "Asociaciones",
"associations.explanation": "Crea una asociación para buscar en un grupo más pequeño (por ejemplo, con los oponentes habituales de tus prácticas o la división LUTI).",
"associations.join.title": "¿Unirse a la asociación {{name}}?",
@@ -88,33 +88,33 @@
"associations.forms.name.title": "Nombre",
"forms.managedByAnyone.title": "Cualquiera puede gestionar",
"forms.managedByAnyone.explanation": "Si está activado, todos los usuarios en esta publicación pueden aceptar peticiones y eliminar la publicación, no solo el creador.",
- "banner.canceled.header": "",
- "banner.canceled.subtitle": "",
- "banner.freeForm.header": "",
- "banner.freeForm.subtitle": "",
- "mapByMap.nonParticipantNotice": "",
- "mapByMap.noCurrentMap": "",
- "mapByMap.undo": "",
- "mapByMap.replay": "",
- "mapByMap.pick": "",
- "mapByMap.pickDialog.heading": "",
- "mapByMap.removeList": "",
- "mapByMap.removeListConfirm": "",
- "mapByMap.submitListHeading": "",
- "mapByMap.noListYet": "",
- "mapByMap.manageMapLists": "",
- "mapByMap.poolList": "",
- "mapByMap.result.replayTag": "",
- "mapByMap.stats.empty": "",
- "mapByMap.stats.restrictToPool": "",
- "mapByMap.stats.byMode": "",
- "mapByMap.stats.byStage": "",
- "mapByMap.stats.byStageMode": "",
- "mapByMap.stats.view.MODE": "",
- "mapByMap.stats.view.STAGE": "",
- "mapByMap.stats.view.BOTH": "",
- "mapByMap.stats.col.label": "",
- "mapByMap.stats.col.wins": "",
- "mapByMap.stats.col.losses": "",
- "mapByMap.stats.col.winPct": ""
+ "banner.canceled.header": "Cancelado por {{user}}",
+ "banner.canceled.subtitle": "Motivo: {{reason}}",
+ "banner.freeForm.header": "Práctica libre",
+ "banner.freeForm.subtitle": "Establece una lista de mapas para empezar a seleccionar mapas (opcional)",
+ "mapByMap.nonParticipantNotice": "Solo los participantes pueden gestionar el seguimiento de mapas.",
+ "mapByMap.noCurrentMap": "Esperando a que se genere el siguiente mapa.",
+ "mapByMap.undo": "Deshacer",
+ "mapByMap.replay": "Repetición",
+ "mapByMap.pick": "Elegir",
+ "mapByMap.pickDialog.heading": "Elegir mapa",
+ "mapByMap.removeList": "Eliminar lista",
+ "mapByMap.removeListConfirm": "¿Eliminar tu lista de mapas?",
+ "mapByMap.submitListHeading": "Enviar tu lista de mapas",
+ "mapByMap.noListYet": "No enviada todavía",
+ "mapByMap.manageMapLists": "Gestionar listas de mapas",
+ "mapByMap.poolList": "Grupo ({{count}} mapas)",
+ "mapByMap.result.replayTag": "Repetición del mapa {{index}}",
+ "mapByMap.stats.empty": "Aún no hay mapas reportados",
+ "mapByMap.stats.restrictToPool": "Restringir a mi lista enviada",
+ "mapByMap.stats.byMode": "Por modo",
+ "mapByMap.stats.byStage": "Por escenario",
+ "mapByMap.stats.byStageMode": "Por escenario y modo",
+ "mapByMap.stats.view.MODE": "Modo",
+ "mapByMap.stats.view.STAGE": "Escenario",
+ "mapByMap.stats.view.BOTH": "Escenario y Modo",
+ "mapByMap.stats.col.label": "Mapa",
+ "mapByMap.stats.col.wins": "Victorias",
+ "mapByMap.stats.col.losses": "Derrotas",
+ "mapByMap.stats.col.winPct": "% Victorias"
}
diff --git a/locales/es-ES/settings.json b/locales/es-ES/settings.json
index 3cd15389f..05f51fd12 100644
--- a/locales/es-ES/settings.json
+++ b/locales/es-ES/settings.json
@@ -1,18 +1,18 @@
{
- "tabs.preferences": "",
- "tabs.matchProfile": "",
- "tabs.locale": "",
- "tabs.theme": "",
+ "tabs.preferences": "Preferencias",
+ "tabs.matchProfile": "Perfil de partida",
+ "tabs.locale": "Idioma",
+ "tabs.theme": "Tema",
"tabs.sounds": "Sonidos",
- "matchProfile.maps.header": "Mapas y modos",
- "matchProfile.maps.personal": "",
- "matchProfile.maps.preferencesFor": "",
- "matchProfile.maps.teamExplanation": "",
+ "matchProfile.maps.header": "Escenarios y modos",
+ "matchProfile.maps.personal": "Personal",
+ "matchProfile.maps.preferencesFor": "Preferencias para",
+ "matchProfile.maps.teamExplanation": "La lista de mapas del equipo se usa para todos los miembros al entrar en cola como equipo",
"matchProfile.maps.avoid": "Evitar",
"matchProfile.maps.prefer": "Preferir",
"matchProfile.maps.neutral": "Neutral",
"matchProfile.weaponPool.header": "Grupo de armas",
- "matchProfile.weaponPool.full": "Grupo de armas está lleno",
+ "matchProfile.weaponPool.full": "El grupo de armas está lleno",
"matchProfile.voiceChat.header": "Chat de voz",
"matchProfile.voiceChat.canVC.header": "¿Se puede usar chat de voz?",
"matchProfile.voiceChat.canVC.yes": "Sí",
@@ -21,8 +21,8 @@
"matchProfile.voiceChat.languages.header": "Tus idiomas",
"matchProfile.voiceChat.languages.placeholder": "Elegir los que correspondan",
"matchProfile.mapPool.notOk": "Elige {{count}} mapas por modo que no evitaste para guardar tus preferencias",
- "sounds.likeReceived": "",
- "sounds.groupNewMember": "",
- "sounds.matchStarted": "",
- "sounds.tournamentMatchStarted": "Partido de torneo comenzado"
+ "sounds.likeReceived": "Invitación de grupo recibida",
+ "sounds.groupNewMember": "Invitación de grupo aceptada",
+ "sounds.matchStarted": "Partida de SendouQ iniciada",
+ "sounds.tournamentMatchStarted": "Set de torneo iniciado"
}
diff --git a/locales/es-ES/team.json b/locales/es-ES/team.json
index 334908c03..c8d455df4 100644
--- a/locales/es-ES/team.json
+++ b/locales/es-ES/team.json
@@ -1,23 +1,23 @@
{
"newTeam.header": "Creando nuevo equipo",
- "editTeam.header": "",
+ "editTeam.header": "Editando {{teamName}}",
"teamSearch.placeholder": "Buscar un equipo o jugador...",
"actionButtons.leaveTeam": "Abandonar equipo",
"actionButtons.makeMainTeam": "Hacer equipo principal",
- "actionButtons.mainTeam": "",
- "actionButtons.teamActions": "",
+ "actionButtons.mainTeam": "Equipo principal",
+ "actionButtons.teamActions": "Acciones de equipo",
"leaveTeam.header": "¿Seguro que quieres abandonar {{teamName}}?",
"leaveTeam.header.newOwner": "¿Seguro que quieres abandonar {{teamName}}? El nuevo propietario será {{newOwner}}",
"actionButtons.leaveTeam.confirm": "Abandonar",
"actionButtons.editTeam": "Editar Equipo",
- "actionButtons.manageRoster": "",
+ "actionButtons.manageRoster": "Gestionar miembros",
"actionButtons.deleteTeam": "Eliminar Equipo",
"actionButtons.deleteTeam.profilePicture": "Eliminar foto de perfil",
"actionButtons.deleteTeam.banner": "Eliminar banner",
"actionButtons.kick": "Echar",
"kick.header": "¿Echar a {{user}} de {{teamName}}?",
- "actionButtons.transferOwnership": "Transferir Custodia",
- "transferOwnership.header": "¿Transferir custodia de {{teamName}} a {{user}}?",
+ "actionButtons.transferOwnership": "Transferir propiedad",
+ "transferOwnership.header": "¿Transferir la propiedad de {{teamName}} a {{user}}?",
"actionButtons.transferOwnership.confirm": "Transferir",
"deleteTeam.header": "¿Estás seguro que quieres eliminar a {{teamName}}?",
"deleteTeam.profilePicture.header": "¿Seguro que quieres eliminar la foto de perfil del equipo?",
@@ -45,12 +45,12 @@
"forms.info.tag": "Normalmente se usa antes del nombre en el juego para indicar pertenencia a un equipo (ej. [TAG] NombreJugador)",
"forms.errors.duplicateName": "Ya existe un equipo con ese nombre",
"forms.errors.noOnlySpecialCharacters": "El nombre del equipo no puede ser solo caracteres especiales",
- "forms.customTheme.header": "",
+ "forms.customTheme.header": "Tema personalizado",
"roster.teamFull": "El equipo está lleno",
"roster.inviteLink.header": "Comparte el link de invitación para agregar más miembros",
"roster.members.header": "Miembros",
- "roster.sections.players": "",
- "roster.sections.other": "",
+ "roster.sections.players": "Plantilla",
+ "roster.sections.other": "Otros",
"validation.SHORT_CODE": "El código de invitación no tiene la longitud correcta. ¿Copiaste la URL completa?",
"validation.TEAM_FULL": "El equipo al que te intentas unir ya está lleno.",
"validation.INVITE_CODE_WRONG": "El código de invitación es incorrecto.",
diff --git a/locales/es-ES/tier-list-maker.json b/locales/es-ES/tier-list-maker.json
index f90a79497..7fd749aee 100644
--- a/locales/es-ES/tier-list-maker.json
+++ b/locales/es-ES/tier-list-maker.json
@@ -6,19 +6,19 @@
"stages": "Escenarios",
"modes": "Modos",
"stageModes": "Escenario + Modos",
- "abilities": "",
+ "abilities": "Potenciadores",
"dropItems": "Suelta los elementos aquí",
- "clickToAdd": "",
- "placementModeTrack": "",
- "placementModeClick": "",
+ "clickToAdd": "Haz clic en los elementos para añadirlos aquí",
+ "placementModeTrack": "Arrastrar y soltar",
+ "placementModeClick": "Hacer clic para colocar",
"editingTier": "Editando tier",
"hideAltKits": "Ocultar kits alternativos",
"hideAltSkins": "Ocultar skins alternativas",
"resetConfirmation": "¿Seguro que quieres reiniciar la tier list? Esto eliminará todos los elementos y restaurará las tiers por defecto.",
- "noDuplicates": "",
+ "noDuplicates": "Sin duplicados",
"showTierHeaders": "Mostrar encabezados de las tiers",
- "title": "",
- "showUsername": "",
+ "title": "Título",
+ "showUsername": "Mostrar nombre de usuario",
"by": "Creado por",
"custom": "Personalizado"
}
diff --git a/locales/es-ES/tournament.json b/locales/es-ES/tournament.json
index 08186e7f1..cafa6d337 100644
--- a/locales/es-ES/tournament.json
+++ b/locales/es-ES/tournament.json
@@ -1,54 +1,54 @@
{
- "nav.label": "",
- "nav.moreItems": "",
+ "nav.label": "Navegación del torneo",
+ "nav.moreItems": "Más",
"nav.brackets": "Cuadros de Torneo",
- "nav.register": "",
+ "nav.register": "Inscripción",
"nav.teams": "Equipos ({{count}})",
"nav.streams": "Streams ({{count}})",
"nav.results": "Resultados",
- "nav.rules": "",
- "nav.looking": "",
+ "nav.rules": "Reglas",
+ "nav.looking": "Busco equipo",
"nav.subs": "Subs",
- "nav.divisions": "",
+ "nav.divisions": "Divisiones",
"nav.admin": "Admin",
- "findTeam": "",
- "registerNow": "",
- "fact.format": "",
- "fact.bracket": "",
- "fact.modes": "",
- "fact.tier": "",
- "fact.tier.est": "",
- "fact.ranked": "",
- "fact.ranked.yes": "",
- "fact.ranked.yesWithSeason": "",
- "fact.ranked.no": "",
- "fact.teamSize": "",
+ "findTeam": "Buscar equipo",
+ "registerNow": "Inscríbete ahora",
+ "fact.format": "Formato",
+ "fact.bracket": "Bracket",
+ "fact.modes": "Modos",
+ "fact.tier": "Tier",
+ "fact.tier.est": "Tier est.",
+ "fact.ranked": "Competitivo",
+ "fact.ranked.yes": "Sí",
+ "fact.ranked.yesWithSeason": "Sí (T{{season}})",
+ "fact.ranked.no": "No",
+ "fact.teamSize": "Tamaño del equipo",
"pre.steps.header": "Completa estos pasos para jugar",
"pre.steps.name": "Nombre de equipo",
"pre.steps.roster": "Equipo lleno",
"pre.steps.pool": "Grupo de mapas",
"pre.steps.check-in": "Check-in",
- "pre.footer": "Registro puede ser ajustado antes de que empieze el torneo",
- "pre.logIn": "Ingresa al sitio para registrar",
+ "pre.footer": "El registro puede ajustarse libremente antes de que empiece el torneo",
+ "pre.logIn": "Inicia sesión para inscribirte",
"pre.inATeam": "Estás en un equipo para este evento",
- "pre.captainOnlyEdit": "",
- "pre.registrationClosed": "",
+ "pre.captainOnlyEdit": "Estás en un equipo para este evento. Solo el capitán del equipo puede editar la inscripción.",
+ "pre.registrationClosed": "La inscripción para este torneo está cerrada",
"pre.checkIn.range": "El check-in está abierto entre {{start}} y {{finish}}",
- "pre.checkIn.over": "Se acabó check-in",
- "pre.checkIn.cant": "Completa los previos pasos antes de check-in",
+ "pre.checkIn.over": "Se acabó el check-in",
+ "pre.checkIn.cant": "Completa los pasos previos antes del check-in",
"pre.checkIn.button": "Check-in",
- "pre.checkIn.checkedIn": "Tu equipo completo check-in",
+ "pre.checkIn.checkedIn": "Tu equipo ha hecho el check-in",
"pre.info.header": "Info de equipo",
"pre.info.unregister": "Cancelar registro",
"pre.info.unregister.confirm": "¿Cancelar registro del torneo y borrar info del equipo?",
- "pre.info.noHost": "Mi equipo prefiere no ser a cargo de salas",
+ "pre.info.noHost": "Mi equipo prefiere no hostear salas",
"pre.roster.header": "Llenar equipo",
"pre.roster.footer": "Se requieren al menos {{atLeastCount}} miembros para participar. La cantidad máxima es {{maxCount}}",
"pre.roster.footer.noSubs": "El formato es {{format}}. No se permiten subs.",
- "pre.roster.addFriend.header": "",
+ "pre.roster.addFriend.header": "Añadir amigos",
"pre.roster.delete.button": "Borrar miembro",
"pre.roster.delete.header": "Miembro que quieres borrar",
- "pre.pool.header": "Escojer grupo de mapas",
+ "pre.pool.header": "Escoger grupo de mapas",
"pre.pool.banned": "Prohibidos",
"pre.pool.tiebreaker.short": "Desempate",
"bracket.type.DE_WINNERS": "Cuadro de ganadores",
@@ -63,53 +63,52 @@
"pickInfo.team": "Equipo {{number}} elige",
"pickInfo.team.specific": "{{team}} eligió",
"pickInfo.team.counterpick": "{{team}} hizo contraselección",
- "pickInfo.pickedBy": "",
- "pickInfo.counterpickedBy": "",
+ "pickInfo.pickedBy": "Elegido por {{teamName}}",
+ "pickInfo.counterpickedBy": "Contrarrestado por {{teamName}}",
"pickInfo.tiebreaker": "Desempate",
"pickInfo.both": "Ambos eligieron",
"pickInfo.default": "Elección de la comunidad",
"pickInfo.default.explanation": "No había un mapa adecuado en los grupos de los participantes. Este mapa fue seleccionado del conjunto de mapas populares.",
"pickInfo.votes_one": "{{count}} voto",
- "pickInfo.votes_many": "{{count}} votos",
"pickInfo.votes_other": "{{count}} votos",
- "pickInfo.teamMapList": "",
+ "pickInfo.teamMapList": "Lista de mapas de {{teamName}}",
"pickInfo.counterpick": "Contraselección",
- "pickInfo.roll": "",
+ "pickInfo.roll": "Aleatorio",
"generator.error": "Los cambios no fueron guardados ya que el torneo comenzó",
"teams.mapsPickedStatus": "Estado de mapas elegidos",
"admin.download": "Descarga participantes",
- "admin.tab.teams": "",
- "admin.tab.seeds": "Listas de Equipos",
- "admin.tab.staff": "",
- "admin.tab.stream": "",
- "admin.tab.brackets": "",
+ "admin.tab.teams": "Equipos",
+ "admin.tab.seeds": "Seeds",
+ "admin.tab.staff": "Staff",
+ "admin.tab.stream": "Stream",
+ "admin.tab.brackets": "Brackets",
"admin.tab.theme": "",
- "admin.tab.audit": "",
- "admin.audit.empty": "",
- "admin.audit.filter.event": "",
- "admin.audit.filter.team": "",
- "admin.audit.filter.allEvents": "",
- "admin.audit.filter.allTeams": "",
- "admin.audit.column.when": "",
- "admin.audit.column.event": "",
- "admin.audit.column.team": "",
- "admin.audit.column.actor": "",
- "admin.audit.column.subject": "",
- "admin.audit.event.MEMBER_ADDED": "",
- "admin.audit.event.MEMBER_REMOVED": "",
- "admin.audit.event.TEAM_REGISTERED": "",
- "admin.audit.event.TEAM_UNREGISTERED": "",
- "admin.audit.event.TEAM_CHECKED_IN": "",
- "admin.audit.event.TEAM_CHECKED_OUT": "",
- "admin.audit.event.TEAM_DROPPED_OUT": "",
- "admin.audit.event.TEAM_DROP_OUT_UNDONE": "",
- "admin.audit.event.UPDATE_IN_GAME_NAME": "",
+ "admin.tab.audit": "Registro de auditoría",
+ "admin.audit.empty": "No hay eventos aún",
+ "admin.audit.filter.event": "Evento",
+ "admin.audit.filter.team": "Equipo",
+ "admin.audit.filter.allEvents": "Todos los eventos",
+ "admin.audit.filter.allTeams": "Todos los equipos",
+ "admin.audit.column.when": "Cuándo",
+ "admin.audit.column.event": "Evento",
+ "admin.audit.column.team": "Equipo",
+ "admin.audit.column.actor": "Por",
+ "admin.audit.column.subject": "Jugador afectado",
+ "admin.audit.event.MEMBER_ADDED": "Jugador se unió al equipo",
+ "admin.audit.event.MEMBER_REMOVED": "Jugador dejó el equipo",
+ "admin.audit.event.TEAM_REGISTERED": "Equipo inscrito",
+ "admin.audit.event.TEAM_UNREGISTERED": "Inscripción de equipo cancelada",
+ "admin.audit.event.TEAM_CHECKED_IN": "Check-in del equipo",
+ "admin.audit.event.TEAM_CHECKED_OUT": "Check-out del equipo",
+ "admin.audit.event.TEAM_DROPPED_OUT": "El equipo se retiró",
+ "admin.audit.event.TEAM_DROP_OUT_UNDONE": "Retirada del equipo deshecha",
+ "admin.audit.event.UPDATE_IN_GAME_NAME": "Nombre en el juego cambiado",
"admin.actions.CHANGE_TEAM_OWNER": "Cambiar capitán",
"admin.actions.CHANGE_TEAM_NAME": "Cambiar nombre de equipo",
"admin.actions.CHECK_IN": "Check in",
"admin.actions.CHECK_OUT": "Check out",
"admin.actions.ADD_MEMBER": "Añadir miembro",
- "admin.actions.REMOVE_MEMBER": "Remover miembro",
+ "admin.actions.REMOVE_MEMBER": "Quitar miembro",
"admin.actions.DELETE_TEAM": "Borrar equipo",
"admin.actions.ADD_TEAM": "Registrar equipo",
"admin.actions.DROP_TEAM_OUT": "Retirar equipo",
@@ -118,46 +117,45 @@
"admin.actions.DELETE_LOGO": "Eliminar logo",
"staff.role.ORGANIZER": "organizador",
"staff.role.STREAMER": "streamer",
- "staff.author": "",
- "staff.organization": "",
- "staff.divider.fromOrganization": "",
- "staff.divider.addedForEvent": "",
- "staff.editOrganization": "",
+ "staff.author": "autor",
+ "staff.organization": "organización",
+ "staff.divider.fromOrganization": "De la organización",
+ "staff.divider.addedForEvent": "Para este evento",
+ "staff.editOrganization": "Editar organización",
"actions.addSub": "Añadir sub",
"actions.shareLink": "Comparte enlace de invitación para añadir miembros: {{inviteLink}}",
"actions.sub.prompt_one": "Aún puedes añadir {{count}} sub a tu equipo",
- "actions.sub.prompt_many": "Aún puedes añadir {{count}} subs a tu equipo",
"actions.sub.prompt_other": "Aún puedes añadir {{count}} subs a tu equipo",
"actions.sub.prompt_zero": "Tu equipo está lleno y no puedes añadir más subs",
"actions.finalize": "Finalizando torneo",
- "actions.finalize.button": "",
+ "actions.finalize.button": "Finalizar torneo",
"actions.finalize.action": "Finalizar",
"actions.finalize.action.withBadges": "Finalizar y asignar insignias",
"actions.finalize.info": "Esta acción no se puede deshacer. Asegúrate de que todos los resultados reportados son correctos antes de continuar.",
"actions.finalize.error.BADGE_NOT_ASSIGNED": "No todas las insignias han sido asignadas a equipos",
"actions.finalize.error.DUPLICATE_TOURNAMENT_TEAM_ID": "La misma insignia fue asignada a varios equipos",
"actions.finalize.error.BADGE_NOT_FOUND": "Insignia inesperada no encontrada",
- "actions.finalize.error.TROPHY_NOT_FOUND": "",
- "actions.finalize.error.TROPHY_NOT_ASSIGNED": "",
+ "actions.finalize.error.TROPHY_NOT_FOUND": "Trofeo inesperado no encontrado",
+ "actions.finalize.error.TROPHY_NOT_ASSIGNED": "El trofeo no tiene receptores seleccionados",
"actions.finalize.assignBadgesLater": "Asignar insignias manualmente más tarde",
"finalize.receivingTeam.label": "Equipo receptor",
"finalize.receivingTeam.placeholder": "Seleccionar equipo...",
"streams.none": "No hay streams disponibles para este torneo al momento",
- "run.sets": "",
- "run.maps": "",
- "run.qualifiedFor": "",
- "run.firstTitle": "",
- "run.latestTitle": "",
- "run.seriesTitles": "",
+ "run.sets": "Sets",
+ "run.maps": "Mapas",
+ "run.qualifiedFor": "Avanzó al {{bracket}}",
+ "run.firstTitle": "Primer título",
+ "run.latestTitle": "Último título",
+ "run.seriesTitles": "Títulos de la serie",
"team.setWins": "Victorias de sets",
"team.mapWins": "Victorias de mapas",
"team.seed": "Colocado",
"team.seed.footer": "de {{count}}",
"team.placement": "Colocación",
"team.placement.footer": "General/Cuadro",
- "bracket.waiting": "Cuadro se muestra aquí cuando al menos {{count}} equipos sean registrados",
- "bracket.waiting.checkin": "Cuadro se muestra aquí cuando al menos {{count}} equipos se hagan check-in",
- "bracket.waiting.advanced": "",
+ "bracket.waiting": "El cuadro se mostrará aquí cuando al menos {{count}} equipos se hayan inscrito",
+ "bracket.waiting.checkin": "El cuadro se mostrará aquí cuando al menos {{count}} equipos hayan hecho check-in",
+ "bracket.waiting.advanced": "El bracket se mostrará aquí cuando al menos {{count}} equipos hayan avanzado",
"bracket.wip": "Este cuadro es temporal y puede cambiar",
"bracket.progress.thanksForPlaying": "¡Gracias por participar en {{eventName}}!",
"bracket.progress.match": "Oponente actual: {{opponent}}",
@@ -170,50 +168,50 @@
"match.pool": "Grupo",
"match.score": "{{scoreOne}}-{{scoreTwo}} (Mejor de {{bestOf}})",
"match.score.playAll": "{{scoreOne}}-{{scoreTwo}} (Jugar todos los {{bestOf}})",
- "match.activeRosterMissing.header": "",
- "match.activeRosterMissing.subtitle": "",
- "match.droppedOut.header": "",
- "match.droppedOut.subtitle": "",
- "match.endedEarly.header": "",
- "match.endedEarly.subtitle": "",
- "match.leagueLocked.header": "",
- "match.leagueLocked.subtitle": "",
- "match.locked.header": "",
- "match.locked.subtitle": "",
- "match.waitingForTeams.header": "",
- "match.waitingForTeams.subtitle": "",
- "match.waitingForPrevious.header": "",
- "match.waitingForPrevious.subtitle": "",
- "match.tbd": "",
+ "match.activeRosterMissing.header": "Plantilla activa requerida",
+ "match.activeRosterMissing.subtitle": "Esperando a {{teams}}",
+ "match.droppedOut.header": "El equipo se retiró",
+ "match.droppedOut.subtitle": "{{team}} abandonó el set",
+ "match.endedEarly.header": "El set terminó antes de tiempo",
+ "match.endedEarly.subtitle": "El staff terminó el set antes de que se decidiera",
+ "match.leagueLocked.header": "Esperando a que empiece la ronda de la liga",
+ "match.leagueLocked.subtitle": "Ronda jugable a partir del {{date}}",
+ "match.locked.header": "Set bloqueado para ser casteado",
+ "match.locked.subtitle": "Por favor, espera a que el staff lo desbloquee",
+ "match.waitingForTeams.header": "Esperando a los equipos",
+ "match.waitingForTeams.subtitle": "Los equipos se decidirán en sets anteriores",
+ "match.waitingForPrevious.header": "Set anterior en curso",
+ "match.waitingForPrevious.subtitle": "El set se podrá reportar cuando ambos equipos estén listos para jugar",
+ "match.tbd": "Por determinar",
"match.action.undoLastScore": "Anular resultado previo",
- "match.action.reopenMatch": "Reabrir partido",
+ "match.action.reopenMatch": "Reabrir set",
"match.action.endSet": "Finalizar set",
"match.action.confirmEndSet": "Confirmar fin de set",
"match.endSet.selectWinner": "Seleccionar ganador",
"match.endSet.randomWinner": "Aleatorio (50/50)",
"match.deadline.explanation": "Informa a los organizadores del torneo sobre cualquier retraso. Los partidos que superen su límite de tiempo pueden terminarse anticipadamente. Consulta las reglas del torneo para más detalles.",
- "match.admin.cast": "",
- "match.admin.castInfo": "",
- "match.admin.castConfigureHint": "",
- "match.admin.notCasted": "",
- "match.admin.unlock": "",
- "match.admin.lockToBeCasted": "",
- "match.admin.lockingInfo": "",
- "match.admin.castChannelUpdated": "",
- "match.admin.editReportedScores": "",
- "match.admin.mapNumber": "",
- "match.admin.koSuffix": "",
+ "match.admin.cast": "Cast",
+ "match.admin.castInfo": "Selecciona la cuenta de Twitch que está casteando este set. Se indicará en la vista del bracket.",
+ "match.admin.castConfigureHint": "Configura los canales de stream en la página de administración del torneo para habilitar el casteo.",
+ "match.admin.notCasted": "No casteado",
+ "match.admin.unlock": "Desbloquear",
+ "match.admin.lockToBeCasted": "Bloquear para ser casteado",
+ "match.admin.lockingInfo": "Puedes bloquear el set para indicar que no debe empezar hasta que el cast esté listo. Bloquear el set impide reportar los resultados y oculta la lista de mapas hasta que el organizador o streamer lo desbloquee.",
+ "match.admin.castChannelUpdated": "Canal de cast actualizado",
+ "match.admin.editReportedScores": "Editar mapas",
+ "match.admin.mapNumber": "Mapa {{number}}",
+ "match.admin.koSuffix": "(Pleno)",
"join.error.MISSING_CODE": "Falta código de invitación. ¿Copiaste el enlace completo?",
- "join.error.SHORT_CODE": "Código de invitación es de cantidad incorrecata. ¿Copiaste el enlace completo?",
+ "join.error.SHORT_CODE": "El código de invitación no tiene la longitud correcta. ¿Copiaste el enlace completo?",
"join.error.NO_TEAM_MATCHING_CODE": "Ningún equipo coincide con el código de invitación.",
"join.error.TEAM_FULL": "El equipo al que quieres unirte está lleno.",
"join.error.ALREADY_JOINED": "Ya eres miembro de este equipo.",
- "join.error.NOT_LOGGED_IN": "Debes de ingresarte al sitio para unirte a un equipo.",
+ "join.error.NOT_LOGGED_IN": "Debes iniciar sesión para unirte a un equipo.",
"join.VALID": "¿Unirte a {{teamName}} para {{eventName}}?",
- "join.viewTeam": "",
- "join.alreadyInTeam": "",
- "join.viewRegistration": "",
- "join.friendSuggestion": "",
+ "join.viewTeam": "Ver tu equipo",
+ "join.alreadyInTeam": "Ya te has registrado en este torneo con otro equipo.",
+ "join.viewRegistration": "Ver inscripción",
+ "join.friendSuggestion": "Puedes añadir al capitán como amigo para que te añada directamente la próxima vez",
"subs.prefersToPlay": "Prefiere jugar",
"subs.canPlay": "Puede jugar",
"subs.canVC": "Puede usar chat de voz",
@@ -221,10 +219,10 @@
"subs.listenOnlyVC": "Solo escuchar",
"subs.editPost": "Editar anuncio de sub",
"subs.addPost": "Agrégate como un sub",
- "subs.noPosts": "",
+ "subs.noPosts": "No hay suplentes disponibles",
"subs.vc.header": "¿Puedes usar chat de voz?",
"subs.weapons.prefer.header": "Armas que prefieres jugar",
- "subs.weapons.ok.header": "Armas que podrías",
+ "subs.weapons.ok.header": "Armas con las que también podrías jugar",
"subs.weapons.info": "Elige entre {{min}} y {{max}}",
"subs.message.header": "Mensaje",
"subs.visibility.header": "Visibilidad",
@@ -236,50 +234,50 @@
"progression.error.SAME_PLACEMENT_TO_MULTIPLE_BRACKETS": "La misma clasificación lleva a varios cuadros",
"progression.error.GAP_IN_PLACEMENTS": "Hay un hueco en las clasificaciones que avanzan",
"progression.error.TOO_MANY_PLACEMENTS": "Demasiadas clasificaciones (más que equipos en grupos)",
- "progression.error.PLACEMENT_TOO_HIGH": "",
+ "progression.error.PLACEMENT_TOO_HIGH": "La clasificación es demasiado alta (máximo {{max}})",
"progression.error.DUPLICATE_BRACKET_NAME": "Nombre de cuadro duplicado",
"progression.error.NAME_MISSING": "Falta el nombre del cuadro",
"progression.error.NEGATIVE_PROGRESSION": "La progresión negativa solo es posible en eliminación doble",
- "progression.error.NO_SE_POSITIVE": "",
+ "progression.error.NO_SE_POSITIVE": "La eliminación directa no es válida para la progresión positiva",
"progression.error.NO_DE_POSITIVE": "La eliminación doble no es válida para progresión positiva",
"progression.error.SWISS_EARLY_ADVANCE_NO_DESTINATION": "El cuadro suizo con avance/eliminación anticipada debe llevar a otro cuadro",
- "progression.error.AB_DIVISIONS_NOT_ROUND_ROBIN": "",
- "progression.error.AB_DIVISIONS_NOT_STARTING": "",
- "progression.error.AB_DIVISIONS_ODD_TEAMS_PER_GROUP": "",
- "progression.error.EMPTY_PLACEMENTS_ON_NON_SWISS": "",
- "lfg.askCaptainToJoinQueue": "",
- "customFlow.beforeSet": "",
- "customFlow.afterMap": "",
- "customFlow.who": "",
- "customFlow.action": "",
- "customFlow.addStep": "",
- "customFlow.whoPlaceholder": "",
- "customFlow.actionPlaceholder": "",
- "customFlow.validation.stepMissingAction": "",
- "customFlow.validation.stepMissingWho": "",
- "customFlow.validation.lastStepMustBePickOrRoll": "",
- "customFlow.validation.winnerLoserInPreSet": "",
- "customFlow.validation.tooManyModePicks": "",
- "customFlow.validation.tooManyMapPicks": "",
- "customFlow.validation.sameTeamModeAndMapPick": "",
- "customFlow.who.RANDOM": "",
- "customFlow.who.RANDOM_OTHER": "",
- "customFlow.who.ALPHA": "",
- "customFlow.who.BRAVO": "",
- "customFlow.who.HIGHER_SEED": "",
- "customFlow.who.LOWER_SEED": "",
- "customFlow.who.WINNER": "",
- "customFlow.who.LOSER": "",
- "customFlow.action.ROLL": "",
- "customFlow.action.PICK": "",
- "customFlow.action.PICK_NO_MODE_REPEAT": "",
- "customFlow.action.BAN": "",
- "customFlow.action.MODE_PICK": "",
- "customFlow.action.MODE_BAN": "",
- "pickBan.counterpick": "",
- "pickBan.pickMap": "",
- "pickBan.banMap": "",
- "pickBan.pickMode": "",
- "pickBan.banMode": "",
- "pickBan.waitingFor": ""
+ "progression.error.AB_DIVISIONS_NOT_ROUND_ROBIN": "Las divisiones A/B solo se pueden activar en brackets de todos contra todos",
+ "progression.error.AB_DIVISIONS_NOT_STARTING": "Las divisiones A/B solo se pueden activar en brackets iniciales",
+ "progression.error.AB_DIVISIONS_ODD_TEAMS_PER_GROUP": "Las divisiones A/B requieren un número par de equipos por grupo",
+ "progression.error.EMPTY_PLACEMENTS_ON_NON_SWISS": "Las posiciones vacías solo son válidas cuando provienen de un bracket suizo con avance anticipado",
+ "lfg.askCaptainToJoinQueue": "Pide al capitán de tu equipo o a un manager que se una a la cola",
+ "customFlow.beforeSet": "Antes del set",
+ "customFlow.afterMap": "Después del mapa",
+ "customFlow.who": "Quién",
+ "customFlow.action": "Acción",
+ "customFlow.addStep": "Añadir paso",
+ "customFlow.whoPlaceholder": "¿Quién?",
+ "customFlow.actionPlaceholder": "¿Qué?",
+ "customFlow.validation.stepMissingAction": "Cada paso debe tener una acción",
+ "customFlow.validation.stepMissingWho": "Cada paso debe especificar quién realiza la acción",
+ "customFlow.validation.lastStepMustBePickOrRoll": "El último paso debe ser Elegir (Pick) o Sorteo (Roll) (para determinar el mapa)",
+ "customFlow.validation.winnerLoserInPreSet": "Ganador/Perdedor no se puede usar en los pasos de Antes del set",
+ "customFlow.validation.tooManyModePicks": "Como máximo una Elección de modo por sección",
+ "customFlow.validation.tooManyMapPicks": "Como máximo un Elegir o Sorteo por sección",
+ "customFlow.validation.sameTeamModeAndMapPick": "El mismo equipo no puede elegir tanto el modo como el mapa",
+ "customFlow.who.RANDOM": "Aleatorio",
+ "customFlow.who.RANDOM_OTHER": "Aleatorio (otro)",
+ "customFlow.who.ALPHA": "Equipo Alfa",
+ "customFlow.who.BRAVO": "Equipo Bravo",
+ "customFlow.who.HIGHER_SEED": "Seed más alto",
+ "customFlow.who.LOWER_SEED": "Seed más bajo",
+ "customFlow.who.WINNER": "Ganador",
+ "customFlow.who.LOSER": "Perdedor",
+ "customFlow.action.ROLL": "Mapa legal aleatorio",
+ "customFlow.action.PICK": "Elegir (mapa)",
+ "customFlow.action.PICK_NO_MODE_REPEAT": "Elegir (mapa - sin repetir modo)",
+ "customFlow.action.BAN": "Banear (mapa)",
+ "customFlow.action.MODE_PICK": "Elegir (modo)",
+ "customFlow.action.MODE_BAN": "Banear (modo)",
+ "pickBan.counterpick": "Contrarrestar",
+ "pickBan.pickMap": "Elige un mapa",
+ "pickBan.banMap": "Banea un mapa",
+ "pickBan.pickMode": "Elige un modo",
+ "pickBan.banMode": "Banea un modo",
+ "pickBan.waitingFor": "Esperando a {{teamName}}"
}
diff --git a/locales/es-ES/trophies.json b/locales/es-ES/trophies.json
index d8e86b2c5..beaa6557a 100644
--- a/locales/es-ES/trophies.json
+++ b/locales/es-ES/trophies.json
@@ -1,70 +1,70 @@
{
- "title": "",
- "lookingForBadges": "",
- "viewBadges": "",
- "details.createdBy": "",
- "details.managedBy": "",
- "details.organization": "",
- "details.owners": "",
- "details.noOwners": "",
- "details.tournamentHistory": "",
- "details.noTournamentHistory": "",
- "details.upcoming": "",
- "display.viewTrophyPage": "",
- "special.supporter.description": "",
- "special.xp.description": "",
- "new.form.creatorNotice": "",
- "new.form.limitReached": "",
- "new.form.preview.light": "",
- "new.form.preview.dark": "",
- "new.specs.required": "",
- "new.specs.recommended": "",
- "new.specs.cameraTarget": "",
- "new.specs.centered": "",
- "new.specs.zoom": "",
- "new.specs.angles": "",
- "new.specs.noStandaloneFlag": "",
- "new.specs.noTrademarked": "",
- "new.specs.background": "",
- "new.specs.drawCalls": "",
- "new.specs.polys": "",
- "new.specs.effects": "",
- "new.specs.currentValue": "",
- "new.specs.stats.drawCalls": "",
- "new.specs.stats.polys": "",
- "new.specs.stats.effects": "",
- "new.specs.stats.cameraTargetOff": "",
- "new.specs.stats.backgroundNotAlpha": "",
- "new.terms.title": "",
- "new.terms.intro": "",
- "new.terms.trustedOrg": "",
- "new.terms.oneOff.title": "",
- "new.terms.oneOff.pastTournaments": "",
- "new.terms.oneOff.projectedTeams": "",
- "new.terms.oneOff.signedUpTeams": "",
- "new.terms.series.title": "",
- "new.terms.series.consistentTeams": "",
- "new.terms.disclaimer": "",
- "new.terms.preApproval": "",
- "new.terms.agree": "",
- "new.tabs.upload": "",
- "new.tabs.update": "",
- "new.tabs.pending": "",
- "new.tabs.reviewed": "",
- "new.update.selectLabel": "",
- "new.update.searchPlaceholder": "",
- "new.update.editing": "",
- "new.update.before": "",
- "new.update.after": "",
- "new.pending.empty": "",
- "new.pending.notFromManager": "",
- "new.pending.approve": "",
- "new.pending.approved": "",
- "new.pending.approvalProgress": "",
- "new.pending.decline": "",
- "new.pending.declineHeading": "",
- "new.pending.declineReason": "",
- "new.pending.declined": "",
- "new.pending.declinedBy": "",
- "new.reviewed.empty": ""
+ "title": "Trofeos",
+ "lookingForBadges": "¿Buscas chapas?",
+ "viewBadges": "Míralas aquí",
+ "details.createdBy": "Creado por <1>{{name}}",
+ "details.managedBy": "Gestionado por <1>{{name}}",
+ "details.organization": "Organización: <1>{{name}}",
+ "details.owners": "Propietarios",
+ "details.noOwners": "Sin propietarios todavía",
+ "details.tournamentHistory": "Torneos",
+ "details.noTournamentHistory": "Sin historial de torneos",
+ "details.upcoming": "Próximos",
+ "display.viewTrophyPage": "Ver página del trofeo",
+ "special.supporter.description": "Otorgado por apoyar a sendou.ink",
+ "special.xp.description": "Otorgado por alcanzar {{value}} de Energía X",
+ "new.form.creatorNotice": "El usuario que sube un trofeo queda registrado como su creador. Esto no se puede cambiar. Si le encargaste un trofeo a alguien y quiere aparecer como su creador, tiene que subirlo esa persona.",
+ "new.form.limitReached": "Has alcanzado el límite de {{limit}} trofeos pendientes. Borra o espera a que se revise un envío existente antes de enviar otro.",
+ "new.form.preview.light": "Modo claro",
+ "new.form.preview.dark": "Modo oscuro",
+ "new.specs.required": "Obligatorio",
+ "new.specs.recommended": "Recomendado",
+ "new.specs.cameraTarget": "El objetivo de la cámara en X y Z debe ser 0",
+ "new.specs.centered": "El modelo debe estar visualmente centrado en todos los ejes",
+ "new.specs.zoom": "El zoom debe ajustarse para que el modelo ocupe la vista lo máximo posible sin tocar los bordes",
+ "new.specs.angles": "El modelo debe poder verse desde todos los ángulos",
+ "new.specs.noStandaloneFlag": "El modelo no puede ser una bandera independiente",
+ "new.specs.noTrademarked": "No muestres material registrado (con derechos de autor)",
+ "new.specs.background": "El color de fondo debe ser el color alfa",
+ "new.specs.drawCalls": "Máximo {{value}} llamadas de dibujado",
+ "new.specs.polys": "Máximo {{value}} polígonos",
+ "new.specs.effects": "Máximo {{value}} efectos",
+ "new.specs.currentValue": "(actualmente {{value}})",
+ "new.specs.stats.drawCalls": "{{value}} llamadas de dibujado",
+ "new.specs.stats.polys": "{{value}} polígonos",
+ "new.specs.stats.effects": "{{value}} efectos",
+ "new.specs.stats.cameraTargetOff": "Objetivo de cámara no centrado",
+ "new.specs.stats.backgroundNotAlpha": "El fondo no es del color alfa",
+ "new.terms.title": "¡Atención! ¡Lee las condiciones antes de crear o encargar un modelo de trofeo!",
+ "new.terms.intro": "Debes cumplir AL MENOS una de las siguientes condiciones para que tu trofeo sea aceptado:",
+ "new.terms.trustedOrg": "Está organizado por una organización consolidada",
+ "new.terms.oneOff.title": "Si el trofeo es para un torneo único:",
+ "new.terms.oneOff.pastTournaments": "Haber organizado torneos en el pasado con 24 equipos o más",
+ "new.terms.oneOff.projectedTeams": "Se prevé tener al menos 24 equipos apuntados para el torneo",
+ "new.terms.oneOff.signedUpTeams": "Ya tiene 24 equipos o más apuntados para el torneo",
+ "new.terms.series.title": "Si el trofeo es para una serie de torneos:",
+ "new.terms.series.consistentTeams": "Tener de forma regular 24 equipos o más apuntados",
+ "new.terms.disclaimer": "¡Cumplir al menos una condición no significa automáticamente que se acepte el trofeo!",
+ "new.terms.preApproval": "Si no tienes claro si tu torneo cumple los requisitos, no dudes en conseguir una preaprobación creando una solicitud en el <1>servidor de Discord.",
+ "new.terms.agree": "He leído y acepto",
+ "new.tabs.upload": "Subir",
+ "new.tabs.update": "Actualizar",
+ "new.tabs.pending": "Pendientes",
+ "new.tabs.reviewed": "Revisados",
+ "new.update.selectLabel": "Trofeo a actualizar",
+ "new.update.searchPlaceholder": "Buscar trofeos",
+ "new.update.editing": "Editando trofeo existente",
+ "new.update.before": "Antes",
+ "new.update.after": "Después",
+ "new.pending.empty": "No hay trofeos pendientes",
+ "new.pending.notFromManager": "No ha sido enviado por el gestor del trofeo",
+ "new.pending.approve": "Aprobar",
+ "new.pending.approved": "Aprobado",
+ "new.pending.approvalProgress": "{{current}}/{{required}} aprobaciones",
+ "new.pending.decline": "Rechazar",
+ "new.pending.declineHeading": "Rechazar trofeo",
+ "new.pending.declineReason": "Razón",
+ "new.pending.declined": "Rechazado",
+ "new.pending.declinedBy": "Rechazado por {{name}}",
+ "new.reviewed.empty": "No hay trofeos revisados"
}
diff --git a/locales/es-ES/user.json b/locales/es-ES/user.json
index f935de997..11ad4770c 100644
--- a/locales/es-ES/user.json
+++ b/locales/es-ES/user.json
@@ -3,7 +3,7 @@
"ign.short": "IGN",
"widget.bio": "Biografía",
"widget.bio-md": "Biografía",
- "widget.trophies-owned": "",
+ "widget.trophies-owned": "Trofeos",
"widget.badges-owned": "Insignias",
"widget.badges-authored": "Insignias creadas",
"widget.badges-managed": "Insignias gestionadas",
@@ -18,7 +18,7 @@
"widget.highlighted-results": "Resultados de torneos",
"widget.placement-results": "Clasificaciones en torneos",
"widget.patron-since": "Mecenas desde",
- "widget.join-date": "",
+ "widget.join-date": "Miembro n.º",
"widget.timezone": "Hora actual del usuario",
"widget.favorite-stage": "Escenario favorito",
"widget.videos": "Vídeos",
@@ -34,7 +34,7 @@
"widget.top-500-weapons-dualies": "Top 500 Difusores",
"widget.top-500-weapons-brellas": "Top 500 Paratintas",
"widget.top-500-weapons-stringers": "Top 500 Arcos",
- "widget.top-500-weapons-splatanas": "Top 500 Azotintadores",
+ "widget.top-500-weapons-splatanas": "Top 500 Azotadores",
"widget.x-rank-peaks": "Picos de Rango X por modo",
"widget.builds": "Builds",
"widget.weapon-pool": "Grupo de armas",
@@ -43,9 +43,9 @@
"widget.commissions": "Comisiones",
"widget.social-links": "Enlaces sociales verificados",
"widget.links": "Enlaces",
- "widget.game-badges": "",
- "widget.game-badges-small": "",
- "widget.friends": "",
+ "widget.game-badges": "Chapas del juego",
+ "widget.game-badges-small": "Chapas del juego",
+ "widget.friends": "Amigos",
"widget.tier-list": "Tier List destacada",
"widget.link.all": "Todos",
"widgets.edit": "Editar widgets",
@@ -61,7 +61,7 @@
"widgets.maxReached": "Límite máximo de widgets alcanzado",
"widgets.search": "Buscar widgets...",
"widgets.category.misc": "Miscelánea",
- "widgets.category.trophies": "",
+ "widgets.category.trophies": "Trofeos",
"widgets.category.badges": "Insignias",
"widgets.category.teams": "Equipos",
"widgets.category.sendouq": "SendouQ",
@@ -70,11 +70,11 @@
"widgets.category.vods": "Vídeos",
"widgets.category.builds": "Builds",
"widgets.category.art": "Arte",
- "widgets.category.friends": "",
- "widgets.category.game-badges": "",
+ "widgets.category.friends": "Amigos",
+ "widgets.category.game-badges": "Chapas del juego",
"widgets.description.bio": "Comparte información libre sobre ti",
"widgets.description.bio-md": "Comparte información libre sobre ti usando formato Markdown",
- "widgets.description.trophies-owned": "",
+ "widgets.description.trophies-owned": "Muestra los trofeos que has ganado",
"widgets.description.badges-owned": "Muestra las insignias que has conseguido",
"widgets.description.badges-authored": "Muestra las insignias que has creado",
"widgets.description.badges-managed": "Muestra las insignias que gestionas",
@@ -89,7 +89,7 @@
"widgets.description.highlighted-results": "Muestra tus resultados de torneos (resaltados)",
"widgets.description.placement-results": "Muestra tus clasificaciones en torneos por 1º, 2º y 3º lugar",
"widgets.description.patron-since": "Muestra la fecha desde la que eres mecenas",
- "widgets.description.join-date": "",
+ "widgets.description.join-date": "Muestra tu número de miembro de sendou.ink",
"widgets.description.timezone": "Muestra tu hora local actual",
"widgets.description.favorite-stage": "Muestra tu escenario favorito",
"widgets.description.videos": "Muestra tus 3 vídeos más recientes",
@@ -114,9 +114,9 @@
"widgets.description.commissions": "Muestra el estado y los detalles de tus comisiones",
"widgets.description.social-links": "Muestra los enlaces de tus redes sociales conectados a través de Discord",
"widgets.description.links": "Comparte tus enlaces personalizados de webs y redes sociales",
- "widgets.description.game-badges": "",
- "widgets.description.game-badges-small": "",
- "widgets.description.friends": "",
+ "widgets.description.game-badges": "Muestra hasta {{max}} chapas del juego en tu perfil",
+ "widgets.description.game-badges-small": "Muestra hasta {{max}} chapas del juego en tu perfil",
+ "widgets.description.friends": "Muestra tu lista de amigos",
"widgets.description.tier-list": "Muestra una Tier List que hayas creado",
"widgets.forms.bio": "Biografía",
"widgets.forms.bio.markdownSupport": "Compatible con Markdown",
@@ -133,8 +133,8 @@
"widgets.forms.source.MADE-BY": "Hecho por mí",
"widgets.forms.source.MADE-OF": "Hecho sobre mí",
"widgets.forms.links": "Enlaces",
- "widgets.forms.gameBadges": "",
- "widgets.forms.gameBadgesSearch": "",
+ "widgets.forms.gameBadges": "Chapas",
+ "widgets.forms.gameBadgesSearch": "Buscar chapas por nombre...",
"widgets.forms.tierListUrl": "URL de la Tier List",
"widget.tier-list.untitled": "Tier List sin título",
"controllers.s1-pro-con": "Mando Pro de Switch 1",
@@ -161,7 +161,7 @@
"results.highlights.explanation": "Elige los resultados que quieres resaltar",
"results.button.showHighlights": "Mostrar resaltados",
"results.button.showAll": "Mostrar todos",
- "results.filter.placeholder": "",
+ "results.filter.placeholder": "Filtrar por torneo",
"forms.errors.maxWeapons": "Máxima cantidad de armas",
"search.info": "Busca usuarios por su nombre de Discord o de Splatoon 3",
"search.noResults": "No se encontraron usuarios que coincidan con '{{query}}'",
@@ -170,7 +170,7 @@
"seasons": "Temporadas",
"seasons.noQ": "Este usuario no ha jugado a SendouQ esta temporada",
"seasons.noSeasons": "Este usuario no ha participado en ninguna temporada",
- "seasons.tabs.sets": "",
+ "seasons.tabs.sets": "Sets",
"seasons.tabs.weapons": "Armas",
"seasons.tabs.stages": "Mapas",
"seasons.tabs.self": "Personal",
@@ -180,35 +180,33 @@
"seasons.season.short": "T",
"seasons.win.short": "W",
"seasons.loss.short": "L",
- "seasons.tentative": "Tentative",
- "seasons.tentative.explanation": "La tabla de posición tiene cantidad baja de entrantes. En cuanto suficientes de jugadores obtengan sus resultados, los niveles de rango se calcularán. Para la mayoría de jugadores, su nivel baja. Fuerza Sendou no es afectada por esto.",
+ "seasons.tentative": "Provisional",
+ "seasons.tentative.explanation": "La tabla de clasificación tiene pocas entradas. Una vez que suficientes jugadores terminen sus cálculos, los niveles de rango se recalcularán. Para la mayoría de jugadores esto significará que su nivel baje. El SP siempre se mantiene igual.",
"seasons.peak": "Punto más alto",
"seasons.noReportedWeapons": "No se han informado armas",
"seasons.clickARow": "Haga clic en una fila para ver estadísticas de armas",
"seasons.loading": "Cargando...",
- "seasons.summary.sets": "",
- "seasons.summary.maps": "",
- "seasons.summary.winStreak": "",
- "seasons.summary.soloRank": "",
- "seasons.summary.teamRank": "",
- "seasons.summary.activity": "",
- "seasons.summary.activity.tournament": "",
- "seasons.summary.activity.both": "",
- "seasons.summary.bestStage": "",
- "seasons.summary.topWeapons": "",
- "seasons.summary.topMates": "",
- "seasons.summary.clutch": "",
- "seasons.summary.bestWins": "",
- "seasons.summary.bestTournament": "",
- "seasons.summary.opponentSp": "",
- "seasons.summary.count.sets_one": "",
- "seasons.summary.count.sets_many": "",
- "seasons.summary.count.sets_other": "",
- "seasons.summary.count.maps_one": "",
- "seasons.summary.count.maps_many": "",
- "seasons.summary.count.maps_other": "",
- "seasons.summary.export": "",
- "seasons.summary.export.supporterPerk": "",
+ "seasons.summary.sets": "Sets",
+ "seasons.summary.maps": "Mapas",
+ "seasons.summary.winStreak": "Mejor racha de victorias",
+ "seasons.summary.soloRank": "Rango solitario",
+ "seasons.summary.teamRank": "Rango de equipo",
+ "seasons.summary.activity": "Actividad",
+ "seasons.summary.activity.tournament": "Torneo",
+ "seasons.summary.activity.both": "Ambos",
+ "seasons.summary.bestStage": "Mejor escenario",
+ "seasons.summary.topWeapons": "Mejores armas",
+ "seasons.summary.topMates": "Mejores compañeros",
+ "seasons.summary.clutch": "Clutch",
+ "seasons.summary.bestWins": "Mejores victorias",
+ "seasons.summary.bestTournament": "Mejor torneo",
+ "seasons.summary.opponentSp": "Sendou Power rival",
+ "seasons.summary.count.sets_one": "{{count}} set",
+ "seasons.summary.count.sets_other": "{{count}} sets",
+ "seasons.summary.count.maps_one": "{{count}} mapa",
+ "seasons.summary.count.maps_other": "{{count}} mapas",
+ "seasons.summary.export": "Exportar imagen",
+ "seasons.summary.export.supporterPerk": "Exportar la imagen del resumen de esta temporada es una ventaja de supporter. Todos pueden exportar la imagen de la última temporada finalizada durante la pretemporada (off-season).",
"builds.sorting.changeButton": "Cambiar orden",
"builds.sorting.header": "Cambiar orden de las builds",
"builds.sorting.backToDefaults": "Volver por defecto",
@@ -226,23 +224,22 @@
"builds.sorting.PRIVATE_BUILD": "Builds privadas",
"commissions.open": "Abiertas",
"commissions.closed": "Cerradas",
- "mutualFriends": "",
- "mutualFriends.count_one": "",
- "mutualFriends.count_many": "",
- "mutualFriends.count_other": "",
- "card.viewUserPage": "",
- "card.sendFriendRequest": "",
- "card.friendRequestPending": "",
- "card.friendRequestSent": "",
- "card.friendRequestAccepted": "",
- "card.editPrivateNote": "",
- "card.report.header": "",
- "card.report.falseReportsWarning": "",
- "card.privateNote": "",
- "card.xp": "",
- "card.freeAgent": "",
- "card.noMutualFriends": "",
- "card.edit.title": "",
- "card.edit.bannerColor": "",
- "card.edit.supporterOnlyBanner": ""
+ "mutualFriends": "Amigos en común",
+ "mutualFriends.count_one": "amigo en común",
+ "mutualFriends.count_other": "amigos en común",
+ "card.viewUserPage": "Ver página de usuario",
+ "card.sendFriendRequest": "Enviar solicitud de amistad",
+ "card.friendRequestPending": "Solicitud de amistad pendiente",
+ "card.friendRequestSent": "Solicitud de amistad enviada",
+ "card.friendRequestAccepted": "Solicitud de amistad aceptada",
+ "card.editPrivateNote": "Editar nota privada",
+ "card.report.header": "Reportar a {{name}}",
+ "card.report.falseReportsWarning": "Abusar del sistema de reportes, incluyendo hacer reportes falsos, puede llevar a la suspensión de tu cuenta.",
+ "card.privateNote": "Nota privada",
+ "card.xp": "XP",
+ "card.freeAgent": "FA",
+ "card.noMutualFriends": "Sin amigos en común",
+ "card.edit.title": "Editar tarjeta de usuario",
+ "card.edit.bannerColor": "Color del banner",
+ "card.edit.supporterOnlyBanner": "Subir una imagen de banner es una función exclusiva para supporters."
}
diff --git a/locales/es-ES/vods.json b/locales/es-ES/vods.json
index e6747eda9..17a344fba 100644
--- a/locales/es-ES/vods.json
+++ b/locales/es-ES/vods.json
@@ -16,7 +16,7 @@
"forms.title.pov": "Jugador (punto de vista)",
"forms.title.startTimestamp": "Tiempo de comienzo",
"forms.title.mode": "Modo",
- "forms.title.stage": "Mapa",
+ "forms.title.stage": "Escenario",
"forms.title.weaponsTeamOne": "Armas (Equipo 1)",
"forms.title.weaponsTeamTwo": "Armas (Equipo 2)",
"forms.title.weapon": "Arma",
@@ -33,10 +33,10 @@
"gainPerms": "Por favor envía un mensaje en el 'helpdesk' de nuestro Discord para obtener permiso para subir videos.",
"deleteConfirm": "¿Borrar el vídeo con el título '{{title}}'?",
"errors.youtubePreviewFailed": "Error al cargar la vista previa de YouTube",
- "copyTimestamps": "",
- "copyTimestamps.help": "",
- "copyTimestamps.modeFormat": "",
- "copyTimestamps.stageFormat": "",
- "copyTimestamps.format.short": "",
- "copyTimestamps.format.long": ""
+ "copyTimestamps": "Copiar marcas de tiempo",
+ "copyTimestamps.help": "Pégalas en la descripción de tu vídeo de YouTube para crear marcadores de capítulos.",
+ "copyTimestamps.modeFormat": "Formato de modo",
+ "copyTimestamps.stageFormat": "Formato de escenario",
+ "copyTimestamps.format.short": "Corto",
+ "copyTimestamps.format.long": "Largo"
}
diff --git a/locales/es-ES/welcome.json b/locales/es-ES/welcome.json
index 68ba5f1bc..70bd56e54 100644
--- a/locales/es-ES/welcome.json
+++ b/locales/es-ES/welcome.json
@@ -1,27 +1,27 @@
{
- "title": "",
- "photoCredit": "",
- "whatDoINeed.header": "",
- "whatDoINeed.body": "",
- "motionControls.header": "",
- "motionControls.body": "",
- "weapons.header": "",
- "weapons.body": "",
- "builds.header": "",
- "builds.body": "",
- "mapsModes.header": "",
- "mapsModes.body": "",
- "findingTeam.header": "",
- "findingTeam.body": "",
- "noTeam.header": "",
- "noTeam.body": "",
- "haveTeam.header": "",
- "haveTeam.body": "",
- "ranks.header": "",
- "ranks.body": "",
- "divs.header": "",
- "divs.body": "",
- "plusServer.header": "",
- "plusServer.body": "",
- "pills.tiers": ""
+ "title": "Introducción al Splatoon competitivo y a sendou.ink",
+ "photoCredit": "Foto de Dio",
+ "whatDoINeed.header": "¿Qué necesito?",
+ "whatDoINeed.body": "No necesitas un nivel de habilidad específico para unirte a la comunidad. Hay gente de todos los niveles en la comunidad. Por lo general, puedes esperar jugar sobre todo contra personas en el Combate X incluso en los torneos de nivel inferior, pero ni siquiera eso es un requisito. Puede ser más divertido mejorar en grupo.\n\nEn la práctica necesitarás una cuenta de Discord, ya que mucha de la comunicación dentro de los equipos y torneos se realiza ahí. También puedes usar una cuenta de Discord para iniciar sesión en sendou.ink.\n\nPara el chat de voz, los jugadores normalmente usan Discord. En cuanto a la configuración, puedes buscar más información en internet, pero algunas personas pueden usar un divisor de audio que te permite escuchar tanto el audio del juego como el chat de voz con los mismos auriculares. Una configuración más sencilla podría ser usar los auriculares de tu teléfono, por ejemplo, y usar altavoces para el audio del juego.\n\nTambién deberías invertir en un cable ethernet. Una conexión a internet estable hace que el juego sea más agradable para ti y para los que juegan contra ti.",
+ "motionControls.header": "¿Debería usar los controles de movimiento?",
+ "motionControls.body": "En resumen, si puedes, sí. Esto es algo único de Splatoon, pero todos los jugadores de alto nivel y nivel superior, prácticamente sin excepción, usan controles de movimiento. Los controles de palanca difieren de la mayoría de los demás shooters de consola en que no hay asistencia de apuntado. En la práctica, usarlos significa que estás en desventaja.",
+ "weapons.header": "¿Cómo elegir qué armas jugar?",
+ "weapons.body": "Si acabas de empezar, no es necesario que te preocupes demasiado por qué arma es popular en el metajuego actual. Esto es algo que cambia rápidamente de un parche a otro y normalmente solo empieza a importar en el nivel de juego muy alto. En su lugar, elige un arma que te guste jugar para mejorar con ella. Luego, considera complementarla con otras 1 o 2 armas alternativas que sean diferentes a ella (en el set o alcance, por ejemplo). Esto te facilitará encajar en la composición del equipo sin importar lo que estén jugando tus compañeros.",
+ "builds.header": "¿Cómo hacer una buena build?",
+ "builds.body": "Optimizar las builds al máximo (min-maxing) puede ser divertido, pero es importante darse cuenta de que lo bien que lo hagas en las partidas lo decide de forma abrumadora tu habilidad más que la build exacta que estés usando. La única regla que realmente necesitas recordar es el rendimiento decreciente (diminishing returns), lo que significa que el primer potenciador secundario de cualquier habilidad dada será el más efectivo y cuanto más acumules, menor efecto verás. Por eso, normalmente mezclar al menos un par de habilidades diferentes será la build más fuerte. Dicho esto, en lugar de reinventar la rueda, puedes simplemente comprobar lo que usan los jugadores experimentados en la lista de >>builds<<.\n\nSi eres de los que les gusta optimizar todo hasta el último potenciador, asegúrate de echar un vistazo a >>analyzer<< y a >>object-damage-calculator<< para aprender exactamente qué hace cada habilidad.",
+ "mapsModes.header": "¿Qué escenarios/modos se juegan en competitivo?",
+ "mapsModes.body": "Esto dependerá totalmente del torneo. Antes de apuntarte a un torneo en sendou.ink podrás ver los escenarios y modos que tiene el torneo. Para niveles de juego más altos y algunos torneos abiertos (Open), el modo Pintazonas en exclusiva es muy popular. Combate territorial es menos popular en el competitivo que otros modos, pero también hay torneos que lo incluyen. En particular, Koshien en Japón, que es uno de los torneos más prestigiosos, es solo de Combate territorial.",
+ "findingTeam.header": "¿Cómo puedo encontrar un equipo?",
+ "findingTeam.body": "¡Echa un vistazo a las publicaciones en >>lfg<< o deja la tuya!",
+ "noTeam.header": "Aún no tengo equipo, ¿puedo jugar de todas formas?",
+ "noTeam.body": "Con equipo o sin equipo, la práctica en solitario es crucial para mejorar. Incluso los mejores jugadores han invertido una cantidad significativa de horas practicando en solitario en rango (Combate X). A veces también verás que la gente usa su pico de Energía X (XP) como indicador de habilidad. Como jugador nuevo, uno de tus objetivos principales debería ser alcanzar el Combate X y luego mejorar tu rango. Uno de los errores es desesperarse por lo que están haciendo tus compañeros en cualquier partida. No caigas en esto, ya que no es algo en lo que puedas influir y los mejores jugadores pueden darle la vuelta incluso a las partidas que parecen más imposibles de ganar. Para las divisiones (Divs), Tentatek puede estar bien al empezar, pero verás que la mayoría de los jugadores competitivos eligen la Takoroka, lo cual es algo a tener en cuenta.\n\nSendouQ es una extensión del modo solitario dentro del juego. Te permite hacer cola solo o con 1-3 de tus amigos. Existe una solución integrada para formar un equipo al momento. Cuando te apuntes solo, prepárate para que tome algo de tiempo. Normalmente, querrás por ejemplo jugar en solitario de fondo e ir revisando cómo va la formación del equipo entre partidas. Recuerda también establecer tu perfil completo de jugador en la página de >>settings<<.\n\nNo necesitas un equipo para empezar a jugar en torneos. Echa un vistazo al >>calendar<< y usa los filtros para encontrar torneos que tengan formato 1vs1 o formato \"draft\". 1vs1 no es el formato competitivo típico (ese sería 4vs4) pero es una buena manera de empezar. En los torneos draft, el organizador forma los equipos a partir de los registros individuales. Incluso si el torneo no tiene registros en solitario como tal, puedes usar la función LFG para indicar que estás buscando equipo para el evento. El proceso real funciona de manera similar a la formación de equipos de SendouQ.\n\n¡Una buena forma de mejorar también es observar y estudiar a buenos jugadores que usan las mismas armas que tú! La función >>vods<< es una manera de descubrirlos.",
+ "haveTeam.header": "Tengo un equipo, ¿qué deberíamos hacer?",
+ "haveTeam.body": "¡Nunca es demasiado pronto para participar en algunos torneos! En el >>calendar<< puedes filtrar por la etiqueta de límite de nivel (\"Skill cap\") para encontrar torneos dirigidos específicamente a equipos más nuevos. Dicho esto, no te cortes en probar algunos torneos de nivel abierto (Open) también. Es una buena manera de evitar crear malos hábitos en torno a estrategias que no funcionarán contra equipos de nivel más alto.\n\nFuera de los torneos, la verdad es que >>sendouq<< se experimenta mejor con un equipo ya formado. Puede darte esa presión parecida a la de un torneo de un set \"al mejor de\" mientras practicas una lista de escenarios específica, quizás para alguno de tus próximos torneos.\n\nLas >>scrims<< son otra gran opción. Aunque aquí se soporta el seguimiento de la lista de mapas, no se trata realmente de \"ganar o perder\". En su lugar, estás intentando aprender en un entorno donde puedes repetir escenarios y jugar un periodo prolongado de tiempo contra el mismo oponente. Las scrims se pueden programar, lo que te da una mejor oportunidad de encontrar un oponente adecuado que simplemente depender de encontrar uno al momento.",
+ "ranks.header": "¿Qué son los rangos en sendou.ink? (Leviathan/Diamond/Platinum…)",
+ "ranks.body": "Juega SendouQ y torneos puntuables para participar en las temporadas competitivas de sendou.ink. Una vez que hayas jugado al menos siete sets, se calculará y mostrará tu rango. ¡Luego puedes intentar subirlo antes de que acabe la temporada! Los rangos siempre se basan estrictamente en percentiles, por lo que, por ejemplo, \"Leviathan\" es siempre el 5% superior de los jugadores que participaron en la temporada. Ve todos los rangos en la página de >>tiers<<.",
+ "divs.header": "¿Qué son las \"divs\"?",
+ "divs.body": "Las divs o divisiones están relacionadas con >>luti<< (Leagues Under The Ink), que es la liga más grande de Splatoon. Históricamente se ha organizado una o dos veces al año. Por razones históricas, a veces la gente las usa como indicador del nivel de habilidad de un jugador. Así que, si alguien dice que es \"Div 2\", eso significaría que su nivel de habilidad es superior a \"Div 4\". La forma real de conseguir una Div es participar en LUTI (en la que deberías participar porque es un evento muy especial, no solo por conseguir una div), pero la gente también las calcula de forma aproximada.",
+ "plusServer.header": "¿Qué es el \"Plus Server\" (+1/+2/+3)?",
+ "plusServer.body": "Originalmente un servidor LFG para jugadores de alto y máximo nivel. Hay una votación una vez por temporada donde cada miembro existente vota a todos los de ese tier así como todas las sugerencias de esa vez. También puedes conseguir la membresía logrando un rango lo suficientemente alto en una temporada. Tienes los detalles exactos en la página de >>faq<<.",
+ "pills.tiers": "Tiers"
}
diff --git a/migrations/20260805155023-pending-trophy-accepted-at.ts b/migrations/20260805155023-pending-trophy-accepted-at.ts
new file mode 100644
index 000000000..3bd081079
--- /dev/null
+++ b/migrations/20260805155023-pending-trophy-accepted-at.ts
@@ -0,0 +1,114 @@
+import { type Kysely, sql } from "kysely";
+
+const duplicateMapping = sql`
+ select
+ dup."id" as "dupId",
+ (
+ select min(kept."id")
+ from "Trophy" kept
+ where kept."code" is null
+ and kept."name" = dup."name"
+ and kept."creatorId" is dup."creatorId"
+ ) as "keepId"
+ from "Trophy" dup
+ where dup."code" is null
+ and exists (
+ select 1
+ from "Trophy" kept
+ where kept."code" is null
+ and kept."name" = dup."name"
+ and kept."creatorId" is dup."creatorId"
+ and kept."id" < dup."id"
+ )
+`;
+
+/**
+ * Persists trophy submission acceptance instead of deriving it from the approval
+ * count, so that raising TROPHY_APPROVALS_REQUIRED cannot put already accepted
+ * submissions back into the review queue. Also deletes duplicate trophies that
+ * re-approving an already accepted submission created, keeping the oldest one.
+ */
+export async function up(db: Kysely): Promise {
+ // kysely does not wrap sqlite migrations in a transaction, so do it here
+ await db.transaction().execute(async (trx) => {
+ await trx.schema
+ .alterTable("PendingTrophy")
+ .addColumn("acceptedAt", "integer")
+ .execute();
+
+ // Repoint references at duplicates to the kept trophy before deleting, so
+ // the on-delete cascades cannot destroy owner rows or pending submissions.
+ // A duplicate is a user-submitted trophy sharing name and creator with an
+ // older one, which the review flow cannot legitimately produce.
+ await sql`
+ update "TrophyOwner"
+ set "trophyId" = m."keepId"
+ from (${duplicateMapping}) m
+ where "TrophyOwner"."trophyId" = m."dupId"
+ and not exists (
+ select 1
+ from "TrophyOwner" existing
+ where existing."tournamentId" = "TrophyOwner"."tournamentId"
+ and existing."userId" = "TrophyOwner"."userId"
+ and existing."trophyId" = m."keepId"
+ )
+ `.execute(trx);
+
+ await sql`
+ update "CalendarEvent"
+ set "trophyId" = m."keepId"
+ from (${duplicateMapping}) m
+ where "CalendarEvent"."trophyId" = m."dupId"
+ `.execute(trx);
+
+ await sql`
+ update "PendingTrophy"
+ set "targetTrophyId" = m."keepId"
+ from (${duplicateMapping}) m
+ where "PendingTrophy"."targetTrophyId" = m."dupId"
+ `.execute(trx);
+
+ await sql`
+ delete from "Trophy"
+ where "id" in (select "dupId" from (${duplicateMapping}))
+ `.execute(trx);
+
+ // Backfill submissions accepted under the old threshold of 2 approvals.
+ // A row only counts as accepted if its trophy was actually created.
+ await sql`
+ update "PendingTrophy"
+ set "acceptedAt" = (
+ select max("createdAt")
+ from "PendingTrophyApproval"
+ where "PendingTrophyApproval"."pendingTrophyId" = "PendingTrophy"."id"
+ )
+ where "declinedAt" is null
+ and (
+ select count(*)
+ from "PendingTrophyApproval"
+ where "PendingTrophyApproval"."pendingTrophyId" = "PendingTrophy"."id"
+ ) >= 2
+ and (
+ (
+ "targetTrophyId" is null
+ and exists (
+ select 1
+ from "Trophy"
+ where "Trophy"."name" = "PendingTrophy"."name"
+ and "Trophy"."creatorId" = "PendingTrophy"."submitterUserId"
+ )
+ )
+ or (
+ "targetTrophyId" is not null
+ and exists (
+ select 1
+ from "Trophy"
+ where "Trophy"."id" = "PendingTrophy"."targetTrophyId"
+ and "Trophy"."name" = "PendingTrophy"."name"
+ and "Trophy"."model" = "PendingTrophy"."model"
+ )
+ )
+ )
+ `.execute(trx);
+ });
+}
diff --git a/package.json b/package.json
index 337925b0b..7a6d09cfa 100644
--- a/package.json
+++ b/package.json
@@ -40,8 +40,8 @@
"knip": "knip"
},
"dependencies": {
- "@aws-sdk/client-s3": "3.1095.0",
- "@aws-sdk/lib-storage": "3.1095.0",
+ "@aws-sdk/client-s3": "3.1096.0",
+ "@aws-sdk/lib-storage": "3.1096.0",
"@date-fns/tz": "1.5.0",
"@dnd-kit/core": "6.3.1",
"@dnd-kit/modifiers": "9.0.0",
@@ -76,7 +76,7 @@
"p-limit": "7.3.1",
"pako": "^3.0.1",
"partysocket": "1.3.0",
- "picocad2-web": "^1.3.0",
+ "picocad2-web": "1.4.0-beta.1",
"qrcode.react": "4.2.0",
"react": "19.2.8",
"react-aria-components": "1.19.0",
@@ -102,7 +102,7 @@
"@biomejs/biome": "2.5.5",
"@playwright/test": "1.62.0",
"@react-router/dev": "8.3.0",
- "@types/node": "26.1.1",
+ "@types/node": "26.1.2",
"@types/nprogress": "0.2.3",
"@types/react": "19.2.17",
"@types/react-dom": "19.2.3",
@@ -113,7 +113,7 @@
"cross-env": "10.1.0",
"i18next-locales-sync": "2.1.1",
"knip": "6.29.0",
- "magic-string": "0.30.21",
+ "magic-string": "1.1.0",
"sql-formatter": "15.8.2",
"typescript": "7.0.2",
"vite": "8.1.5",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index ff49dcd77..0dab7d949 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -13,11 +13,11 @@ importers:
.:
dependencies:
'@aws-sdk/client-s3':
- specifier: 3.1095.0
- version: 3.1095.0
+ specifier: 3.1096.0
+ version: 3.1096.0
'@aws-sdk/lib-storage':
- specifier: 3.1095.0
- version: 3.1095.0(@aws-sdk/client-s3@3.1095.0)
+ specifier: 3.1096.0
+ version: 3.1096.0(@aws-sdk/client-s3@3.1096.0)
'@date-fns/tz':
specifier: 1.5.0
version: 1.5.0
@@ -121,8 +121,8 @@ importers:
specifier: 1.3.0
version: 1.3.0(react@19.2.8)
picocad2-web:
- specifier: ^1.3.0
- version: 1.3.0
+ specifier: 1.4.0-beta.1
+ version: 1.4.0-beta.1
qrcode.react:
specifier: 4.2.0
version: 4.2.0(react@19.2.8)
@@ -192,10 +192,10 @@ importers:
version: 1.62.0
'@react-router/dev':
specifier: 8.3.0
- version: 8.3.0(@react-router/serve@8.1.0(patch_hash=4d79b209948d4237f1ca3a5cca417c6d11519d8b1ab7084c75c46a39e3ac27d6)(react-router@8.3.0(react-dom@19.2.8(react@19.2.8))(react@19.2.8))(typescript@7.0.2))(react-router@8.3.0(react-dom@19.2.8(react@19.2.8))(react@19.2.8))(typescript@7.0.2)(vite@8.1.5(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0))
+ version: 8.3.0(@react-router/serve@8.1.0(patch_hash=4d79b209948d4237f1ca3a5cca417c6d11519d8b1ab7084c75c46a39e3ac27d6)(react-router@8.3.0(react-dom@19.2.8(react@19.2.8))(react@19.2.8))(typescript@7.0.2))(react-router@8.3.0(react-dom@19.2.8(react@19.2.8))(react@19.2.8))(typescript@7.0.2)(vite@8.1.5(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0))
'@types/node':
- specifier: 26.1.1
- version: 26.1.1
+ specifier: 26.1.2
+ version: 26.1.2
'@types/nprogress':
specifier: 0.2.3
version: 0.2.3
@@ -210,7 +210,7 @@ importers:
version: 3.6.4
'@vitest/browser-playwright':
specifier: 4.1.10
- version: 4.1.10(playwright@1.62.0)(vite@8.1.5(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0))(vitest@4.1.10)
+ version: 4.1.10(playwright@1.62.0)(vite@8.1.5(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0))(vitest@4.1.10)
'@vitest/ui':
specifier: 4.1.10
version: 4.1.10(vitest@4.1.10)
@@ -227,8 +227,8 @@ importers:
specifier: 6.29.0
version: 6.29.0
magic-string:
- specifier: 0.30.21
- version: 0.30.21
+ specifier: 1.1.0
+ version: 1.1.0
sql-formatter:
specifier: 15.8.2
version: 15.8.2
@@ -237,16 +237,16 @@ importers:
version: 7.0.2
vite:
specifier: 8.1.5
- version: 8.1.5(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0)
+ version: 8.1.5(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0)
vite-node:
specifier: 6.0.0
- version: 6.0.0(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0)
+ version: 6.0.0(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0)
vite-plugin-babel:
specifier: 1.7.3
- version: 1.7.3(@babel/core@7.29.7)(vite@8.1.5(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0))
+ version: 1.7.3(@babel/core@7.29.7)(vite@8.1.5(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0))
vitest:
specifier: 4.1.10
- version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.1)(@vitest/browser-playwright@4.1.10)(@vitest/ui@4.1.10)(vite@8.1.5(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0))
+ version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.2)(@vitest/browser-playwright@4.1.10)(@vitest/ui@4.1.10)(vite@8.1.5(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0))
vitest-browser-react:
specifier: 2.2.0
version: 2.2.0(@types/react-dom@19.2.3(@types/react@19.2.17))(@types/react@19.2.17)(react-dom@19.2.8(react@19.2.8))(react@19.2.8)(vitest@4.1.10)
@@ -264,70 +264,73 @@ packages:
'@apm-js-collab/tracing-hooks@0.13.0':
resolution: {integrity: sha512-mTvWz9rnQwx1U3h0XPTHaX7bgfkpipLLTQyjlC2cdhQpQEuoLT0AGzoydeoq2NxfEVv6fWOOETcSbb2nptleyw==}
- '@aws-sdk/checksums@3.1000.24':
- resolution: {integrity: sha512-7TWLjypP8kk3savsDBRuhZJx7mBuFFA2136BQhwwLllsAnO4Tmq/p+SXZaNxbuulkzUFz3BZzj0bb4YzexZcNQ==}
+ '@aws-sdk/checksums@3.1000.25':
+ resolution: {integrity: sha512-zUjEceMw6vhAxMayAlF/vkkKqP9gHbENqvz11t4FbfDlxB/WtW/Az1orJAQ00Pc/yORLQJXKE24w11Ktu/XBcg==}
engines: {node: '>=20.0.0'}
- '@aws-sdk/client-s3@3.1095.0':
- resolution: {integrity: sha512-eeobm3TKci47CTTHIxc5s5UDjLL0gTKfjlcyzKU+NMoeIJ3flKPq51Fhi2nUDiMNbzsY5HAynM3bHAQFHxRTUw==}
+ '@aws-sdk/client-s3@3.1096.0':
+ resolution: {integrity: sha512-sEx7KAEtkp1UqOoWQv2baM1rreClZG7o9YE8EfPvYpPBvGad1fQRG3sMHrOPMkIdZ9VjGRl25GiaG1MSeie2Mw==}
engines: {node: '>=20.0.0'}
- '@aws-sdk/core@3.977.4':
- resolution: {integrity: sha512-CEkcQlMOQJCvul60U7wdAOACjtdgFWDsfJI+6wUOGdhGNV2lGbuJpi/R50QLpFG3Tp+sQxa/RmzC3X7KHbhuTA==}
+ '@aws-sdk/core@3.977.5':
+ resolution: {integrity: sha512-O5otOc1c6UZh5HsHAaPdYBcUUR9HL6mtnKqvc8nxN/CKDGUBUpsdh0q8K04Uz/dd1i0TaGyIQuQNqoO7+ad2TQ==}
+ engines: {node: '>=20.0.0'}
+ deprecated: |-
+ Deprecated due to Document number parsing bug in JSON, see
+ https://github.com/aws/aws-sdk-js-v3/issues/8246. Newer version available.
+
+ '@aws-sdk/credential-provider-env@3.972.66':
+ resolution: {integrity: sha512-bOzP2+zdJ0XrghywB4FaJXtGZCx9yS0AGps+VJ5yEgg30wVyHNmVDBwVDXcRypzQY5iLGCS3NSn0nsuISqjFCQ==}
engines: {node: '>=20.0.0'}
- '@aws-sdk/credential-provider-env@3.972.65':
- resolution: {integrity: sha512-lJT2aRw9wCV8jPHyFJjdZLD4HTydL6/22AnCSOB8e/LqOc55nEJGLHkJQeSxhn8QiqyjFwPKQFtMw0ovjRUY/g==}
+ '@aws-sdk/credential-provider-http@3.972.68':
+ resolution: {integrity: sha512-lkunS8X+H6V76WE+t/uGQm/U8v0JXK5mLfNFTUAMlE1kqaCjwlmqKJrgCVtqjK/vqnlrSWsLK4Lr4NANBWlfTQ==}
engines: {node: '>=20.0.0'}
- '@aws-sdk/credential-provider-http@3.972.67':
- resolution: {integrity: sha512-N7fw/15hSwI/CPxe5ohOyb7O4ge9f5me1gVIn8OIkBRB0squ8OJqQyDyH/HoL+Sb1W5xdC88jVC+bHkw73iu+Q==}
+ '@aws-sdk/credential-provider-ini@3.973.11':
+ resolution: {integrity: sha512-KoDEolYtLHG/8C+IiZpXbJWyBOMkrHV+j66Kb9PBXmLv5euGb7aELvuCmLenoGAV6gBW2wM7TsG/1e5iulH4kA==}
engines: {node: '>=20.0.0'}
- '@aws-sdk/credential-provider-ini@3.973.10':
- resolution: {integrity: sha512-Zh9XRaPnDN9buO7GfWBubS22R6Nq5D6hbyYEMN05LiOnXugm/8WDjUx6y756bSPbdn3aJB2qG4zFW3bN82QhoQ==}
+ '@aws-sdk/credential-provider-login@3.972.73':
+ resolution: {integrity: sha512-tjsxMkTAFkmiV9ycmymapb9nLECWVOwFs0bZMQ9gB9bnbY8/HwfukHZlWbXZZp7qkPU6EXAfOcMm3DioFFEywA==}
engines: {node: '>=20.0.0'}
- '@aws-sdk/credential-provider-login@3.972.72':
- resolution: {integrity: sha512-zZapIKwaHp7TdTf9hbH1I3CVUdEupmt7FXO/BoTQGC+4h6NkXKWpqF2p5WyfpjurDLHCpSyh+BzMlAg8arqWLA==}
+ '@aws-sdk/credential-provider-node@3.972.77':
+ resolution: {integrity: sha512-l4nitYCN/Ls57vtUfdextCjTjW41JD7lQiAnuR0RTbdByFc/6OmEAzwGd+lrp6CUtiXGQL1FCaYiamfHASrwBw==}
engines: {node: '>=20.0.0'}
- '@aws-sdk/credential-provider-node@3.972.76':
- resolution: {integrity: sha512-1yzLmRiYSgGC25v7ZZEwJn/auhHHTIHgFOmzL2f36hf1+7jSLcX+1QrAz4760WEzPiiQl8xmlpFhHfl2OoyVzA==}
+ '@aws-sdk/credential-provider-process@3.972.66':
+ resolution: {integrity: sha512-YOnX6bIhdjx0QfaENu2PB0eFm5MEc9ft8XNGQ+NxMfeLSq9aE+XjWCwDupEnV4UWv5ZFpBLJbTREIx7KNOoqpQ==}
engines: {node: '>=20.0.0'}
- '@aws-sdk/credential-provider-process@3.972.65':
- resolution: {integrity: sha512-e5DbbNteOSalN58U83G6kFa4ECLEuGbGqNBHIXE7zYXA/m4GHblIGjFbSH7wYv6gBV8iNSDcRZBKfQZF5vF9nw==}
+ '@aws-sdk/credential-provider-sso@3.973.10':
+ resolution: {integrity: sha512-IsXnQ35j5VE+3ZK6aIhT5ypB+Jim3zRwVz0nYuVwyBKZyu/SYx+O2/LQpng8c2EiuwyqceabsDlYrICHDlJPsA==}
engines: {node: '>=20.0.0'}
- '@aws-sdk/credential-provider-sso@3.973.9':
- resolution: {integrity: sha512-0V0u4t+KBku9fbh5CPCaC5hUWwSzDafp8nCuDy817zWbp2gz80jO44rMQkiwnZ+k54B+tjAtzRy00DJRGTKGBg==}
+ '@aws-sdk/credential-provider-web-identity@3.972.72':
+ resolution: {integrity: sha512-nj9Zlsy7ya+fy+jhWTJwgfr7YdtDM4xHyZvgKuftuny0UgROVx9lxwvsWJSLvpKk4lig0m0tHng3k1fEnt0LeA==}
engines: {node: '>=20.0.0'}
- '@aws-sdk/credential-provider-web-identity@3.972.71':
- resolution: {integrity: sha512-e4dwiRltGAaQ+2yxw57Hj0l/BF3BHiG14+QpYE7bGYBlpAq/fkIri2BDhjWon8c0mhhtd2txQBAkQb9BcTStFg==}
- engines: {node: '>=20.0.0'}
-
- '@aws-sdk/lib-storage@3.1095.0':
- resolution: {integrity: sha512-Z8JGw3YVrUd5JEmOeOs5+YzwxZxJXXwOXqZ7l9oNk4uw+JS/QLxgMr3HB6wYam0ksO6O6u1BQz+gW6PkJ3+RNw==}
+ '@aws-sdk/lib-storage@3.1096.0':
+ resolution: {integrity: sha512-A9ZoQFUawEO2l7jVoBRtDbIJ3hPBnxMRy3oIGQREOsMfwQFvoiyyV0f1Fl5CuIfoovv508TuW+Pe6WZIfh7NOg==}
engines: {node: '>=20.0.0'}
peerDependencies:
- '@aws-sdk/client-s3': ^3.1095.0
+ '@aws-sdk/client-s3': ^3.1096.0
- '@aws-sdk/middleware-sdk-s3@3.972.70':
- resolution: {integrity: sha512-APdP0iODt39AkjCjzTFIoFrxDH/Cz3CpWRDKLcsJg7eOnfE1htkxL9BhDoe/xL7cXdoMwh2HBYv3DiT1uf64NQ==}
+ '@aws-sdk/middleware-sdk-s3@3.972.71':
+ resolution: {integrity: sha512-5fpExT7JOIZSIWExXCgJVbZzbaOlNrS/rE5Eoesnp0ONMbnCtiyYsCkahNIdlXtKrO6XHqXI6ceqssVWMYKmWQ==}
engines: {node: '>=20.0.0'}
- '@aws-sdk/nested-clients@3.997.39':
- resolution: {integrity: sha512-wU5NPnj62Sb7A8xn/Zb+xThe05P3otNtDl37iOIi5DDMeCesNeCckaG+eXWGUs12Z9R34I8CD05TaTe6SIa61g==}
+ '@aws-sdk/nested-clients@3.997.40':
+ resolution: {integrity: sha512-hEdHT0PBR4fkGxWhwKG5EtEYKnAM7HKkp0vD10ufk4YcXejH4r4q6G/XhPzjUc6Yxo5kBS2vHg7llj4ViR9VTQ==}
engines: {node: '>=20.0.0'}
'@aws-sdk/signature-v4-multi-region@3.996.43':
resolution: {integrity: sha512-lKekx8bLBXSv4O+cslk9Zfnw2XKSkWBs3uWL5QGhH2ZAQfNS7FE0vcSSN2vD/AhxX54ZTywWxR4STThoeOXlBA==}
engines: {node: '>=20.0.0'}
- '@aws-sdk/token-providers@3.1100.0':
- resolution: {integrity: sha512-THf3MkgY3fNJZ3zdgSenLqR7gSE68KccCj1RCKretlG73Ppszvues02VpCUO9NlB/tZDC483FvGCld+AiPCkvg==}
+ '@aws-sdk/token-providers@3.1102.0':
+ resolution: {integrity: sha512-Ua700vVvM1q105yABSUQWkCK6FeTrNfU6ORGetJe5BzkZWY7QhkF7SVTOlmDGWRDNd6jbyY0Dv5e+E4bMBEmLg==}
engines: {node: '>=20.0.0'}
'@aws-sdk/types@3.974.2':
@@ -2636,8 +2639,8 @@ packages:
'@types/mdurl@2.0.0':
resolution: {integrity: sha512-RGdgjQUZba5p6QEFAVx2OGb8rQDL/cPRG7GiedRzMcJ1tYnUANBncjbSB1NRGwbvjcPeikRABz2nshyPk1bhWg==}
- '@types/node@26.1.1':
- resolution: {integrity: sha512-nxAkRSVkN1Y0JC1W8ky/fTfkGsMmcrRsbx+3XoZE+rMOX71kLYTV7fLXpqud1GpbpP5TuffXFqfX7fH2GgZREw==}
+ '@types/node@26.1.2':
+ resolution: {integrity: sha512-Vu4a5UFA9rIIFJ7rB/Vaafh9lrCQszopTCx6KjFboXTGQbPNasehVR5TEiithSDGyd1DEiUByggTZsg8jukeIg==}
'@types/nprogress@0.2.3':
resolution: {integrity: sha512-k7kRA033QNtC+gLc4VPlfnue58CM1iQLgn1IMAU8VPHGOj7oIHPp9UlhedEnD/Gl8evoCjwkZjlBORtZ3JByUA==}
@@ -3586,6 +3589,9 @@ packages:
magic-string@0.30.21:
resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==}
+ magic-string@1.1.0:
+ resolution: {integrity: sha512-kS3VHe0nEPST2saQV4Rbkchcd3UBRkVTQHo1D3h/ZTwFDhai/mfKkmtPAtD129EOI7K3HlHIsFOt0WrI2/oU9g==}
+
markdown-it@14.1.1:
resolution: {integrity: sha512-BuU2qnTti9YKgK5N+IeMubp14ZUKUUw7yeJbkjtosvHiP0AZ5c8IAgEMk79D0eC8F23r4Ac/q8cAIFdm2FtyoA==}
hasBin: true
@@ -3807,8 +3813,8 @@ packages:
pathe@2.0.3:
resolution: {integrity: sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==}
- picocad2-web@1.3.0:
- resolution: {integrity: sha512-qvJv7aZ+FZczZAdddbA/yvKLApxX7s+wxkoEOXvJlRrgjXI0Q453dUyAYfrn/u1lPahrW2MBcxU+atWQXrEvYw==}
+ picocad2-web@1.4.0-beta.1:
+ resolution: {integrity: sha512-WZzacJOpgWfbkho4sRUGNgHgrIO8RKcVczp80UZqL97m6fFmuGNoYgYskCMGZ5+RmOEtuNN7IZZLA95W6/Wtag==}
engines: {node: '>=18.0.0'}
picocolors@1.1.1:
@@ -4654,20 +4660,20 @@ snapshots:
transitivePeerDependencies:
- supports-color
- '@aws-sdk/checksums@3.1000.24':
+ '@aws-sdk/checksums@3.1000.25':
dependencies:
- '@aws-sdk/core': 3.977.4
+ '@aws-sdk/core': 3.977.5
'@aws-sdk/types': 3.974.2
'@smithy/core': 3.31.1
'@smithy/types': 4.16.1
tslib: 2.8.1
- '@aws-sdk/client-s3@3.1095.0':
+ '@aws-sdk/client-s3@3.1096.0':
dependencies:
- '@aws-sdk/checksums': 3.1000.24
- '@aws-sdk/core': 3.977.4
- '@aws-sdk/credential-provider-node': 3.972.76
- '@aws-sdk/middleware-sdk-s3': 3.972.70
+ '@aws-sdk/checksums': 3.1000.25
+ '@aws-sdk/core': 3.977.5
+ '@aws-sdk/credential-provider-node': 3.972.77
+ '@aws-sdk/middleware-sdk-s3': 3.972.71
'@aws-sdk/signature-v4-multi-region': 3.996.43
'@aws-sdk/types': 3.974.2
'@smithy/core': 3.31.1
@@ -4676,7 +4682,7 @@ snapshots:
'@smithy/types': 4.16.1
tslib: 2.8.1
- '@aws-sdk/core@3.977.4':
+ '@aws-sdk/core@3.977.5':
dependencies:
'@aws-sdk/types': 3.974.2
'@aws-sdk/xml-builder': 3.972.37
@@ -4687,17 +4693,17 @@ snapshots:
bowser: 2.14.1
tslib: 2.8.1
- '@aws-sdk/credential-provider-env@3.972.65':
+ '@aws-sdk/credential-provider-env@3.972.66':
dependencies:
- '@aws-sdk/core': 3.977.4
+ '@aws-sdk/core': 3.977.5
'@aws-sdk/types': 3.974.2
'@smithy/core': 3.31.1
'@smithy/types': 4.16.1
tslib: 2.8.1
- '@aws-sdk/credential-provider-http@3.972.67':
+ '@aws-sdk/credential-provider-http@3.972.68':
dependencies:
- '@aws-sdk/core': 3.977.4
+ '@aws-sdk/core': 3.977.5
'@aws-sdk/types': 3.974.2
'@smithy/core': 3.31.1
'@smithy/fetch-http-handler': 5.6.13
@@ -4705,75 +4711,75 @@ snapshots:
'@smithy/types': 4.16.1
tslib: 2.8.1
- '@aws-sdk/credential-provider-ini@3.973.10':
+ '@aws-sdk/credential-provider-ini@3.973.11':
dependencies:
- '@aws-sdk/core': 3.977.4
- '@aws-sdk/credential-provider-env': 3.972.65
- '@aws-sdk/credential-provider-http': 3.972.67
- '@aws-sdk/credential-provider-login': 3.972.72
- '@aws-sdk/credential-provider-process': 3.972.65
- '@aws-sdk/credential-provider-sso': 3.973.9
- '@aws-sdk/credential-provider-web-identity': 3.972.71
- '@aws-sdk/nested-clients': 3.997.39
+ '@aws-sdk/core': 3.977.5
+ '@aws-sdk/credential-provider-env': 3.972.66
+ '@aws-sdk/credential-provider-http': 3.972.68
+ '@aws-sdk/credential-provider-login': 3.972.73
+ '@aws-sdk/credential-provider-process': 3.972.66
+ '@aws-sdk/credential-provider-sso': 3.973.10
+ '@aws-sdk/credential-provider-web-identity': 3.972.72
+ '@aws-sdk/nested-clients': 3.997.40
'@aws-sdk/types': 3.974.2
'@smithy/core': 3.31.1
'@smithy/credential-provider-imds': 4.4.16
'@smithy/types': 4.16.1
tslib: 2.8.1
- '@aws-sdk/credential-provider-login@3.972.72':
+ '@aws-sdk/credential-provider-login@3.972.73':
dependencies:
- '@aws-sdk/core': 3.977.4
- '@aws-sdk/nested-clients': 3.997.39
+ '@aws-sdk/core': 3.977.5
+ '@aws-sdk/nested-clients': 3.997.40
'@aws-sdk/types': 3.974.2
'@smithy/core': 3.31.1
'@smithy/types': 4.16.1
tslib: 2.8.1
- '@aws-sdk/credential-provider-node@3.972.76':
+ '@aws-sdk/credential-provider-node@3.972.77':
dependencies:
- '@aws-sdk/credential-provider-env': 3.972.65
- '@aws-sdk/credential-provider-http': 3.972.67
- '@aws-sdk/credential-provider-ini': 3.973.10
- '@aws-sdk/credential-provider-process': 3.972.65
- '@aws-sdk/credential-provider-sso': 3.973.9
- '@aws-sdk/credential-provider-web-identity': 3.972.71
+ '@aws-sdk/credential-provider-env': 3.972.66
+ '@aws-sdk/credential-provider-http': 3.972.68
+ '@aws-sdk/credential-provider-ini': 3.973.11
+ '@aws-sdk/credential-provider-process': 3.972.66
+ '@aws-sdk/credential-provider-sso': 3.973.10
+ '@aws-sdk/credential-provider-web-identity': 3.972.72
'@aws-sdk/types': 3.974.2
'@smithy/core': 3.31.1
'@smithy/credential-provider-imds': 4.4.16
'@smithy/types': 4.16.1
tslib: 2.8.1
- '@aws-sdk/credential-provider-process@3.972.65':
+ '@aws-sdk/credential-provider-process@3.972.66':
dependencies:
- '@aws-sdk/core': 3.977.4
+ '@aws-sdk/core': 3.977.5
'@aws-sdk/types': 3.974.2
'@smithy/core': 3.31.1
'@smithy/types': 4.16.1
tslib: 2.8.1
- '@aws-sdk/credential-provider-sso@3.973.9':
+ '@aws-sdk/credential-provider-sso@3.973.10':
dependencies:
- '@aws-sdk/core': 3.977.4
- '@aws-sdk/nested-clients': 3.997.39
- '@aws-sdk/token-providers': 3.1100.0
+ '@aws-sdk/core': 3.977.5
+ '@aws-sdk/nested-clients': 3.997.40
+ '@aws-sdk/token-providers': 3.1102.0
'@aws-sdk/types': 3.974.2
'@smithy/core': 3.31.1
'@smithy/types': 4.16.1
tslib: 2.8.1
- '@aws-sdk/credential-provider-web-identity@3.972.71':
+ '@aws-sdk/credential-provider-web-identity@3.972.72':
dependencies:
- '@aws-sdk/core': 3.977.4
- '@aws-sdk/nested-clients': 3.997.39
+ '@aws-sdk/core': 3.977.5
+ '@aws-sdk/nested-clients': 3.997.40
'@aws-sdk/types': 3.974.2
'@smithy/core': 3.31.1
'@smithy/types': 4.16.1
tslib: 2.8.1
- '@aws-sdk/lib-storage@3.1095.0(@aws-sdk/client-s3@3.1095.0)':
+ '@aws-sdk/lib-storage@3.1096.0(@aws-sdk/client-s3@3.1096.0)':
dependencies:
- '@aws-sdk/client-s3': 3.1095.0
+ '@aws-sdk/client-s3': 3.1096.0
'@smithy/core': 3.31.1
'@smithy/types': 4.16.1
buffer: 5.6.0
@@ -4781,18 +4787,18 @@ snapshots:
stream-browserify: 3.0.0
tslib: 2.8.1
- '@aws-sdk/middleware-sdk-s3@3.972.70':
+ '@aws-sdk/middleware-sdk-s3@3.972.71':
dependencies:
- '@aws-sdk/core': 3.977.4
+ '@aws-sdk/core': 3.977.5
'@aws-sdk/signature-v4-multi-region': 3.996.43
'@aws-sdk/types': 3.974.2
'@smithy/core': 3.31.1
'@smithy/types': 4.16.1
tslib: 2.8.1
- '@aws-sdk/nested-clients@3.997.39':
+ '@aws-sdk/nested-clients@3.997.40':
dependencies:
- '@aws-sdk/core': 3.977.4
+ '@aws-sdk/core': 3.977.5
'@aws-sdk/signature-v4-multi-region': 3.996.43
'@aws-sdk/types': 3.974.2
'@smithy/core': 3.31.1
@@ -4808,10 +4814,10 @@ snapshots:
'@smithy/types': 4.16.1
tslib: 2.8.1
- '@aws-sdk/token-providers@3.1100.0':
+ '@aws-sdk/token-providers@3.1102.0':
dependencies:
- '@aws-sdk/core': 3.977.4
- '@aws-sdk/nested-clients': 3.997.39
+ '@aws-sdk/core': 3.977.5
+ '@aws-sdk/nested-clients': 3.997.40
'@aws-sdk/types': 3.974.2
'@smithy/core': 3.31.1
'@smithy/types': 4.16.1
@@ -5768,7 +5774,7 @@ snapshots:
'@radix-ui/rect@1.1.1': {}
- '@react-router/dev@8.3.0(@react-router/serve@8.1.0(patch_hash=4d79b209948d4237f1ca3a5cca417c6d11519d8b1ab7084c75c46a39e3ac27d6)(react-router@8.3.0(react-dom@19.2.8(react@19.2.8))(react@19.2.8))(typescript@7.0.2))(react-router@8.3.0(react-dom@19.2.8(react@19.2.8))(react@19.2.8))(typescript@7.0.2)(vite@8.1.5(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0))':
+ '@react-router/dev@8.3.0(@react-router/serve@8.1.0(patch_hash=4d79b209948d4237f1ca3a5cca417c6d11519d8b1ab7084c75c46a39e3ac27d6)(react-router@8.3.0(react-dom@19.2.8(react@19.2.8))(react@19.2.8))(typescript@7.0.2))(react-router@8.3.0(react-dom@19.2.8(react@19.2.8))(react@19.2.8))(typescript@7.0.2)(vite@8.1.5(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0))':
dependencies:
'@babel/core': 7.29.7
'@babel/generator': 7.29.7
@@ -5797,7 +5803,7 @@ snapshots:
semver: 7.8.5
tinyglobby: 0.2.17
valibot: 1.4.2(typescript@7.0.2)
- vite: 8.1.5(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0)
+ vite: 8.1.5(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0)
optionalDependencies:
'@react-router/serve': 8.1.0(patch_hash=4d79b209948d4237f1ca3a5cca417c6d11519d8b1ab7084c75c46a39e3ac27d6)(react-router@8.3.0(react-dom@19.2.8(react@19.2.8))(react@19.2.8))(typescript@7.0.2)
typescript: 7.0.2
@@ -7229,7 +7235,7 @@ snapshots:
'@types/mdurl@2.0.0': {}
- '@types/node@26.1.1':
+ '@types/node@26.1.2':
dependencies:
undici-types: 8.3.0
@@ -7251,7 +7257,7 @@ snapshots:
'@types/web-push@3.6.4':
dependencies:
- '@types/node': 26.1.1
+ '@types/node': 26.1.2
'@typescript/typescript-aix-ppc64@7.0.2':
optional: true
@@ -7320,29 +7326,29 @@ snapshots:
'@use-gesture/core': 10.3.1
react: 19.2.8
- '@vitest/browser-playwright@4.1.10(playwright@1.62.0)(vite@8.1.5(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0))(vitest@4.1.10)':
+ '@vitest/browser-playwright@4.1.10(playwright@1.62.0)(vite@8.1.5(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0))(vitest@4.1.10)':
dependencies:
- '@vitest/browser': 4.1.10(vite@8.1.5(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0))(vitest@4.1.10)
- '@vitest/mocker': 4.1.10(vite@8.1.5(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0))
+ '@vitest/browser': 4.1.10(vite@8.1.5(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0))(vitest@4.1.10)
+ '@vitest/mocker': 4.1.10(vite@8.1.5(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0))
playwright: 1.62.0
tinyrainbow: 3.1.0
- vitest: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.1)(@vitest/browser-playwright@4.1.10)(@vitest/ui@4.1.10)(vite@8.1.5(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0))
+ vitest: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.2)(@vitest/browser-playwright@4.1.10)(@vitest/ui@4.1.10)(vite@8.1.5(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0))
transitivePeerDependencies:
- bufferutil
- msw
- utf-8-validate
- vite
- '@vitest/browser@4.1.10(vite@8.1.5(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0))(vitest@4.1.10)':
+ '@vitest/browser@4.1.10(vite@8.1.5(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0))(vitest@4.1.10)':
dependencies:
'@blazediff/core': 1.9.1
- '@vitest/mocker': 4.1.10(vite@8.1.5(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0))
+ '@vitest/mocker': 4.1.10(vite@8.1.5(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0))
'@vitest/utils': 4.1.10
magic-string: 0.30.21
pngjs: 7.0.0
sirv: 3.0.2
tinyrainbow: 3.1.0
- vitest: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.1)(@vitest/browser-playwright@4.1.10)(@vitest/ui@4.1.10)(vite@8.1.5(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0))
+ vitest: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.2)(@vitest/browser-playwright@4.1.10)(@vitest/ui@4.1.10)(vite@8.1.5(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0))
ws: 8.21.0
transitivePeerDependencies:
- bufferutil
@@ -7359,13 +7365,13 @@ snapshots:
chai: 6.2.2
tinyrainbow: 3.1.0
- '@vitest/mocker@4.1.10(vite@8.1.5(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0))':
+ '@vitest/mocker@4.1.10(vite@8.1.5(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0))':
dependencies:
'@vitest/spy': 4.1.10
estree-walker: 3.0.3
magic-string: 0.30.21
optionalDependencies:
- vite: 8.1.5(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0)
+ vite: 8.1.5(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0)
'@vitest/pretty-format@4.1.10':
dependencies:
@@ -7394,7 +7400,7 @@ snapshots:
sirv: 3.0.2
tinyglobby: 0.2.17
tinyrainbow: 3.1.0
- vitest: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.1)(@vitest/browser-playwright@4.1.10)(@vitest/ui@4.1.10)(vite@8.1.5(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0))
+ vitest: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.2)(@vitest/browser-playwright@4.1.10)(@vitest/ui@4.1.10)(vite@8.1.5(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0))
'@vitest/utils@4.1.10':
dependencies:
@@ -8090,6 +8096,10 @@ snapshots:
dependencies:
'@jridgewell/sourcemap-codec': 1.5.5
+ magic-string@1.1.0:
+ dependencies:
+ '@jridgewell/sourcemap-codec': 1.5.5
+
markdown-it@14.1.1:
dependencies:
argparse: 2.0.1
@@ -8294,7 +8304,7 @@ snapshots:
pathe@2.0.3: {}
- picocad2-web@1.3.0:
+ picocad2-web@1.4.0-beta.1:
dependencies:
gl-matrix: 3.4.4
twgl.js: 7.0.0
@@ -8976,13 +8986,13 @@ snapshots:
vary@1.1.2: {}
- vite-node@6.0.0(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0):
+ vite-node@6.0.0(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0):
dependencies:
cac: 7.0.0
es-module-lexer: 2.0.0
obug: 2.1.1
pathe: 2.0.3
- vite: 8.1.5(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0)
+ vite: 8.1.5(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0)
transitivePeerDependencies:
- '@types/node'
- '@vitejs/devtools'
@@ -8997,12 +9007,12 @@ snapshots:
- tsx
- yaml
- vite-plugin-babel@1.7.3(@babel/core@7.29.7)(vite@8.1.5(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0)):
+ vite-plugin-babel@1.7.3(@babel/core@7.29.7)(vite@8.1.5(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0)):
dependencies:
'@babel/core': 7.29.7
- vite: 8.1.5(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0)
+ vite: 8.1.5(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0)
- vite@8.1.5(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0):
+ vite@8.1.5(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0):
dependencies:
lightningcss: 1.33.0
picomatch: 4.0.5
@@ -9010,7 +9020,7 @@ snapshots:
rolldown: 1.1.5
tinyglobby: 0.2.17
optionalDependencies:
- '@types/node': 26.1.1
+ '@types/node': 26.1.2
fsevents: 2.3.3
jiti: 2.7.0
yaml: 2.9.0
@@ -9019,15 +9029,15 @@ snapshots:
dependencies:
react: 19.2.8
react-dom: 19.2.8(react@19.2.8)
- vitest: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.1)(@vitest/browser-playwright@4.1.10)(@vitest/ui@4.1.10)(vite@8.1.5(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0))
+ vitest: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.2)(@vitest/browser-playwright@4.1.10)(@vitest/ui@4.1.10)(vite@8.1.5(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0))
optionalDependencies:
'@types/react': 19.2.17
'@types/react-dom': 19.2.3(@types/react@19.2.17)
- vitest@4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.1)(@vitest/browser-playwright@4.1.10)(@vitest/ui@4.1.10)(vite@8.1.5(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0)):
+ vitest@4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.2)(@vitest/browser-playwright@4.1.10)(@vitest/ui@4.1.10)(vite@8.1.5(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0)):
dependencies:
'@vitest/expect': 4.1.10
- '@vitest/mocker': 4.1.10(vite@8.1.5(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0))
+ '@vitest/mocker': 4.1.10(vite@8.1.5(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0))
'@vitest/pretty-format': 4.1.10
'@vitest/runner': 4.1.10
'@vitest/snapshot': 4.1.10
@@ -9044,12 +9054,12 @@ snapshots:
tinyexec: 1.2.4
tinyglobby: 0.2.17
tinyrainbow: 3.1.0
- vite: 8.1.5(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0)
+ vite: 8.1.5(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0)
why-is-node-running: 2.3.0
optionalDependencies:
'@opentelemetry/api': 1.9.1
- '@types/node': 26.1.1
- '@vitest/browser-playwright': 4.1.10(playwright@1.62.0)(vite@8.1.5(@types/node@26.1.1)(jiti@2.7.0)(yaml@2.9.0))(vitest@4.1.10)
+ '@types/node': 26.1.2
+ '@vitest/browser-playwright': 4.1.10(playwright@1.62.0)(vite@8.1.5(@types/node@26.1.2)(jiti@2.7.0)(yaml@2.9.0))(vitest@4.1.10)
'@vitest/ui': 4.1.10(vitest@4.1.10)
transitivePeerDependencies:
- msw