@luceosports/play-rendering 1.19.0 → 2.0.0

package/src/constants.ts

@@ -0,0 +1,49 @@
+export const SPORT_TYPE_BASKETBALL = 'BASKETBALL';
+export const SPORT_TYPE_VOLLEYBALL = 'VOLLEYBALL';
+export const SPORT_TYPE_FOOTBALL = 'FOOTBALL';
+export const SPORT_TYPE_LACROSSE = 'LACROSSE';
+export const SPORT_TYPE_SOCCER = 'SOCCER';
+export const SPORT_TYPE_HOCKEY = 'HOCKEY';
+export const SPORT_TYPE_BASEBALL = 'BASEBALL';
+
+export const COURT_TYPE_BIG3 = 'BIG3';
+export const COURT_TYPE_FIBA = 'FIBA';
+export const COURT_TYPE_NBA = 'NBA';
+export const COURT_TYPE_NCAAM = 'NCAAM';
+export const COURT_TYPE_NCAAW = 'NCAAW';
+export const COURT_TYPE_US_HIGH_SCHOOL = 'US_HIGH_SCHOOL';
+export const COURT_TYPE_US_JUNIOR_HIGH = 'US_JUNIOR_HIGH';
+export const COURT_TYPE_WNBA = 'WNBA';
+
+export const COURT_TYPE_FOOTBALL_HIGH_SCHOOL = 'FOOTBALL_HIGH_SCHOOL';
+export const COURT_TYPE_FOOTBALL_HIGH_SCHOOL_LEGACY = 'FOOTBALL';
+
+export const COURT_TYPE_VOLLEYBALL_INDOOR = 'VOLLEYBALL_INDOOR';
+
+export const COURT_TYPE_LACROSSE_US_M = 'LACROSSE_US_M';
+export const COURT_TYPE_LACROSSE_US_W = 'LACROSSE_US_W';
+
+export const COURT_TYPE_SOCCER_FIFA = 'SOCCER_FIFA';
+export const COURT_TYPE_SOCCER_NCAA = 'SOCCER_NCAA';
+export const COURT_TYPE_SOCCER_NFHS = 'SOCCER_NFHS';
+export const COURT_TYPE_SOCCER_U10 = 'SOCCER_U10';
+export const COURT_TYPE_SOCCER_U12 = 'SOCCER_U12';
+export const COURT_TYPE_SOCCER_U19 = 'SOCCER_U19';
+
+export const COURT_TYPE_HOCKEY_NHL = 'HOCKEY_NHL';
+export const COURT_TYPE_HOCKEY_INTERNATIONAL = 'HOCKEY_INTERNATIONAL';
+
+export const COURT_TYPE_BASEBALL_HIGH_SCHOOL = 'BASEBALL_HIGH_SCHOOL';
+
+export const SHAPE_TYPE_CIRCLE = 'CIRCLE';
+export const SHAPE_TYPE_SQUARE = 'SQUARE';
+export const SHAPE_TYPE_TRIANGLE = 'TRIANGLE';
+export const SHAPE_TYPE_FOV = 'FOV';
+export const SHAPE_TYPE_XMARK = 'XMARK';
+export const SHAPE_TYPE_STRAIGHT = 'STRAIGHT';
+export const SHAPE_TYPE_CONE = 'CONE';
+export const SHAPE_TYPE_LINE_CUT = 'LINE.CUT';
+export const SHAPE_TYPE_LINE_SCREEN = 'LINE.SCREEN';
+export const SHAPE_TYPE_LINE_DRIBBLE = 'LINE.DRIBBLE';
+export const SHAPE_TYPE_LINE_PASS = 'LINE.PASS';
+export const SHAPE_TYPE_LINE_HANDOFF = 'LINE.HANDOFF';

package/src/global.d.ts

@@ -0,0 +1,9 @@
+declare module '*.png' {
+  const value: Buffer;
+  export = value;
+}
+
+declare module '*.svg' {
+  const value: Buffer;
+  export = value;
+}

package/src/helpers/common.ts

@@ -0,0 +1,40 @@
+import { ShapeType } from '../types';
+import { ShapeModels } from '../index';
+
+export function animationProgress(globalProgress: number, start: number, end: number) {
+  const max = end - start;
+  const local = globalProgress - start;
+  return (local * 100) / max / 100;
+}
+
+export function rotatePoint(x: number, y: number, cX: number, cY: number, degrees: number) {
+  return {
+    x: (x - cX) * Math.cos((degrees * Math.PI) / 180) - (y - cY) * Math.sin((degrees * Math.PI) / 180) + cX,
+    y: (x - cX) * Math.sin((degrees * Math.PI) / 180) + (y - cY) * Math.cos((degrees * Math.PI) / 180) + cY
+  };
+}
+
+export function transformShapeTypeToImportKey(type: ShapeType): string {
+  if (type.indexOf('LINE.') < 0) return `${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()}Shape`;
+  const typeClean = type.replace('LINE.', '');
+  return `${typeClean.charAt(0).toUpperCase()}${typeClean.slice(1).toLowerCase()}LineShape`;
+}
+
+export function shapeModelKeyFromImport(shapeModels: typeof ShapeModels, type: ShapeType): keyof typeof ShapeModels {
+  return (Object.keys(shapeModels) as (keyof typeof ShapeModels)[]).find(key => {
+    const prefix = type.replace('LINE.', '');
+    const suffix = type.indexOf('LINE.') >= 0 ? 'LineShape' : 'Shape';
+    return key.toLowerCase() === `${prefix}${suffix}`.toLowerCase();
+  });
+}
+
+export async function loadImage(src: string | Buffer) {
+  const img = new Image();
+  if (typeof src === 'string') {
+    img.src = src;
+  } else {
+    img.src = 'data:image/jpeg;base64,' + src.toString('base64');
+  }
+  await img.decode();
+  return img;
+}

package/src/index.ts

@@ -0,0 +1,36 @@
+import PlayModel from './models/PlayModel';
+import FrameModel from './models/FrameModel';
+import AnimationModel from './models/AnimationModel';
+import LineModel from './models/LineModel';
+import PlayerModel from './models/PlayerModel';
+import NoteModel from './models/NoteModel';
+import ShapeModel from './models/ShapeModel';
+import * as ShapeModels from './models/ShapeModels';
+import * as Constants from './constants';
+import * as LineDrawingMath from './math/LineDrawingMath';
+import * as Helpers from './helpers/common';
+import Bezier from './math/Bezier';
+
+import {
+  courtTypeConstants as CourtTypeConstants,
+  sportConstants as SportConstants,
+  sportCourtTypeMap as SportCourtTypeMap
+} from './layers/court';
+
+export {
+  PlayModel,
+  FrameModel,
+  AnimationModel,
+  LineModel,
+  PlayerModel,
+  NoteModel,
+  ShapeModel,
+  ShapeModels,
+  LineDrawingMath,
+  Bezier,
+  Constants,
+  CourtTypeConstants,
+  SportConstants,
+  SportCourtTypeMap,
+  Helpers
+};

package/src/layers/{CourtLayer.js → CourtLayer.ts}

@@ -1,7 +1,7 @@
-const BaseLayer = require('./base/BaseLayer');
-const { sportLayers, courtTypeLayers } = require('./court');
+import BaseLayer from './base/BaseLayer';
+import { courtTypeLayers, sportLayers } from './court';
 
-class CourtLayer extends BaseLayer {
+export default class CourtLayer extends BaseLayer {
   get frameWidth() {
     return this.options.width;
   }
@@ -35,7 +35,7 @@ class CourtLayer extends BaseLayer {
 
     this.setColor();
 
-    Object.values(this.courtTypeLayers).forEach(LayerClass => {
+    (Object.values(this.courtTypeLayers) as any[]).forEach(LayerClass => {
       new LayerClass(this).apply();
     });
 
@@ -105,5 +105,3 @@ class CourtLayer extends BaseLayer {
     }
   }
 }
-
-module.exports = CourtLayer;

package/src/layers/{LineControlPointLayer.js → LineControlPointLayer.ts}

@@ -1,6 +1,6 @@
-const BaseLayer = require('./base/BaseLayer');
+import BaseLayer from './base/BaseLayer';
 
-class LineControlPointLayer extends BaseLayer {
+export default class LineControlPointLayer extends BaseLayer {
   apply() {
     if (!this.options.linesDisplay) return;
 
@@ -29,5 +29,3 @@ class LineControlPointLayer extends BaseLayer {
     this.ctx.restore();
   }
 }
-
-module.exports = LineControlPointLayer;

package/src/layers/{LineLayer.js → LineLayer.ts}

@@ -1,9 +1,9 @@
-const _ = require('lodash');
-const BaseLayer = require('./base/BaseLayer');
-const lineLayers = require('./line');
+import _ from 'lodash';
+import BaseLayer from './base/BaseLayer';
+import * as lineLayers from './line';
 
-class LineLayer extends BaseLayer {
-  get lineWidth() {
+export default class LineLayer extends BaseLayer {
+  get lineWidth(): number {
     return this.courtTypeConstants.LINE_WIDTH;
   }
 
@@ -24,5 +24,3 @@ class LineLayer extends BaseLayer {
     this.ctx.restore();
   }
 }
-
-module.exports = LineLayer;

package/src/layers/{NoteLayer.js → NoteLayer.ts}

@@ -1,8 +1,10 @@
-const _ = require('lodash');
-const BaseLayer = require('./base/BaseLayer');
-const Note = require('../models/Note');
+import _ from 'lodash';
+import BaseLayer from './base/BaseLayer';
+import NoteModel from '../models/NoteModel';
+
+export default class NoteLayer extends BaseLayer {
+  private noteAlpha: number;
 
-class NoteLayer extends BaseLayer {
   apply() {
     this.ctx.save();
 
@@ -28,7 +30,7 @@ class NoteLayer extends BaseLayer {
     this.ctx.restore();
   }
 
-  setNoteAlpha(note) {
+  setNoteAlpha(note: NoteModel) {
     let alpha = 1;
     if (this.options.animationGlobalProgress) {
       alpha = 0;
@@ -59,7 +61,7 @@ class NoteLayer extends BaseLayer {
     this.noteAlpha = alpha;
   }
 
-  setColor(note) {
+  setColor(note: NoteModel) {
     const { alpha, blue, green, red } = note.color;
 
     const r = Math.ceil(red * 255);
@@ -75,12 +77,12 @@ class NoteLayer extends BaseLayer {
     }
   }
 
-  setFont(note) {
+  setFont(note: NoteModel) {
     this.ctx.font = note.fontComputed;
     this.ctx.textBaseline = note.textBaseline;
   }
 
-  drawBubble(note, { width, height }) {
+  drawBubble(note: NoteModel, { width, height }) {
     this.ctx.lineWidth = this.courtTypeConstants.COURT_LINE_WIDTH;
     this.ctx.beginPath();
     this.ctx.rect(0, 0, width, height);
@@ -90,11 +92,11 @@ class NoteLayer extends BaseLayer {
     }
   }
 
-  drawText(note, lines) {
+  drawText(note: NoteModel, lines) {
     lines.forEach(({ words }, index) => {
       this.ctx.save();
 
-      this.ctx.translate(Note.NOTE_WRAP_PADDING, Note.NOTE_WRAP_PADDING + note.lineHeight * index);
+      this.ctx.translate(NoteModel.NOTE_WRAP_PADDING, NoteModel.NOTE_WRAP_PADDING + note.lineHeight * index);
 
       let wordStartX = 0;
       words.forEach((word, i) => {
@@ -129,12 +131,12 @@ class NoteLayer extends BaseLayer {
         this.ctx.strokeStyle = `rgba(0, 0, 0, ${this.noteAlpha})`;
         this.ctx.beginPath();
         if (note.font.underline) {
-          this.ctx.moveTo(0, note.fontSize - Note.NOTE_LINE_HEIGHT_OFFSET / 2);
-          this.ctx.lineTo(wordStartX, note.fontSize - Note.NOTE_LINE_HEIGHT_OFFSET / 2);
+          this.ctx.moveTo(0, note.fontSize - NoteModel.NOTE_LINE_HEIGHT_OFFSET / 2);
+          this.ctx.lineTo(wordStartX, note.fontSize - NoteModel.NOTE_LINE_HEIGHT_OFFSET / 2);
         }
         if (note.font.strikethrough) {
-          this.ctx.moveTo(0, note.lineHeight / 2 - Note.NOTE_LINE_HEIGHT_OFFSET / 3);
-          this.ctx.lineTo(wordStartX, note.lineHeight / 2 - Note.NOTE_LINE_HEIGHT_OFFSET / 3);
+          this.ctx.moveTo(0, note.lineHeight / 2 - NoteModel.NOTE_LINE_HEIGHT_OFFSET / 3);
+          this.ctx.lineTo(wordStartX, note.lineHeight / 2 - NoteModel.NOTE_LINE_HEIGHT_OFFSET / 3);
         }
         this.ctx.stroke();
       }
@@ -143,7 +145,7 @@ class NoteLayer extends BaseLayer {
     });
   }
 
-  drawPlayerToken(note, x, label) {
+  drawPlayerToken(note: NoteModel, x: number, label: string) {
     this.ctx.save();
 
     this.ctx.translate(x + note.playerTokenRadius, 0);
@@ -158,16 +160,14 @@ class NoteLayer extends BaseLayer {
     const playerFontSize = note.fontSize * 0.8;
     this.ctx.font = `${playerFontSize}px Arial`;
     const textX = -this.ctx.measureText(label).width / 2;
-    const textY = ((note.playerTokenRadius * 2 - playerFontSize) / 2) * (1 + Note.NOTE_LINE_HEIGHT_OFFSET);
+    const textY = ((note.playerTokenRadius * 2 - playerFontSize) / 2) * (1 + NoteModel.NOTE_LINE_HEIGHT_OFFSET);
     this.ctx.fillStyle = `rgba(255, 255, 255, ${this.noteAlpha})`;
     this.ctx.fillText(label, textX, textY);
 
     this.ctx.restore();
   }
 
-  scale(value) {
+  scale(value: number) {
     return value / this.options.scale;
   }
 }
-
-module.exports = NoteLayer;

package/src/layers/{PlayerLayer.js → PlayerLayer.ts}

@@ -1,6 +1,7 @@
-const BaseLayer = require('./base/BaseLayer');
+import BaseLayer from './base/BaseLayer';
+import PlayerModel from '../models/PlayerModel';
 
-class PlayerLayer extends BaseLayer {
+export default class PlayerLayer extends BaseLayer {
   get staticData() {
     return this.options.staticData;
   }
@@ -60,7 +61,7 @@ class PlayerLayer extends BaseLayer {
     this.ctx.restore();
   }
 
-  setPlayerPuckStyle(player) {
+  setPlayerPuckStyle(player: PlayerModel) {
     const { red, green, blue, alpha } = player.color;
 
     const isDefaultInputColor = red === 0 && green === 0 && blue === 0 && alpha === 1;
@@ -86,7 +87,7 @@ class PlayerLayer extends BaseLayer {
     this.ctx.strokeStyle = color;
   }
 
-  drawPlayerPuck(player) {
+  drawPlayerPuck(player: PlayerModel) {
     const { x, y } = player.location;
     this.ctx.beginPath();
     this.ctx.arc(x, y, this.radius, 0, Math.PI * 2, true);
@@ -97,7 +98,7 @@ class PlayerLayer extends BaseLayer {
     this.ctx.fill();
   }
 
-  setPlayerLabel(player) {
+  setPlayerLabel(player: PlayerModel) {
     const { x, y } = player.location;
     const { alpha } = player.color;
 
@@ -143,5 +144,3 @@ class PlayerLayer extends BaseLayer {
     }
   }
 }
-
-module.exports = PlayerLayer;

package/src/layers/{ShapeControlPointLayer.js → ShapeControlPointLayer.ts}

@@ -1,6 +1,6 @@
-const BaseLayer = require('./base/BaseLayer');
+import BaseLayer from './base/BaseLayer';
 
-class ShapeControlPointLayer extends BaseLayer {
+export default class ShapeControlPointLayer extends BaseLayer {
   apply() {
     this.ctx.save();
 
@@ -20,5 +20,3 @@ class ShapeControlPointLayer extends BaseLayer {
     this.ctx.restore();
   }
 }
-
-module.exports = ShapeControlPointLayer;

package/src/layers/{ShapeLayer.js → ShapeLayer.ts}

@@ -1,8 +1,8 @@
-const _ = require('lodash');
-const BaseLayer = require('./base/BaseLayer');
-const shapeLayers = require('./shape');
+import _ from 'lodash';
+import BaseLayer from './base/BaseLayer';
+import * as shapeLayers from './shape';
 
-class ShapeLayer extends BaseLayer {
+export default class ShapeLayer extends BaseLayer {
   apply() {
     this.ctx.save();
 
@@ -19,5 +19,3 @@ class ShapeLayer extends BaseLayer {
     this.ctx.restore();
   }
 }
-
-module.exports = ShapeLayer;

package/src/layers/base/BaseLayer.ts

@@ -0,0 +1,15 @@
+import { FrameData, FrameDataOptions } from '../../models/FrameModel';
+import { CourtTypeConstants, courtTypeConstants, SportConstants, sportConstants } from '../court';
+
+export default class BaseLayer {
+  constructor(public ctx: CanvasRenderingContext2D, public playData: FrameData, public options: FrameDataOptions) {}
+
+  get courtTypeConstants(): SportConstants & CourtTypeConstants {
+    if (!sportConstants[this.playData.sport]) throw new Error('unknown sport type constants');
+    if (!courtTypeConstants[this.playData.court.type]) throw new Error('unknown court type constants');
+    return {
+      ...sportConstants[this.playData.sport],
+      ...courtTypeConstants[this.playData.court.type]
+    };
+  }
+}

package/src/layers/base/InternalBaseLayer.ts

@@ -0,0 +1,29 @@
+import BaseLayer from './BaseLayer';
+import { FrameData, FrameDataOptions } from '../../models/FrameModel';
+import { CourtTypeConstants, SportConstants } from '../court';
+
+export default class InternalBaseLayer {
+  protected ctx: CanvasRenderingContext2D;
+  protected playData: FrameData;
+  protected options: Partial<FrameDataOptions>;
+  protected courtTypeConstants: SportConstants & CourtTypeConstants;
+
+  constructor(parentLayer: BaseLayer) {
+    this.ctx = parentLayer.ctx;
+    this.playData = parentLayer.playData;
+    this.options = parentLayer.options ? parentLayer.options : {};
+    this.courtTypeConstants = parentLayer.courtTypeConstants;
+  }
+
+  apply() {
+    this.ctx.save();
+
+    this.drawLogic();
+
+    this.ctx.restore();
+  }
+
+  drawLogic() {
+    // Override this
+  }
+}

package/src/layers/court/base/{InternalCourtLayer.js → InternalCourtLayer.ts}

@@ -1,6 +1,6 @@
-const InternalBaseLayer = require('../../base/InternalBaseLayer');
+import InternalBaseLayer from '../../base/InternalBaseLayer';
 
-class InternalCourtLayer extends InternalBaseLayer {
+export default class InternalCourtLayer extends InternalBaseLayer {
   get courtCenter() {
     return {
       x: this.courtTypeConstants.COURT_RECT_WIDTH / 2,
@@ -36,11 +36,9 @@ class InternalCourtLayer extends InternalBaseLayer {
     this.ctx.translate(0, -Math.abs(verticalTranslationDist));
   }
 
-  setColor(color) {
+  setColor(color: string) {
     const style = this.options.lineColor === 'transparent' ? 'transparent' : color;
     this.ctx.strokeStyle = style;
     this.ctx.fillStyle = style;
   }
 }
-
-module.exports = InternalCourtLayer;

package/src/layers/court/index.ts

@@ -0,0 +1,213 @@
+import { CourtType, SportType } from '../../types';
+import {
+  COURT_TYPE_BASEBALL_HIGH_SCHOOL,
+  COURT_TYPE_BIG3,
+  COURT_TYPE_FIBA,
+  COURT_TYPE_FOOTBALL_HIGH_SCHOOL,
+  COURT_TYPE_FOOTBALL_HIGH_SCHOOL_LEGACY,
+  COURT_TYPE_HOCKEY_INTERNATIONAL,
+  COURT_TYPE_HOCKEY_NHL,
+  COURT_TYPE_LACROSSE_US_M,
+  COURT_TYPE_LACROSSE_US_W,
+  COURT_TYPE_NBA,
+  COURT_TYPE_NCAAM,
+  COURT_TYPE_NCAAW,
+  COURT_TYPE_SOCCER_FIFA,
+  COURT_TYPE_SOCCER_NCAA,
+  COURT_TYPE_SOCCER_NFHS,
+  COURT_TYPE_SOCCER_U10,
+  COURT_TYPE_SOCCER_U12,
+  COURT_TYPE_SOCCER_U19,
+  COURT_TYPE_US_HIGH_SCHOOL,
+  COURT_TYPE_US_JUNIOR_HIGH,
+  COURT_TYPE_VOLLEYBALL_INDOOR,
+  COURT_TYPE_WNBA,
+  SPORT_TYPE_BASEBALL,
+  SPORT_TYPE_BASKETBALL,
+  SPORT_TYPE_FOOTBALL,
+  SPORT_TYPE_HOCKEY,
+  SPORT_TYPE_LACROSSE,
+  SPORT_TYPE_SOCCER,
+  SPORT_TYPE_VOLLEYBALL
+} from '../../constants';
+
+export type SportConstants = {
+  COURT_LINE_WIDTH: number;
+  PLAYER_TOKEN_RADIUS: number;
+  PLAYER_TOKEN_SCALE: number;
+  LINE_WIDTH: number;
+  LINE_MASKING: boolean;
+};
+
+export type CourtTypeConstants = {
+  COURT_RECT_WIDTH: number;
+  COURT_RECT_HEIGHT: number;
+} & Record<string, any>;
+
+import InternalCourtLayer from './base/InternalCourtLayer';
+
+import * as BaseballLayers from './layers/BASEBALL/layers';
+import * as BaseballConstants from './layers/BASEBALL/constants';
+import * as BaseballHighSchoolLayers from './layers/BASEBALL/courtTypes/BASEBALL_HIGH_SCHOOL/layers';
+import * as BaseballHighSchoolConstants from './layers/BASEBALL/courtTypes/BASEBALL_HIGH_SCHOOL/constants';
+
+import * as BasketballLayers from './layers/BASKETBALL/layers';
+import * as BasketballConstants from './layers/BASKETBALL/constants';
+import * as BasketballBig3Layers from './layers/BASKETBALL/courtTypes/BIG3/layers';
+import * as BasketballBig3Constants from './layers/BASKETBALL/courtTypes/BIG3/constants';
+import * as BasketballFibaLayers from './layers/BASKETBALL/courtTypes/FIBA/layers';
+import * as BasketballFibaConstants from './layers/BASKETBALL/courtTypes/FIBA/constants';
+import * as BasketballNbaLayers from './layers/BASKETBALL/courtTypes/NBA/layers';
+import * as BasketballNbaConstants from './layers/BASKETBALL/courtTypes/NBA/constants';
+import * as BasketballNcaamLayers from './layers/BASKETBALL/courtTypes/NCAAM/layers';
+import * as BasketballNcaamConstants from './layers/BASKETBALL/courtTypes/NCAAM/constants';
+import * as BasketballNcaawLayers from './layers/BASKETBALL/courtTypes/NCAAW/layers';
+import * as BasketballNcaawConstants from './layers/BASKETBALL/courtTypes/NCAAW/constants';
+import * as BasketballUsHsLayers from './layers/BASKETBALL/courtTypes/US_HIGH_SCHOOL/layers';
+import * as BasketballUsHsConstants from './layers/BASKETBALL/courtTypes/US_HIGH_SCHOOL/constants';
+import * as BasketballUsJhLayers from './layers/BASKETBALL/courtTypes/US_JUNIOR_HIGH/layers';
+import * as BasketballUsJhConstants from './layers/BASKETBALL/courtTypes/US_JUNIOR_HIGH/constants';
+import * as BasketballWnbaLayers from './layers/BASKETBALL/courtTypes/WNBA/layers';
+import * as BasketballWnbaConstants from './layers/BASKETBALL/courtTypes/WNBA/constants';
+
+import * as FootballLayers from './layers/FOOTBALL/layers';
+import * as FootballConstants from './layers/FOOTBALL/constants';
+import * as FootballHsConstants from './layers/FOOTBALL/courtTypes/FOOTBALL_HIGH_SCHOOL/constants';
+
+import * as HockeyLayers from './layers/HOCKEY/layers';
+import * as HockeyConstants from './layers/HOCKEY/constants';
+import * as HockeyNhlLayers from './layers/HOCKEY/courtTypes/HOCKEY_NHL/layers';
+import * as HockeyNhlConstants from './layers/HOCKEY/courtTypes/HOCKEY_NHL/constants';
+import * as HockeyIntLayers from './layers/HOCKEY/courtTypes/HOCKEY_INTERNATIONAL/layers';
+import * as HockeyIntConstants from './layers/HOCKEY/courtTypes/HOCKEY_INTERNATIONAL/constants';
+
+import * as LacrosseLayers from './layers/LACROSSE/layers';
+import * as LacrosseConstants from './layers/LACROSSE/constants';
+import * as LacrosseUsMLayers from './layers/LACROSSE/courtTypes/LACROSSE_US_M/layers';
+import * as LacrosseUsMConstants from './layers/LACROSSE/courtTypes/LACROSSE_US_M/constants';
+import * as LacrosseUsWLayers from './layers/LACROSSE/courtTypes/LACROSSE_US_W/layers';
+import * as LacrosseUsWConstants from './layers/LACROSSE/courtTypes/LACROSSE_US_W/constants';
+
+import * as SoccerLayers from './layers/SOCCER/layers';
+import * as SoccerConstants from './layers/SOCCER/constants';
+import * as SoccerU19Constants from './layers/SOCCER/courtTypes/SOCCER_U19/constants';
+import * as SoccerFifaConstants from './layers/SOCCER/courtTypes/SOCCER_FIFA/constants';
+import * as SoccerNcaaLayers from './layers/SOCCER/courtTypes/SOCCER_NCAA/layers';
+import * as SoccerNcaaConstants from './layers/SOCCER/courtTypes/SOCCER_NCAA/constants';
+import * as SoccerNfhsLayers from './layers/SOCCER/courtTypes/SOCCER_NFHS/layers';
+import * as SoccerNfhsConstants from './layers/SOCCER/courtTypes/SOCCER_NFHS/constants';
+import * as SoccerU10Layers from './layers/SOCCER/courtTypes/SOCCER_U10/layers';
+import * as SoccerU10Constants from './layers/SOCCER/courtTypes/SOCCER_U10/constants';
+import * as SoccerU12Layers from './layers/SOCCER/courtTypes/SOCCER_U12/layers';
+import * as SoccerU12Constants from './layers/SOCCER/courtTypes/SOCCER_U12/constants';
+
+import * as VolleyballLayers from './layers/VOLLEYBALL/layers';
+import * as VolleyballConstants from './layers/VOLLEYBALL/constants';
+import * as VolleyballIndoorConstants from './layers/VOLLEYBALL/courtTypes/VOLLEYBALL_INDOOR/constants';
+
+const sportLayers: Record<SportType, Record<string, typeof InternalCourtLayer>> = {
+  [SPORT_TYPE_BASEBALL]: BaseballLayers,
+  [SPORT_TYPE_BASKETBALL]: BasketballLayers,
+  [SPORT_TYPE_FOOTBALL]: FootballLayers,
+  [SPORT_TYPE_HOCKEY]: HockeyLayers,
+  [SPORT_TYPE_LACROSSE]: LacrosseLayers,
+  [SPORT_TYPE_SOCCER]: SoccerLayers,
+  [SPORT_TYPE_VOLLEYBALL]: VolleyballLayers
+};
+
+const courtTypeLayers: Record<SportType, Partial<Record<CourtType, Record<string, typeof InternalCourtLayer>>>> = {
+  [SPORT_TYPE_BASEBALL]: {
+    [COURT_TYPE_BASEBALL_HIGH_SCHOOL]: BaseballHighSchoolLayers
+  },
+  [SPORT_TYPE_BASKETBALL]: {
+    [COURT_TYPE_BIG3]: BasketballBig3Layers,
+    [COURT_TYPE_FIBA]: BasketballFibaLayers,
+    [COURT_TYPE_NBA]: BasketballNbaLayers,
+    [COURT_TYPE_NCAAM]: BasketballNcaamLayers,
+    [COURT_TYPE_NCAAW]: BasketballNcaawLayers,
+    [COURT_TYPE_US_HIGH_SCHOOL]: BasketballUsHsLayers,
+    [COURT_TYPE_US_JUNIOR_HIGH]: BasketballUsJhLayers,
+    [COURT_TYPE_WNBA]: BasketballWnbaLayers
+  },
+  [SPORT_TYPE_FOOTBALL]: {},
+  [SPORT_TYPE_HOCKEY]: {
+    [COURT_TYPE_HOCKEY_NHL]: HockeyNhlLayers,
+    [COURT_TYPE_HOCKEY_INTERNATIONAL]: HockeyIntLayers
+  },
+  [SPORT_TYPE_LACROSSE]: {
+    [COURT_TYPE_LACROSSE_US_M]: LacrosseUsMLayers,
+    [COURT_TYPE_LACROSSE_US_W]: LacrosseUsWLayers
+  },
+  [SPORT_TYPE_SOCCER]: {
+    [COURT_TYPE_SOCCER_NCAA]: SoccerNcaaLayers,
+    [COURT_TYPE_SOCCER_NFHS]: SoccerNfhsLayers,
+    [COURT_TYPE_SOCCER_U10]: SoccerU10Layers,
+    [COURT_TYPE_SOCCER_U12]: SoccerU12Layers
+  },
+  [SPORT_TYPE_VOLLEYBALL]: {}
+};
+
+const sportConstants: Record<SportType, SportConstants> = {
+  [SPORT_TYPE_BASEBALL]: BaseballConstants,
+  [SPORT_TYPE_BASKETBALL]: BasketballConstants,
+  [SPORT_TYPE_FOOTBALL]: FootballConstants,
+  [SPORT_TYPE_HOCKEY]: HockeyConstants,
+  [SPORT_TYPE_LACROSSE]: LacrosseConstants,
+  [SPORT_TYPE_SOCCER]: SoccerConstants,
+  [SPORT_TYPE_VOLLEYBALL]: VolleyballConstants
+};
+const courtTypeConstants: Record<CourtType, CourtTypeConstants> = {
+  [COURT_TYPE_BASEBALL_HIGH_SCHOOL]: BaseballHighSchoolConstants,
+  [COURT_TYPE_BIG3]: BasketballBig3Constants,
+  [COURT_TYPE_FIBA]: BasketballFibaConstants,
+  [COURT_TYPE_NBA]: BasketballNbaConstants,
+  [COURT_TYPE_NCAAM]: BasketballNcaamConstants,
+  [COURT_TYPE_NCAAW]: BasketballNcaawConstants,
+  [COURT_TYPE_US_HIGH_SCHOOL]: BasketballUsHsConstants,
+  [COURT_TYPE_US_JUNIOR_HIGH]: BasketballUsJhConstants,
+  [COURT_TYPE_WNBA]: BasketballWnbaConstants,
+  [COURT_TYPE_FOOTBALL_HIGH_SCHOOL_LEGACY]: FootballHsConstants,
+  [COURT_TYPE_FOOTBALL_HIGH_SCHOOL]: FootballHsConstants,
+  [COURT_TYPE_HOCKEY_NHL]: HockeyNhlConstants,
+  [COURT_TYPE_HOCKEY_INTERNATIONAL]: HockeyIntConstants,
+  [COURT_TYPE_LACROSSE_US_M]: LacrosseUsMConstants,
+  [COURT_TYPE_LACROSSE_US_W]: LacrosseUsWConstants,
+  [COURT_TYPE_SOCCER_FIFA]: SoccerFifaConstants,
+  [COURT_TYPE_SOCCER_NCAA]: SoccerNcaaConstants,
+  [COURT_TYPE_SOCCER_NFHS]: SoccerNfhsConstants,
+  [COURT_TYPE_SOCCER_U10]: SoccerU10Constants,
+  [COURT_TYPE_SOCCER_U12]: SoccerU12Constants,
+  [COURT_TYPE_SOCCER_U19]: SoccerU19Constants,
+  [COURT_TYPE_VOLLEYBALL_INDOOR]: VolleyballIndoorConstants
+};
+const sportCourtTypeMap: Record<SportType, { courtTypes: CourtType[] }> = {
+  [SPORT_TYPE_BASEBALL]: { courtTypes: [COURT_TYPE_BASEBALL_HIGH_SCHOOL] },
+  [SPORT_TYPE_BASKETBALL]: {
+    courtTypes: [
+      COURT_TYPE_BIG3,
+      COURT_TYPE_FIBA,
+      COURT_TYPE_NBA,
+      COURT_TYPE_NCAAM,
+      COURT_TYPE_NCAAW,
+      COURT_TYPE_US_HIGH_SCHOOL,
+      COURT_TYPE_US_JUNIOR_HIGH,
+      COURT_TYPE_WNBA
+    ]
+  },
+  [SPORT_TYPE_FOOTBALL]: { courtTypes: [COURT_TYPE_FOOTBALL_HIGH_SCHOOL] },
+  [SPORT_TYPE_HOCKEY]: { courtTypes: [COURT_TYPE_HOCKEY_NHL, COURT_TYPE_HOCKEY_INTERNATIONAL] },
+  [SPORT_TYPE_LACROSSE]: { courtTypes: [COURT_TYPE_LACROSSE_US_M, COURT_TYPE_LACROSSE_US_W] },
+  [SPORT_TYPE_SOCCER]: {
+    courtTypes: [
+      COURT_TYPE_SOCCER_FIFA,
+      COURT_TYPE_SOCCER_NCAA,
+      COURT_TYPE_SOCCER_NFHS,
+      COURT_TYPE_SOCCER_U10,
+      COURT_TYPE_SOCCER_U12,
+      COURT_TYPE_SOCCER_U19
+    ]
+  },
+  [SPORT_TYPE_VOLLEYBALL]: { courtTypes: [COURT_TYPE_VOLLEYBALL_INDOOR] }
+};
+
+export { sportLayers, courtTypeLayers, sportConstants, courtTypeConstants, sportCourtTypeMap };

package/src/layers/court/layers/BASEBALL/constants.ts

@@ -0,0 +1,5 @@
+export const COURT_LINE_WIDTH = 0.1667;
+export const PLAYER_TOKEN_RADIUS = 1.5;
+export const PLAYER_TOKEN_SCALE = 2;
+export const LINE_WIDTH = 0.55;
+export const LINE_MASKING = false;