volleyballsimtypes 0.0.526 → 0.0.528

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

@@ -26,5 +26,137 @@ 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'),
+    // 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, 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,
+    numberColor: hexColor,
+    numberOutline: hexColor,
+    numberOutlineEnabled: z.boolean().default(true),
+    brandColor1: hexColor.default('#ffffff'),
     brandColor2: hexColor.default('#1e293b')
 });
+// ---------------------------------------------------------------------------
+// Colour utilities (pure math, zero deps)
+// ---------------------------------------------------------------------------
+function hexToRgb(hex) {
+    const h = hex.replace('#', '').slice(0, 6);
+    return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)];
+}
+function rgbToHex(r, g, b) {
+    return '#' + [r, g, b].map(v => Math.round(Math.max(0, Math.min(255, v))).toString(16).padStart(2, '0')).join('');
+}
+function rgbToHsl(r, g, b) {
+    r /= 255;
+    g /= 255;
+    b /= 255;
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    const l = (max + min) / 2;
+    if (max === min)
+        return [0, 0, l];
+    const d = max - min;
+    const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    let h = 0;
+    if (max === r)
+        h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+    else if (max === g)
+        h = ((b - r) / d + 2) / 6;
+    else
+        h = ((r - g) / d + 4) / 6;
+    return [h, s, l];
+}
+function hslToRgb(h, s, l) {
+    if (s === 0) {
+        const v = Math.round(l * 255);
+        return [v, v, v];
+    }
+    const hue2rgb = (p, q, t) => {
+        if (t < 0)
+            t += 1;
+        if (t > 1)
+            t -= 1;
+        if (t < 1 / 6)
+            return p + (q - p) * 6 * t;
+        if (t < 1 / 2)
+            return q;
+        if (t < 2 / 3)
+            return p + (q - p) * (2 / 3 - t) * 6;
+        return p;
+    };
+    const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+    const p = 2 * l - q;
+    return [Math.round(hue2rgb(p, q, h + 1 / 3) * 255), Math.round(hue2rgb(p, q, h) * 255), Math.round(hue2rgb(p, q, h - 1 / 3) * 255)];
+}
+// Rotate a hex colour's hue by 180 degrees (complementary).
+export function complementaryHex(hex) {
+    const [r, g, b] = hexToRgb(hex);
+    const [h, s, l] = rgbToHsl(r, g, b);
+    const [cr, cg, cb] = hslToRgb((h + 0.5) % 1, s, l);
+    return rgbToHex(cr, cg, cb);
+}
+// Relative luminance (WCAG 2.x formula, 0 = black, 1 = white).
+export function relativeLuminance(hex) {
+    const [r, g, b] = hexToRgb(hex);
+    const srgb = [r, g, b].map(v => {
+        v /= 255;
+        return v <= 0.03928 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+    });
+    return 0.2126 * srgb[0] + 0.7152 * srgb[1] + 0.0722 * srgb[2];
+}
+// Build the libero alternate kit from the main kit using complementary colours. Every colour in the
+// pattern and the brand is hue-rotated 180 degrees; the chest-number fill/outline are picked for
+// readability against the new primary colour (dark number on light, light number on dark).
+export function computeComplementaryJersey(main) {
+    const compColors = main.colors.map(c => complementaryHex(c));
+    const lum = relativeLuminance(compColors[0]);
+    return {
+        // Locked fields: inherited from main
+        clothing: main.clothing,
+        font: main.font,
+        brand: main.brand,
+        numberSpacing: main.numberSpacing,
+        numberSize: main.numberSize,
+        brandSize: main.brandSize,
+        badgeSize: main.badgeSize,
+        // Editable fields: complementary-derived
+        pattern: main.pattern,
+        colors: compColors,
+        numberColor: lum > 0.4 ? '#1a1a1a' : '#ffffff',
+        numberOutline: lum > 0.4 ? '#ffffff' : '#1a1a1a',
+        numberOutlineEnabled: main.numberOutlineEnabled,
+        brandColor1: complementaryHex(main.brandColor1),
+        brandColor2: complementaryHex(main.brandColor2)
+    };
+}
+// Merge a stored alternate (partial, editable fields only) with the main kit's locked fields to
+// produce a full JerseyConfig for rendering.
+export function mergeAlternateJersey(main, alt) {
+    return {
+        clothing: main.clothing,
+        font: main.font,
+        brand: main.brand,
+        numberSpacing: main.numberSpacing,
+        numberSize: main.numberSize,
+        brandSize: main.brandSize,
+        badgeSize: main.badgeSize,
+        pattern: alt.pattern,
+        colors: alt.colors,
+        numberColor: alt.numberColor,
+        numberOutline: alt.numberOutline,
+        numberOutlineEnabled: alt.numberOutlineEnabled,
+        brandColor1: alt.brandColor1,
+        brandColor2: alt.brandColor2
+    };
+}

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

@@ -413,6 +413,128 @@ 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<{
+            solid: "solid";
+            verticalStripes: "verticalStripes";
+            verticalBars: "verticalBars";
+            pinstripes: "pinstripes";
+            hoops: "hoops";
+            checkered: "checkered";
+            diagonalSash: "diagonalSash";
+            splitHalves: "splitHalves";
+            chevron: "chevron";
+            shoulderYoke: "shoulderYoke";
+            sidePanels: "sidePanels";
+            centerBand: "centerBand";
+            gradientFade: "gradientFade";
+            twoToneSplit: "twoToneSplit";
+        }>;
+        colors: z.ZodArray<z.ZodString>;
+        numberColor: z.ZodString;
+        numberOutline: z.ZodString;
+        numberOutlineEnabled: z.ZodDefault<z.ZodBoolean>;
+        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

@@ -2,7 +2,8 @@ import { z } from 'zod';
 import { Player } from '../../player';
 import { Country } from '../../country';
 import { TacticsInputSchema } from './tactics.z';
-import { JerseySchema } from '../jersey';
+import { JerseySchema, AlternateJerseySchema } from '../jersey';
+import { BadgeSchema } from '../badge';
 const playerInstanceSchema = z.custom((v) => v instanceof Player, {
     message: 'INVALID_PLAYER_INSTANCE'
 });
@@ -19,7 +20,9 @@ export const TeamInputSchema = z.object({
     country: countrySchema,
     legacyFlagCountry: countrySchema.optional(),
     tactics: TacticsInputSchema.optional(),
-    jerseyConfig: JerseySchema.optional()
+    jerseyConfig: JerseySchema.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

@@ -1,7 +1,8 @@
 import { Player } from '../player';
 import { Country } from '../country';
 import { Tactics } from './tactics';
-import type { JerseyConfig } from './jersey';
+import type { JerseyConfig, AlternateJerseyConfig } from './jersey';
+import type { BadgeConfig } from './badge';
 export declare class Team {
     readonly id: string;
     readonly roster: Player[];
@@ -12,6 +13,8 @@ export declare class Team {
     readonly country: Country;
     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 }) {
+    constructor({ id, rating, name, shortName, divisionId, country, legacyFlagCountry, roster, tactics, jerseyConfig, alternateJerseyConfig, badgeConfig }) {
         this.id = id;
         this._rating = rating;
         this.roster = roster;
@@ -27,6 +27,8 @@ export class Team {
         this.country = country;
         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.526",
+  "version": "0.0.528",
   "description": "vbsim types",
   "main": "./dist/cjs/src/index.js",
   "module": "./dist/esm/src/index.js",