volleyballsimtypes 0.0.527 → 0.0.528

package/dist/esm/src/service/team/badge.js

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+// 6-digit hex (#rrggbb) or 8-digit hex with alpha (#rrggbbaa), the same convention as the jersey colours (the
+// 8-digit form comes from the UI's opacity-enabled colour pickers; SVG fills render both).
+const hexColor = z.string().regex(/^#[0-9a-fA-F]{6}([0-9a-fA-F]{2})?$/, 'INVALID_HEX_COLOR');
+// The badge canvas is a fixed square coordinate space. Layer x/y are the layer's centre in canvas units and
+// `size` is the layer's height in the same units; positions may overhang the canvas a little (clipped at render).
+export const BADGE_CANVAS = 200;
+// Curated FontAwesome icon names offered as badge layers (owner decision 2026-08-31: curated set, not a full
+// catalog). The UI maps each name to its solid-icon path data (view/badge/badge-icons.ts, a Record keyed by this
+// type so the two lists cannot drift); this list is what the API validates against.
+export const BADGE_ICONS = [
+    'star', 'crown', 'bolt', 'fire', 'heart', 'gem', 'skull', 'ghost', 'anchor', 'compass',
+    'sun', 'moon', 'snowflake', 'leaf', 'seedling', 'tree', 'mountain', 'water', 'wind', 'meteor',
+    'rocket', 'bell', 'flag', 'feather', 'shield-halved', 'chess-knight', 'chess-rook', 'hammer', 'crosshairs',
+    'medal', 'trophy', 'award', 'volleyball', 'dragon', 'cat', 'crow', 'turtle', 'unicorn', 'horse', 'dove',
+    'fish', 'paw', 'spider', 'otter', 'frog', 'dog'
+];
+// Text layers offer the same 20 faces as the jersey number editor (JERSEY_FONT_ALL): five generic stacks, then
+// the fifteen display families. The jersey renders its number from GENERATED DIGIT GLYPHS because it lives in a
+// data-uri <img> where @font-face does not load; the badge canvas is inline SVG in the document, so it uses the
+// real webfonts instead, which also means badge text is not limited to the digits those glyph sets cover.
+export const BADGE_TEXT_FONTS = [
+    'sans', 'wide', 'mono', 'serif', 'block',
+    'permanentMarker', 'kaushanScript', 'russoOne', 'teko', 'saira', 'michroma', 'zillaSlab', 'changaOne',
+    'stardosStencil', 'wallpoet', 'orbitron', 'tourney', 'bebasNeue', 'anton', 'jersey25'
+];
+// Basic geometric shapes (VolleyballSimUI/public/shapes), extracted from the two source sets 2026-08-31. The
+// crest sets are positional (shield-a01, ribbon-07), but these are named, so the vocabulary is spelled out
+// rather than pattern-matched: this list IS the allow list, and every entry has a file of the same name.
+// `-outline` is the hollow cut, whose interior is a real hole in the path (so layers underneath show through,
+// no transparent fill slot needed). Order is the picker order, grouped by family.
+// The rounded-corner cut of every shape, plus the split square and the pie, were dropped by the owner
+// 2026-08-31; only the sharp cuts ship.
+export const BADGE_SHAPES = [
+    'star5-solid', 'star5-slim-solid', 'star6-solid', 'cross-solid',
+    'star5-outline', 'star5-slim-outline', 'star6-outline', 'cross-outline',
+    'pentagon-solid', 'hexagon-solid', 'octagon-solid',
+    'pentagon-outline', 'hexagon-outline', 'octagon-outline',
+    'square-solid', 'triangle-solid', 'diamond-solid',
+    'square-outline', 'triangle-outline', 'diamond-outline',
+    'rectangle-solid', 'burst-solid', 'trapezoid-solid',
+    'rectangle-outline', 'burst-outline', 'trapezoid-outline',
+    'circle-solid', 'heptagon-solid', 'nonagon-solid', 'ellipse-solid', 'parallelogram-solid',
+    'heart-solid', 'moon-solid', 'semicircle-solid', 'triangle-right-solid', 'triangle-tall-solid',
+    'trapezoid-tall-solid', 'kite-solid'
+];
+// The extracted vector sets in VolleyballSimUI/public/shields + public/ribbons + public/shapes:
+// shield-a01..a17 / shield-b01..b16, each -solid|-bordered|-outline; ribbon-01..ribbon-49; and shape-<name>
+// for every name in BADGE_SHAPES.
+const CREST_ID = /^(shield-(a(0[1-9]|1[0-7])|b(0[1-9]|1[0-6]))-(solid|bordered|outline)|ribbon-(0[1-9]|[1-4][0-9]))$/;
+const BASIC_ID = new RegExp(`^shape-(${BADGE_SHAPES.join('|')})$`);
+const shapeId = z.string().refine(v => CREST_ID.test(v) || BASIC_ID.test(v), 'INVALID_BADGE_SHAPE');
+const layerBase = {
+    x: z.number().min(-100).max(300),
+    y: z.number().min(-100).max(300),
+    size: z.number().min(4).max(400),
+    rotation: z.number().min(-180).max(180)
+};
+// One colour per DISTINCT fill in the source art (solid shields 1, bordered 3, ribbons up to 4, basic shapes 1),
+// applied in the order the fills first appear in the file. Extra entries are ignored at render; missing ones
+// fall back to the source colour.
+const shapeLayer = z.object({
+    type: z.literal('shape'),
+    shape: shapeId,
+    colors: z.array(hexColor).min(1).max(6),
+    ...layerBase
+});
+const iconLayer = z.object({
+    type: z.literal('icon'),
+    icon: z.enum(BADGE_ICONS),
+    color: hexColor,
+    ...layerBase
+});
+const textLayer = z.object({
+    type: z.literal('text'),
+    text: z.string().min(1).max(24),
+    font: z.enum(BADGE_TEXT_FONTS),
+    color: hexColor,
+    ...layerBase
+});
+export const BadgeLayerSchema = z.discriminatedUnion('type', [shapeLayer, iconLayer, textLayer]);
+// The most layers one badge may stack. Not a technical ceiling (25 layers is under 3 KB of jsonb and a trivial
+// number of SVG paths): past roughly a dozen you cannot tell the elements apart at the size a crest is shown,
+// and the one-step-per-click reordering gets tedious. Exported so the editor gates on the SAME number the save
+// validates against, rather than keeping its own copy that can drift.
+export const BADGE_MAX_LAYERS = 25;
+// The full team badge: an ordered stack of layers (index 0 renders first, i.e. at the back).
+export const BadgeSchema = z.object({
+    layers: z.array(BadgeLayerSchema).min(1).max(BADGE_MAX_LAYERS)
+});

package/dist/esm/src/service/team/index.d.ts

@@ -1,6 +1,7 @@
 export * from './team';
 export * from './jersey';
 export * from './jersey-defaults';
+export * from './badge';
 export * from './team-generator';
 export * from './formation';
 export * from './tactics';

package/dist/esm/src/service/team/index.js

@@ -1,6 +1,7 @@
 export * from './team';
 export * from './jersey';
 export * from './jersey-defaults';
+export * from './badge';
 export * from './team-generator';
 export * from './formation';
 export * from './tactics';

package/dist/esm/src/service/team/jersey-defaults.js

@@ -70,6 +70,8 @@ export function jerseyFromTeamId(teamId) {
         numberSize: 46,
         brand: 'none',
         brandColor1: '#ffffff',
-        brandColor2: '#1e293b'
+        brandColor2: '#1e293b',
+        brandSize: 29,
+        badgeSize: 48
     };
 }

package/dist/esm/src/service/team/jersey.d.ts

@@ -67,6 +67,8 @@ export declare const JerseySchema: z.ZodObject<{
     }>>;
     brandColor1: z.ZodDefault<z.ZodString>;
     brandColor2: z.ZodDefault<z.ZodString>;
+    brandSize: z.ZodDefault<z.ZodNumber>;
+    badgeSize: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type JerseyConfig = z.infer<typeof JerseySchema>;
 export type JerseyClothing = JerseyConfig['clothing'];

package/dist/esm/src/service/team/jersey.js

@@ -26,10 +26,18 @@ export const JerseySchema = z.object({
     // configs saved before it stay valid.
     brand: z.enum(['none', 'sigma', 'person-soccer', 'feather-pointed', 'paw-claws', 'narwhal', 'horseshoe', 'spider-black-widow', 'wreath-laurel', 'omega', 'trillium']).default('none'),
     brandColor1: hexColor.default('#ffffff'),
-    brandColor2: hexColor.default('#1e293b')
+    brandColor2: hexColor.default('#1e293b'),
+    // Chest-element heights in avatar-svg units, on the y=297 chest line. The brand sits at x=90 and the team badge
+    // at x=191, with the (non-editable) champion badge between them at x=140.5 spanning 116.5..164.5, so either one
+    // starts touching it past about 52. The range allows more than that on purpose: most teams have no champion
+    // badge, and the editor preview shows the overlap for the ones that do. Defaulted to the sizes both were fixed
+    // at before, so configs saved earlier stay valid and look unchanged.
+    brandSize: z.number().min(16).max(64).default(29),
+    badgeSize: z.number().min(16).max(64).default(48)
 });
 // The alternate (libero) kit stores only the fields the premium editor allows changing. Locked fields (clothing,
-// font, brand icon, numberSpacing, numberSize) are always inherited from the main kit at render time.
+// font, brand icon, numberSpacing, numberSize, brandSize, badgeSize) are always inherited from the main kit at
+// render time.
 export const AlternateJerseySchema = z.object({
     pattern: JerseySchema.shape.pattern,
     colors: JerseySchema.shape.colors,
@@ -120,6 +128,8 @@ export function computeComplementaryJersey(main) {
         brand: main.brand,
         numberSpacing: main.numberSpacing,
         numberSize: main.numberSize,
+        brandSize: main.brandSize,
+        badgeSize: main.badgeSize,
         // Editable fields: complementary-derived
         pattern: main.pattern,
         colors: compColors,
@@ -139,6 +149,8 @@ export function mergeAlternateJersey(main, alt) {
         brand: main.brand,
         numberSpacing: main.numberSpacing,
         numberSize: main.numberSize,
+        brandSize: main.brandSize,
+        badgeSize: main.badgeSize,
         pattern: alt.pattern,
         colors: alt.colors,
         numberColor: alt.numberColor,

package/dist/esm/src/service/team/schemas/team.z.d.ts

@@ -413,6 +413,8 @@ export declare const TeamInputSchema: z.ZodObject<{
         }>>;
         brandColor1: z.ZodDefault<z.ZodString>;
         brandColor2: z.ZodDefault<z.ZodString>;
+        brandSize: z.ZodDefault<z.ZodNumber>;
+        badgeSize: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
     alternateJerseyConfig: z.ZodOptional<z.ZodObject<{
         pattern: z.ZodEnum<{
@@ -438,5 +440,101 @@ export declare const TeamInputSchema: z.ZodObject<{
         brandColor1: z.ZodDefault<z.ZodString>;
         brandColor2: z.ZodDefault<z.ZodString>;
     }, z.core.$strip>>;
+    badgeConfig: z.ZodOptional<z.ZodObject<{
+        layers: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            size: z.ZodNumber;
+            rotation: z.ZodNumber;
+            type: z.ZodLiteral<"shape">;
+            shape: z.ZodString;
+            colors: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            size: z.ZodNumber;
+            rotation: z.ZodNumber;
+            type: z.ZodLiteral<"icon">;
+            icon: z.ZodEnum<{
+                star: "star";
+                crown: "crown";
+                bolt: "bolt";
+                fire: "fire";
+                heart: "heart";
+                gem: "gem";
+                skull: "skull";
+                ghost: "ghost";
+                anchor: "anchor";
+                compass: "compass";
+                sun: "sun";
+                moon: "moon";
+                snowflake: "snowflake";
+                leaf: "leaf";
+                seedling: "seedling";
+                tree: "tree";
+                mountain: "mountain";
+                water: "water";
+                wind: "wind";
+                meteor: "meteor";
+                rocket: "rocket";
+                bell: "bell";
+                flag: "flag";
+                feather: "feather";
+                "shield-halved": "shield-halved";
+                "chess-knight": "chess-knight";
+                "chess-rook": "chess-rook";
+                hammer: "hammer";
+                crosshairs: "crosshairs";
+                medal: "medal";
+                trophy: "trophy";
+                award: "award";
+                volleyball: "volleyball";
+                dragon: "dragon";
+                cat: "cat";
+                crow: "crow";
+                turtle: "turtle";
+                unicorn: "unicorn";
+                horse: "horse";
+                dove: "dove";
+                fish: "fish";
+                paw: "paw";
+                spider: "spider";
+                otter: "otter";
+                frog: "frog";
+                dog: "dog";
+            }>;
+            color: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            size: z.ZodNumber;
+            rotation: z.ZodNumber;
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+            font: z.ZodEnum<{
+                block: "block";
+                sans: "sans";
+                wide: "wide";
+                mono: "mono";
+                serif: "serif";
+                permanentMarker: "permanentMarker";
+                kaushanScript: "kaushanScript";
+                russoOne: "russoOne";
+                teko: "teko";
+                saira: "saira";
+                michroma: "michroma";
+                zillaSlab: "zillaSlab";
+                changaOne: "changaOne";
+                stardosStencil: "stardosStencil";
+                wallpoet: "wallpoet";
+                orbitron: "orbitron";
+                tourney: "tourney";
+                bebasNeue: "bebasNeue";
+                anton: "anton";
+                jersey25: "jersey25";
+            }>;
+            color: z.ZodString;
+        }, z.core.$strip>], "type">>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type TeamInput = z.infer<typeof TeamInputSchema>;

package/dist/esm/src/service/team/schemas/team.z.js

@@ -3,6 +3,7 @@ import { Player } from '../../player';
 import { Country } from '../../country';
 import { TacticsInputSchema } from './tactics.z';
 import { JerseySchema, AlternateJerseySchema } from '../jersey';
+import { BadgeSchema } from '../badge';
 const playerInstanceSchema = z.custom((v) => v instanceof Player, {
     message: 'INVALID_PLAYER_INSTANCE'
 });
@@ -20,7 +21,8 @@ export const TeamInputSchema = z.object({
     legacyFlagCountry: countrySchema.optional(),
     tactics: TacticsInputSchema.optional(),
     jerseyConfig: JerseySchema.optional(),
-    alternateJerseyConfig: AlternateJerseySchema.optional()
+    alternateJerseyConfig: AlternateJerseySchema.optional(),
+    badgeConfig: BadgeSchema.optional()
 }).superRefine((data, ctx) => {
     const ids = data.roster.map(p => p.id);
     if (new Set(ids).size !== ids.length) {

package/dist/esm/src/service/team/team.d.ts

@@ -2,6 +2,7 @@ import { Player } from '../player';
 import { Country } from '../country';
 import { Tactics } from './tactics';
 import type { JerseyConfig, AlternateJerseyConfig } from './jersey';
+import type { BadgeConfig } from './badge';
 export declare class Team {
     readonly id: string;
     readonly roster: Player[];
@@ -13,6 +14,7 @@ export declare class Team {
     readonly legacyFlagCountry?: Country;
     readonly jerseyConfig?: JerseyConfig;
     readonly alternateJerseyConfig?: AlternateJerseyConfig;
+    readonly badgeConfig?: BadgeConfig;
     private _rating;
     static create(input: unknown): Team;
     private constructor();

package/dist/esm/src/service/team/team.js

@@ -16,7 +16,7 @@ export class Team {
             tactics: result.data.tactics != null ? Tactics.create(result.data.tactics) : undefined
         });
     }
-    constructor({ id, rating, name, shortName, divisionId, country, legacyFlagCountry, roster, tactics, jerseyConfig, alternateJerseyConfig }) {
+    constructor({ id, rating, name, shortName, divisionId, country, legacyFlagCountry, roster, tactics, jerseyConfig, alternateJerseyConfig, badgeConfig }) {
         this.id = id;
         this._rating = rating;
         this.roster = roster;
@@ -28,6 +28,7 @@ export class Team {
         this.legacyFlagCountry = legacyFlagCountry;
         this.jerseyConfig = jerseyConfig;
         this.alternateJerseyConfig = alternateJerseyConfig;
+        this.badgeConfig = badgeConfig;
     }
     get rating() {
         return this._rating;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "volleyballsimtypes",
-  "version": "0.0.527",
+  "version": "0.0.528",
   "description": "vbsim types",
   "main": "./dist/cjs/src/index.js",
   "module": "./dist/esm/src/index.js",