volleyballsimtypes 0.0.98 → 0.0.99

package/dist/esm/src/data/models/trait.js

@@ -10,26 +10,6 @@ export class TraitModel extends Model {
             name: {
                 type: DataTypes.STRING,
                 allowNull: false
-            },
-            modifier: {
-                type: DataTypes.REAL,
-                allowNull: false
-            },
-            chance: {
-                type: DataTypes.REAL,
-                allowNull: false
-            },
-            threshold: {
-                type: DataTypes.INTEGER,
-                allowNull: false
-            },
-            weight: {
-                type: DataTypes.INTEGER,
-                allowNull: false
-            },
-            general_stat: {
-                type: DataTypes.ENUM('Attack', 'Defense', 'Physical', 'Serve'),
-                allowNull: false
             }
         }, {
             sequelize,

package/dist/esm/src/data/transformers/block.js

@@ -1,5 +1,5 @@
 import { Block, BlockFailureEnum, BlockTypeEnum } from '../../service';
-import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer, transformToTrait } from '.';
+import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer } from '.';
 function transformToBlockFailure(failure) {
     switch (failure) {
         case BlockFailureEnum.NO_FAILURE:
@@ -39,26 +39,18 @@ function transformFromBlockType(type) {
     return BlockTypeEnum[type];
 }
 function transformToAttributes(event, rallyId) {
-    const eventTraits = event.activeTraits.map(trait => ({
-        block_id: event.id,
-        trait_id: trait.id,
-        event_id: event.id
-    }));
     return {
         event_id: event.id,
         player_id: event.player.id,
         rally_id: rallyId,
         order: event.order,
-        modifier: event.modifier,
-        score: event.score,
         target: transformFromCourtTarget(event.target),
         failure: transformToBlockFailure(event.failure),
         type: transformToBlockType(event.type),
         event_type: transformFromEventType(event.eventType),
         blocker_1: event.blockers[0]?.id,
         blocker_2: event.blockers[1]?.id,
-        blocker_3: event.blockers[2]?.id,
-        EventTraits: eventTraits
+        blocker_3: event.blockers[2]?.id
     };
 }
 function transformToObject(model) {
@@ -69,11 +61,11 @@ function transformToObject(model) {
         type: transformFromBlockType(model.type),
         player: transformToPlayer(model.player),
         target: transformToCourtTarget(model.target),
-        modifier: model.modifier,
         order: model.order,
-        score: model.score,
         blockers: [],
-        activeTraits: model.Traits.map(transformToTrait)
+        modifier: 1,
+        score: 1,
+        activeTraits: []
     });
     if (model.Blocker_1 != null)
         block.blockers.push(transformToPlayer(model.Blocker_1));
@@ -91,9 +83,7 @@ function transformToAPIObject(model) {
         type: transformFromBlockType(model.type),
         playerId: model.player_id,
         target: transformToCourtTarget(model.target),
-        modifier: model.modifier,
         order: model.order,
-        score: model.score,
         blockers: []
     };
     if (model.blocker_1 != null)

package/dist/esm/src/data/transformers/reception.js

@@ -1,5 +1,5 @@
 import { Reception, ReceptionFailureEnum, ReceptionTypeEnum } from '../../service';
-import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer, transformToTrait } from '.';
+import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer } from '.';
 function transformToReceptionFailure(failure) {
     switch (failure) {
         case ReceptionFailureEnum.NO_FAILURE:
@@ -37,23 +37,15 @@ function transformFromReceptionType(type) {
     return ReceptionTypeEnum[type];
 }
 function transformToAttributes(event, rallyId) {
-    const eventTraits = event.activeTraits.map(trait => ({
-        event_id: event.id,
-        reception_id: event.id,
-        trait_id: trait.id
-    }));
     return {
         event_id: event.id,
         player_id: event.player.id,
         rally_id: rallyId,
         order: event.order,
-        modifier: event.modifier,
-        score: event.score,
         target: transformFromCourtTarget(event.target),
         failure: transformToReceptionFailure(event.failure),
         type: transformToReceptionType(event.type),
         event_type: transformFromEventType(event.eventType),
-        EventTraits: eventTraits
     };
 }
 function transformToObject(reception) {
@@ -64,10 +56,10 @@ function transformToObject(reception) {
         type: transformFromReceptionType(reception.type),
         player: transformToPlayer(reception.player),
         target: transformToCourtTarget(reception.target),
-        modifier: reception.modifier,
         order: reception.order,
-        score: reception.score,
-        activeTraits: reception.Traits.map(transformToTrait)
+        modifier: 1,
+        score: 1,
+        activeTraits: []
     });
 }
 function transformToAPIObject(event) {
@@ -78,9 +70,7 @@ function transformToAPIObject(event) {
         type: transformFromReceptionType(event.type),
         playerId: event.player_id,
         target: transformToCourtTarget(event.target),
-        modifier: event.modifier,
-        order: event.order,
-        score: event.score
+        order: event.order
     };
 }
 export { transformToObject as transformToReception, transformToAPIObject as transformToAPIReception, transformToAttributes as transformFromReception };

package/dist/esm/src/data/transformers/serve.js

@@ -1,5 +1,5 @@
 import { Serve, ServeFailureEnum, ServeTypeEnum } from '../../service';
-import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer, transformToTrait } from '.';
+import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer } from '.';
 function transformToServeFailure(failure) {
     switch (failure) {
         case ServeFailureEnum.NO_FAILURE:
@@ -39,23 +39,15 @@ function transformFromServeType(type) {
     return ServeTypeEnum[type];
 }
 function transformToAttributes(event, rallyId) {
-    const eventTraits = event.activeTraits.map(trait => ({
-        event_id: event.id,
-        serve_id: event.id,
-        trait_id: trait.id
-    }));
     return {
         event_id: event.id,
         player_id: event.player.id,
         rally_id: rallyId,
         order: event.order,
-        modifier: event.modifier,
-        score: event.score,
         target: transformFromCourtTarget(event.target),
         failure: transformToServeFailure(event.failure),
         type: transformToServeType(event.type),
         event_type: transformFromEventType(event.eventType),
-        EventTraits: eventTraits
     };
 }
 function transformToObject(serve) {
@@ -66,10 +58,10 @@ function transformToObject(serve) {
         type: transformFromServeType(serve.type),
         player: transformToPlayer(serve.player),
         target: transformToCourtTarget(serve.target),
-        modifier: serve.modifier,
         order: serve.order,
-        score: serve.score,
-        activeTraits: serve.Traits.map(transformToTrait)
+        modifier: 1,
+        score: 1,
+        activeTraits: []
     });
 }
 function transformToAPIObject(event) {
@@ -80,9 +72,7 @@ function transformToAPIObject(event) {
         type: transformFromServeType(event.type),
         playerId: event.player_id,
         target: transformToCourtTarget(event.target),
-        modifier: event.modifier,
-        order: event.order,
-        score: event.score
+        order: event.order
     };
 }
 export { transformToObject as transformToServe, transformToAPIObject as transformToAPIServe, transformToAttributes as transformFromServe };

package/dist/esm/src/data/transformers/set.js

@@ -1,5 +1,5 @@
 import { Set, SetFailureEnum, SetTypeEnum } from '../../service';
-import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer, transformToTrait } from '.';
+import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer } from '.';
 function transformToSetFailure(failure) {
     switch (failure) {
         case SetFailureEnum.NO_FAILURE:
@@ -37,23 +37,15 @@ function transformFromSetType(type) {
     return SetTypeEnum[type];
 }
 function transformToAttributes(event, rallyId) {
-    const eventTraits = event.activeTraits.map(trait => ({
-        event_id: event.id,
-        set_id: event.id,
-        trait_id: trait.id
-    }));
     return {
         event_id: event.id,
         player_id: event.player.id,
         rally_id: rallyId,
         order: event.order,
-        modifier: event.modifier,
-        score: event.score,
         target: transformFromCourtTarget(event.target),
         failure: transformToSetFailure(event.failure),
         type: transformToSetType(event.type),
-        event_type: transformFromEventType(event.eventType),
-        EventTraits: eventTraits
+        event_type: transformFromEventType(event.eventType)
     };
 }
 function transformToObject(set) {
@@ -64,10 +56,10 @@ function transformToObject(set) {
         type: transformFromSetType(set.type),
         player: transformToPlayer(set.player),
         target: transformToCourtTarget(set.target),
-        modifier: set.modifier,
         order: set.order,
-        score: set.score,
-        activeTraits: set.Traits.map(transformToTrait)
+        modifier: 1,
+        score: 1,
+        activeTraits: []
     });
 }
 function transformToAPIObject(event) {
@@ -78,9 +70,7 @@ function transformToAPIObject(event) {
         type: transformFromSetType(event.type),
         playerId: event.player_id,
         target: transformToCourtTarget(event.target),
-        modifier: event.modifier,
-        order: event.order,
-        score: event.score
+        order: event.order
     };
 }
 export { transformToObject as transformToSet, transformToAPIObject as transformToAPISet, transformToAttributes as transformFromSet };

package/dist/esm/src/data/transformers/spike.js

@@ -1,5 +1,5 @@
 import { Spike, SpikeFailureEnum, SpikeTypeEnum } from '../../service';
-import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer, transformToTrait } from '.';
+import { transformFromCourtTarget, transformFromEventType, transformToCourtTarget, transformToEventType, transformToPlayer } from '.';
 function transformToSpikeFailure(failure) {
     switch (failure) {
         case SpikeFailureEnum.NO_FAILURE:
@@ -41,23 +41,15 @@ function transformFromSpikeType(type) {
     return SpikeTypeEnum[type];
 }
 function transformToAttributes(event, rallyId) {
-    const eventTraits = event.activeTraits.map(trait => ({
-        event_id: event.id,
-        spike_id: event.id,
-        trait_id: trait.id
-    }));
     return {
         event_id: event.id,
         player_id: event.player.id,
         rally_id: rallyId,
         order: event.order,
-        modifier: event.modifier,
-        score: event.score,
         target: transformFromCourtTarget(event.target),
         failure: transformToSpikeFailure(event.failure),
         type: transformToSpikeType(event.type),
-        event_type: transformFromEventType(event.eventType),
-        EventTraits: eventTraits
+        event_type: transformFromEventType(event.eventType)
     };
 }
 function transformToObject(spike) {
@@ -68,10 +60,10 @@ function transformToObject(spike) {
         type: transformFromSpikeType(spike.type),
         player: transformToPlayer(spike.player),
         target: transformToCourtTarget(spike.target),
-        modifier: spike.modifier,
         order: spike.order,
-        score: spike.score,
-        activeTraits: spike.Traits.map(transformToTrait)
+        modifier: 1,
+        score: 1,
+        activeTraits: []
     });
 }
 function transformToAPIObject(event) {
@@ -82,9 +74,7 @@ function transformToAPIObject(event) {
         type: transformFromSpikeType(event.type),
         playerId: event.player_id,
         target: transformToCourtTarget(event.target),
-        modifier: event.modifier,
         order: event.order,
-        score: event.score
     };
 }
 export { transformToObject as transformToSpike, transformToAPIObject as transformToAPISpike, transformToAttributes as transformFromSpike };

package/dist/esm/src/data/transformers/trait.js

@@ -3,12 +3,7 @@ import { APITrait } from '../../api';
 function transformToAttributes(trait) {
     return {
         trait_id: trait.id,
-        name: trait.name,
-        modifier: trait.modifier,
-        chance: trait.chance,
-        weight: trait.weight,
-        threshold: trait.statThreshold,
-        general_stat: trait.stat
+        name: trait.name
     };
 }
 function transformToAPIObject(model) {

package/package.json

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

package/dist/cjs/src/data/models/event-trait.d.ts

@@ -1,50 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { Model, Optional } from 'sequelize';
-import type { BlockId, BlockModel, ReceptionId, ReceptionModel, ServeId, ServeModel, SetId, SetModel, SpikeId, SpikeModel, TraitId, TraitModel } from '.';
-export interface EventTraitAttributes {
-    block_id?: string;
-    reception_id?: string;
-    serve_id?: string;
-    set_id?: string;
-    spike_id?: string;
-    event_id: string;
-    trait_id: string;
-}
-export type EventTraitPk = 'event_id' | 'trait_id';
-export type EventTraitId = EventTraitModel[EventTraitPk];
-export type EventTraitOptionalAttributes = 'block_id' | 'reception_id' | 'serve_id' | 'set_id' | 'spike_id';
-export type EventTraitCreationAttributes = Optional<EventTraitAttributes, EventTraitOptionalAttributes>;
-export declare class EventTraitModel extends Model<EventTraitAttributes, EventTraitCreationAttributes> implements EventTraitAttributes {
-    block_id?: string;
-    reception_id?: string;
-    serve_id?: string;
-    set_id?: string;
-    spike_id?: string;
-    event_id: string;
-    trait_id: string;
-    Block: BlockModel;
-    getBlock: Sequelize.BelongsToGetAssociationMixin<BlockModel>;
-    setBlock: Sequelize.BelongsToSetAssociationMixin<BlockModel, BlockId>;
-    createBlock: Sequelize.BelongsToCreateAssociationMixin<BlockModel>;
-    Reception: ReceptionModel;
-    getReception: Sequelize.BelongsToGetAssociationMixin<ReceptionModel>;
-    setReception: Sequelize.BelongsToSetAssociationMixin<ReceptionModel, ReceptionId>;
-    createReception: Sequelize.BelongsToCreateAssociationMixin<ReceptionModel>;
-    Serve: ServeModel;
-    getServe: Sequelize.BelongsToGetAssociationMixin<ServeModel>;
-    setServe: Sequelize.BelongsToSetAssociationMixin<ServeModel, ServeId>;
-    createServe: Sequelize.BelongsToCreateAssociationMixin<ServeModel>;
-    Set: SetModel;
-    getSet: Sequelize.BelongsToGetAssociationMixin<SetModel>;
-    setSet: Sequelize.BelongsToSetAssociationMixin<SetModel, SetId>;
-    createSet: Sequelize.BelongsToCreateAssociationMixin<SetModel>;
-    Spike: SpikeModel;
-    getSpike: Sequelize.BelongsToGetAssociationMixin<SpikeModel>;
-    setSpike: Sequelize.BelongsToSetAssociationMixin<SpikeModel, SpikeId>;
-    createSpike: Sequelize.BelongsToCreateAssociationMixin<SpikeModel>;
-    Trait: TraitModel;
-    getTrait: Sequelize.BelongsToGetAssociationMixin<TraitModel>;
-    setTrait: Sequelize.BelongsToSetAssociationMixin<TraitModel, TraitId>;
-    createTrait: Sequelize.BelongsToCreateAssociationMixin<TraitModel>;
-    static initModel(sequelize: Sequelize.Sequelize): typeof EventTraitModel;
-}

package/dist/cjs/src/data/models/event-trait.js

@@ -1,77 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventTraitModel = void 0;
-const sequelize_1 = require("sequelize");
-class EventTraitModel extends sequelize_1.Model {
-    static initModel(sequelize) {
-        return EventTraitModel.init({
-            block_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: true,
-                references: {
-                    model: 'Block',
-                    key: 'event_id'
-                }
-            },
-            reception_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: true,
-                references: {
-                    model: 'Reception',
-                    key: 'event_id'
-                }
-            },
-            serve_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: true,
-                references: {
-                    model: 'Serve',
-                    key: 'event_id'
-                }
-            },
-            set_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: true,
-                references: {
-                    model: 'Set',
-                    key: 'event_id'
-                }
-            },
-            spike_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: true,
-                references: {
-                    model: 'Spike',
-                    key: 'event_id'
-                }
-            },
-            event_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                primaryKey: true
-            },
-            trait_id: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Trait',
-                    key: 'trait_id'
-                }
-            }
-        }, {
-            sequelize,
-            tableName: 'EventTrait',
-            schema: 'public',
-            timestamps: false,
-            indexes: [{
-                    name: 'eventtrait_pk',
-                    unique: true,
-                    fields: [
-                        { name: 'event_id' },
-                        { name: 'trait_id' }
-                    ]
-                }]
-        });
-    }
-}
-exports.EventTraitModel = EventTraitModel;

package/dist/esm/src/data/models/event-trait.d.ts

@@ -1,50 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { Model, Optional } from 'sequelize';
-import type { BlockId, BlockModel, ReceptionId, ReceptionModel, ServeId, ServeModel, SetId, SetModel, SpikeId, SpikeModel, TraitId, TraitModel } from '.';
-export interface EventTraitAttributes {
-    block_id?: string;
-    reception_id?: string;
-    serve_id?: string;
-    set_id?: string;
-    spike_id?: string;
-    event_id: string;
-    trait_id: string;
-}
-export type EventTraitPk = 'event_id' | 'trait_id';
-export type EventTraitId = EventTraitModel[EventTraitPk];
-export type EventTraitOptionalAttributes = 'block_id' | 'reception_id' | 'serve_id' | 'set_id' | 'spike_id';
-export type EventTraitCreationAttributes = Optional<EventTraitAttributes, EventTraitOptionalAttributes>;
-export declare class EventTraitModel extends Model<EventTraitAttributes, EventTraitCreationAttributes> implements EventTraitAttributes {
-    block_id?: string;
-    reception_id?: string;
-    serve_id?: string;
-    set_id?: string;
-    spike_id?: string;
-    event_id: string;
-    trait_id: string;
-    Block: BlockModel;
-    getBlock: Sequelize.BelongsToGetAssociationMixin<BlockModel>;
-    setBlock: Sequelize.BelongsToSetAssociationMixin<BlockModel, BlockId>;
-    createBlock: Sequelize.BelongsToCreateAssociationMixin<BlockModel>;
-    Reception: ReceptionModel;
-    getReception: Sequelize.BelongsToGetAssociationMixin<ReceptionModel>;
-    setReception: Sequelize.BelongsToSetAssociationMixin<ReceptionModel, ReceptionId>;
-    createReception: Sequelize.BelongsToCreateAssociationMixin<ReceptionModel>;
-    Serve: ServeModel;
-    getServe: Sequelize.BelongsToGetAssociationMixin<ServeModel>;
-    setServe: Sequelize.BelongsToSetAssociationMixin<ServeModel, ServeId>;
-    createServe: Sequelize.BelongsToCreateAssociationMixin<ServeModel>;
-    Set: SetModel;
-    getSet: Sequelize.BelongsToGetAssociationMixin<SetModel>;
-    setSet: Sequelize.BelongsToSetAssociationMixin<SetModel, SetId>;
-    createSet: Sequelize.BelongsToCreateAssociationMixin<SetModel>;
-    Spike: SpikeModel;
-    getSpike: Sequelize.BelongsToGetAssociationMixin<SpikeModel>;
-    setSpike: Sequelize.BelongsToSetAssociationMixin<SpikeModel, SpikeId>;
-    createSpike: Sequelize.BelongsToCreateAssociationMixin<SpikeModel>;
-    Trait: TraitModel;
-    getTrait: Sequelize.BelongsToGetAssociationMixin<TraitModel>;
-    setTrait: Sequelize.BelongsToSetAssociationMixin<TraitModel, TraitId>;
-    createTrait: Sequelize.BelongsToCreateAssociationMixin<TraitModel>;
-    static initModel(sequelize: Sequelize.Sequelize): typeof EventTraitModel;
-}

package/dist/esm/src/data/models/event-trait.js

@@ -1,73 +0,0 @@
-import { DataTypes, Model } from 'sequelize';
-export class EventTraitModel extends Model {
-    static initModel(sequelize) {
-        return EventTraitModel.init({
-            block_id: {
-                type: DataTypes.UUID,
-                allowNull: true,
-                references: {
-                    model: 'Block',
-                    key: 'event_id'
-                }
-            },
-            reception_id: {
-                type: DataTypes.UUID,
-                allowNull: true,
-                references: {
-                    model: 'Reception',
-                    key: 'event_id'
-                }
-            },
-            serve_id: {
-                type: DataTypes.UUID,
-                allowNull: true,
-                references: {
-                    model: 'Serve',
-                    key: 'event_id'
-                }
-            },
-            set_id: {
-                type: DataTypes.UUID,
-                allowNull: true,
-                references: {
-                    model: 'Set',
-                    key: 'event_id'
-                }
-            },
-            spike_id: {
-                type: DataTypes.UUID,
-                allowNull: true,
-                references: {
-                    model: 'Spike',
-                    key: 'event_id'
-                }
-            },
-            event_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                primaryKey: true
-            },
-            trait_id: {
-                type: DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'Trait',
-                    key: 'trait_id'
-                }
-            }
-        }, {
-            sequelize,
-            tableName: 'EventTrait',
-            schema: 'public',
-            timestamps: false,
-            indexes: [{
-                    name: 'eventtrait_pk',
-                    unique: true,
-                    fields: [
-                        { name: 'event_id' },
-                        { name: 'trait_id' }
-                    ]
-                }]
-        });
-    }
-}