dyo-tools 0.1.0 → 0.2.0

package/e2e/future/resources/dominion.js

@@ -0,0 +1,238 @@
+const {DTElement, DTManager, DTBunch, DTPlayer} = require("../../../dist/src");
+
+/****************** CARDS REFERENCE ************************/
+const cards = {
+    "COPPER": {
+        meta: {
+            type: 'treasure',
+            cost: 0,
+            treasurePoints: 1
+        },
+        events: {
+          play: (ctx) => {
+              ctx.getOwner.setMeta('coin', 1);
+          }
+        }
+    },
+    "SILVER": {
+        meta: {
+            type: 'treasure',
+            cost: 3,
+            treasurePoints: 2
+        },
+        events: {
+            play: (ctx) => {
+                ctx.getOwner.setMeta('coin', 2);
+            }
+        }
+    },
+    "GOLD": {
+        meta: {
+            type: 'treasure',
+            cost: 6,
+            treasurePoints: 3
+        },
+        events: {
+            play: (ctx) => {
+                ctx.getOwner.setMeta('coin', 3);
+            }
+        }
+    },
+    "ESTATE": {
+        meta: {
+            type: 'victory',
+            cost: 2,
+            victoryPoints: 1
+        }
+    },
+    "DUCHY": {
+        meta: {
+            type: 'victory',
+            cost: 5,
+            treasurePoints: 3
+        }
+    },
+    "PROVINCE": {
+        meta: {
+            type: 'victory',
+            cost: 8,
+            treasurePoints: 6
+        }
+    },
+    "SMITHY": {
+        meta: {
+            type: 'action',
+            cost: 4,
+        }
+    },
+    "WORKSHOP": {
+        meta: {
+            type: 'action',
+            cost: 3,
+        }
+    },
+    "MILITIA": {
+        meta: {
+            type: 'action',
+            cost: 4,
+        }
+    },
+}
+
+/****************** BUILDERS ************************/
+
+const buildCard = (key) => {
+    const element = new DTElement(key);
+    element.setManyMeta(cards[key].meta);
+    if (cards[key].events) {
+        for (let actionKey of Object.keys(cards[key].events)) {
+            element.addEvent(actionKey, cards[key].events[actionKey]);
+        }
+    }
+    return element;
+}
+
+const duplicateCard = (card, nb) => {
+    const items = [card];
+    let i = 1;
+    while (i <= nb) {
+        items.push(card.copy());
+        i++;
+    }
+    return items;
+}
+
+const initializeDominionManager = () => {
+    const scopes = [
+        'supply',
+        'hand',
+        'playZone',
+        'discard',
+        'deck'
+    ];
+    const library = [
+        ...duplicateCard(buildCard('COPPER'), 13),
+        ...duplicateCard(buildCard('ESTATE'), 5)
+    ];
+    const manager = new DTManager('dominionCard', library, scopes, { errors: true });
+
+    // Initialize Supply zone
+    const copperPile = new DTBunch('copperPile', duplicateCard(buildCard('COPPER'), 11));
+    copperPile.setMeta('cost', cards["COPPER"].cost);
+    const silverPile = new DTBunch('silverPile', duplicateCard(buildCard('SILVER'), 11));
+    silverPile.setMeta('cost', cards["SILVER"].cost);
+    const goldPile = new DTBunch('goldPile', duplicateCard(buildCard('GOLD'), 11));
+    goldPile.setMeta('cost', cards["GOLD"].cost);
+
+    const estatePile = new DTBunch('estatePile', duplicateCard(buildCard('ESTATE'), 7));
+    estatePile.setMeta('cost', cards["ESTATE"].cost);
+    const duchyPile = new DTBunch('duchyPile', duplicateCard(buildCard('DUCHY'), 7));
+    duchyPile.setMeta('cost', cards["DUCHY"].cost);
+    const provincePile = new DTBunch('provincePile', duplicateCard(buildCard('PROVINCE'), 7));
+    provincePile.setMeta('cost', cards["PROVINCE"].cost);
+
+    const militiaPile = new DTBunch('militiaPile', duplicateCard(buildCard('MILITIA'), 7));
+    militiaPile.setMeta('cost', cards["MILITIA"].cost);
+    const smithyPile = new DTBunch('smithyPile', duplicateCard(buildCard('SMITHY'), 7));
+    smithyPile.setMeta('cost', cards["SMITHY"].cost);
+    const workshopPile = new DTBunch('workshopPile', duplicateCard(buildCard('WORKSHOP'), 7));
+    workshopPile.setMeta('cost', cards["WORKSHOP"].cost);
+
+    manager.addMany([
+        copperPile,
+        silverPile,
+        goldPile,
+        estatePile,
+        duchyPile,
+        provincePile,
+        militiaPile,
+        smithyPile,
+        workshopPile
+    ], 'supply');
+
+    // Initialize players
+    const players = [
+        new DTPlayer('PRIAM'),
+        new DTPlayer('ECTESIAM'),
+    ]
+
+    // Initialize players deck, discard and hand
+    let current = {};
+    for (let player of players) {
+        const deck = new DTBunch('deck');
+        deck.setOwner(player);
+        manager.add(deck, 'deck');
+
+        const discard = new DTBunch('discard');
+        discard.setOwner(player);
+        manager.add(discard, 'discard');
+
+        const hand = new DTBunch('hand');
+        hand.setOwner(player);
+        manager.add(hand, 'hand');
+
+        const playZone = new DTBunch('playZone');
+        playZone.setOwner(player);
+        manager.add(playZone, 'playZone');
+
+        const playerCards = new DTBunch('playerCards', [], { virtualContext: true });
+        playerCards.setOwner(player);
+        manager.add(playerCards);
+
+        if (player.getKey() === 'PRIAM') {
+            current = {
+                player,
+                deck,
+                hand,
+                playZone
+            }
+        }
+    }
+
+    // Initialize actions
+    const fakeShuffle = (bunch) => {
+      const estates = bunch.find({ key: { $eq: 'ESTATE' }});
+      const coppers = bunch.find({ key: { $eq: 'COPPER' }});
+
+      bunch.removeAll();
+      bunch.addMany([
+          coppers[0],
+          estates[0],
+          coppers[1],
+          estates[1],
+          coppers[2],
+          estates[2],
+          coppers[3],
+          coppers[4],
+          coppers[5],
+          coppers[6],
+      ])
+    };
+    const fakeShuffleAction = new DTSimpleAction('shuffle', fakeShuffle, {
+        target: 'bunch',
+        scopes: ['deck']
+    });
+
+    const drawAction = new DTTransferAction('draw', {
+       scopes: ['deck'],
+       destinationScope: 'hand'
+    });
+
+    const playAction = new DTTransferAction('play', {
+        scopes: ['hand'],
+        destinationScope: 'playZone'
+    });
+
+    manager.addAction(fakeShuffleAction);
+    manager.addAction(drawAction);
+    manager.addAction(playAction);
+
+    // Return
+    return {
+        manager,
+        current,
+        players
+    }
+}
+
+module.exports = initializeDominionManager

package/e2e/future/resources/utils.js

@@ -0,0 +1,27 @@
+
+const transformDataTableToBunchFinderArgs = (table) => {
+    const validArgs = ['key', 'id', 'owner', 'scope'];
+    const finalArgs = {};
+
+    for (let [arg, value] of Object.entries(table.rowsHash())) {
+        if (validArgs.includes(arg)) {
+            finalArgs[arg] = { $eq: value };
+        } else {
+            if (!finalArgs.meta) {
+                finalArgs.meta = {};
+            }
+            finalArgs.meta[arg] = { $eq: value };
+        }
+    }
+
+    return finalArgs;
+}
+
+const extractKeysElement = (elements) => {
+    return elements.map((element) => element.getKey());
+}
+
+module.exports = {
+    transformDataTableToBunchFinderArgs,
+    extractKeysElement
+}

package/jest.config.js

@@ -0,0 +1,6 @@
+/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
+module.exports = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+  testPathIgnorePatterns: ["<rootDir>/dist/", "<rootDir>/dist_test/", "<rootDir>/node_modules/"]
+};

package/package.json

@@ -1,42 +1,52 @@
 {
   "name": "dyo-tools",
-  "version": "0.1.0",
-  "description": "Provide component classes to manage any board game instance.",
+  "version": "0.2.0",
+  "description": "",
   "main": "dist/index.js",
   "scripts": {
-    "build": "tsc",
+    "build:prod": "tsc -p tsconfig.json",
+    "build:dev": "tsc -p tsconfig.dev.json",
     "start": "node dist/index.js",
     "lint": "eslint src/ --ext .ts",
     "lint:fix": "eslint src/ --ext .ts --fix",
+    "typecheck": "tsc --noEmit -p tsconfig.dev.json",
     "test": "jest",
     "test:coverage": "c8 --check-coverage npm test",
-    "test:coverage:verify": "c8 --check-coverage --100 npm test"
+    "test:coverage:verify": "c8 --check-coverage --lines 97 --functions 97 --branches 97 --statements 97 npm test",
+    "e2e": "cucumber-js --config cucumber.js",
+    "typedoc": "typedoc --tsconfig tsconfig.dev.json src/**/*.ts"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/Flaya24/dyo-tools.git"
+    "url": "git+https://gitlab.com/dyo-system/dyo-tools.git"
   },
-  "author": "Flaya for DYO System",
-  "license": "MIT",
-  "keywords": ["game", "DYO", "board game"],
-  "files": ["dist/*"],
+  "author": "",
+  "license": "ISC",
+  "engines": {
+    "node": ">=12.13.0"
+  },
+  "bugs": {
+    "url": "https://gitlab.com/dyo-system/dyo-tools/issues"
+  },
+  "homepage": "https://gitlab.com/dyo-system/dyo-tools#readme",
   "devDependencies": {
-    "@babel/preset-env": "^7.14.7",
-    "@types/jest": "^27.4.0",
-    "@types/uuid": "^8.3.3",
-    "@typescript-eslint/eslint-plugin": "^5.9.0",
-    "@typescript-eslint/parser": "^5.9.0",
-    "c8": "^7.11.0",
-    "eslint": "^8.6.0",
+    "@babel/preset-env": "^7.22.5",
+    "@types/jest": "^27.5.2",
+    "@types/uuid": "^9.0.2",
+    "@typescript-eslint/eslint-plugin": "^5.59.11",
+    "@typescript-eslint/parser": "^5.59.11",
+    "c8": "^8.0.0",
+    "eslint": "^8.42.0",
     "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-config-airbnb-typescript": "^16.1.0",
-    "eslint-plugin-import": "^2.25.4",
-    "jest": "^27.0.6",
-    "ts-jest": "^27.1.3",
-    "typedoc": "^0.22.10",
-    "typescript": "^4.2.4"
+    "eslint-config-airbnb-typescript": "^17.0.0",
+    "eslint-plugin-import": "^2.27.5",
+    "jest": "^27.5.1",
+    "ts-jest": "^27.1.5",
+    "typedoc": "^0.24.8",
+    "typescript": "4.8.4"
   },
   "dependencies": {
-    "uuid": "^8.3.2"
+    "@cucumber/cucumber": "^9.1.2",
+    "uuid": "^9.0.0"
   }
 }

package/src/constants.ts

@@ -0,0 +1,85 @@
+import {
+  DTAcceptedMetaData,
+  DTBunchOptions,
+  DTManagerOptions,
+  DYOFinderConfiguration,
+  FilterOperatorType,
+  StandardPrimitiveType,
+} from './types';
+import {
+  DTBunch, DTComponentPhysical, DTElement, DTManager,
+} from './index';
+
+/* ********************** CORE CONSTANTS ********************** */
+/** DTBunch constants * */
+export const bunchDefaultOptions: DTBunchOptions = {
+  errors: false,
+  uniqueKey: false,
+  inheritOwner: false,
+  replaceIndex: false,
+  virtualContext: false,
+};
+
+/** DTManager constants * */
+export const managerDefaultOptions: DTManagerOptions = {
+  errors: false,
+  libraryDeletion: false,
+};
+
+/** DYOFinder configuration constants * */
+const baseOperators = [
+  FilterOperatorType.EQ,
+  FilterOperatorType.IN,
+  FilterOperatorType.NIN,
+  FilterOperatorType.NE,
+];
+const advancedOperators = [
+  ...baseOperators,
+  FilterOperatorType.GTE,
+  FilterOperatorType.LTE,
+  FilterOperatorType.CONTAINS,
+  FilterOperatorType.NCONTAINS,
+];
+
+export const componentPhysicalDefaultFinderConfiguration: DYOFinderConfiguration = {
+  id: {
+    operators: baseOperators,
+    getValue: (item: DTComponentPhysical<DTAcceptedMetaData>) => item.getId(),
+    objectSearch: false,
+  },
+  key: {
+    operators: baseOperators,
+    getValue: (item: DTComponentPhysical<DTAcceptedMetaData>) => item.getKey(),
+    objectSearch: false,
+  },
+  owner: {
+    operators: baseOperators,
+    getValue: (item: DTComponentPhysical<DTAcceptedMetaData>) => (item.getOwner() ? item.getOwner().getId() : null),
+    objectSearch: false,
+  },
+  meta: {
+    operators: advancedOperators,
+    getValue: (item: DTComponentPhysical<DTAcceptedMetaData>) => item.getManyMeta(),
+    objectSearch: true,
+  },
+};
+
+export const componentManagerDefaultFinderConfiguration: DYOFinderConfiguration = {
+  ...componentPhysicalDefaultFinderConfiguration,
+  scope: {
+    operators: baseOperators,
+    getValue(item: DTBunch<DTElement<DTAcceptedMetaData>>, ctx: DTManager<DTElement<DTAcceptedMetaData>>): StandardPrimitiveType {
+      return ctx.getScope(item.getId());
+    },
+    objectSearch: false,
+  },
+};
+
+export const componentBunchDefaultFinderConfiguration: DYOFinderConfiguration = {
+  ...componentPhysicalDefaultFinderConfiguration,
+  context: {
+    operators: baseOperators,
+    getValue: (item: DTComponentPhysical<DTAcceptedMetaData>) => (item.getContext() ? item.getContext().getId() : null),
+    objectSearch: false,
+  },
+};