dyo-tools 0.3.2 → 0.4.0

package/dist/types/core.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FilterOperatorType = void 0;
-var FilterOperatorType;
+export var FilterOperatorType;
 (function (FilterOperatorType) {
     FilterOperatorType["EQ"] = "$eq";
     FilterOperatorType["IN"] = "$in";
@@ -11,5 +8,4 @@ var FilterOperatorType;
     FilterOperatorType["GTE"] = "$gte";
     FilterOperatorType["CONTAINS"] = "$contains";
     FilterOperatorType["NCONTAINS"] = "$ncontains";
-})(FilterOperatorType = exports.FilterOperatorType || (exports.FilterOperatorType = {}));
-//# sourceMappingURL=core.js.map
+})(FilterOperatorType || (FilterOperatorType = {}));

package/dist/types/core.js.map

@@ -1 +1 @@
-{"version":3,"file":"core.js","sourceRoot":"","sources":["../../src/types/core.ts"],"names":[],"mappings":";;;AAIA,IAAY,kBASX;AATD,WAAY,kBAAkB;IAC5B,gCAAU,CAAA;IACV,gCAAU,CAAA;IACV,kCAAY,CAAA;IACZ,gCAAU,CAAA;IACV,kCAAY,CAAA;IACZ,kCAAY,CAAA;IACZ,4CAAsB,CAAA;IACtB,8CAAwB,CAAA;AAC1B,CAAC,EATW,kBAAkB,GAAlB,0BAAkB,KAAlB,0BAAkB,QAS7B"}
+{"version":3,"file":"core.js","sourceRoot":"","sources":["../../src/types/core.ts"],"names":[],"mappings":"AAIA,MAAM,CAAN,IAAY,kBASX;AATD,WAAY,kBAAkB;IAC5B,gCAAU,CAAA;IACV,gCAAU,CAAA;IACV,kCAAY,CAAA;IACZ,gCAAU,CAAA;IACV,kCAAY,CAAA;IACZ,kCAAY,CAAA;IACZ,4CAAsB,CAAA;IACtB,8CAAwB,CAAA;AAC1B,CAAC,EATW,kBAAkB,KAAlB,kBAAkB,QAS7B"}

package/dist/types/index.d.ts

@@ -1,2 +1,3 @@
 export * from './core';
 export * from './player';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC"}

package/dist/types/index.js

@@ -1,19 +1,2 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./core"), exports);
-__exportStar(require("./player"), exports);
-//# sourceMappingURL=index.js.map
+export * from './core';
+export * from './player';

package/dist/types/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,yCAAuB;AACvB,2CAAyB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC"}

package/dist/types/player.d.ts

@@ -1,5 +1,5 @@
 import { DTPlayer } from '../index';
 export interface DTPlayerManagerSimpleConfiguration {
     players?: number | DTPlayer[];
-    errors?: boolean;
 }
+//# sourceMappingURL=player.d.ts.map

package/dist/types/player.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"player.d.ts","sourceRoot":"","sources":["../../src/types/player.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC,MAAM,WAAW,kCAAkC;IACjD,OAAO,CAAC,EAAE,MAAM,GAAG,QAAQ,EAAE,CAAC;CAC/B"}

package/dist/types/player.js

@@ -1,3 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=player.js.map
+export {};

package/integration/data/components/DTHero.ts

@@ -0,0 +1,42 @@
+import {DTElement} from "../../../src";
+import {DIXObject, DTComponentOptions} from "../../../src/types";
+
+type DTHeroMeta = {
+  damage: number;
+}
+
+export default class DTHero extends DTElement<DTHeroMeta> {
+  _domain = 'hero';
+  name: string;
+
+  constructor(key?: string, options: Partial<DTComponentOptions> = {}) {
+    super(key, options);
+    this.name = "";
+    this.setMeta('damage', 0);
+  }
+
+  getDamage(): number {
+    return this.getMeta('damage');
+  }
+
+  setDamage(damage: number) {
+    this.setMeta('damage', damage);
+  }
+
+  toDIXObject(): Record<string, DIXObject> {
+    const dixObject = super.toDIXObject()[this.getId()];
+    dixObject.name = this.name;
+    return {
+      [this.getId()]: dixObject
+    };
+  }
+
+  updateFromDix(dix: Record<string, DIXObject>) {
+    super.updateFromDix(dix);
+    const dixObject = dix[this._id];
+
+    if (dixObject && dixObject.owner) {
+      this.name = dixObject.name as string;
+    }
+  }
+}

package/integration/data/components/DTHeroManager.ts

@@ -0,0 +1,11 @@
+import {DTManager} from "../../../src";
+import DTHero from "./DTHero";
+import {DTManagerOptions} from "../../../src/types";
+
+export default class DTHeroManager extends DTManager<DTHero> {
+  _domain = 'hero';
+
+  constructor(key?: string, elements: DTHero[] = [], scopes: string[] = [], options: Partial<DTManagerOptions> = {}) {
+    super(key ?? 'hero', elements, ['hand', 'playZone', ...scopes], options);
+  }
+}

package/integration/data/components/DTHeroPlayZone.ts

@@ -0,0 +1,6 @@
+import {DTBunch} from "../../../src";
+import DTHero from "./DTHero";
+
+export default class DTHeroPlayZone extends DTBunch<DTHero> {
+  _domain = 'hero';
+}

package/integration/data/components/DTHeroPlayerHand.ts

@@ -0,0 +1,11 @@
+import {DTBunch} from "../../../src";
+import DTHero from "./DTHero";
+import {DTBunchOptions} from "../../../src/types";
+
+export default class DTHeroPlayerHand extends DTBunch<DTHero> {
+  _domain = 'hero';
+
+  constructor(key?: string, items: DTHero[] = [], options: Partial<DTBunchOptions> = {}) {
+    super(key, items, { ...options, inheritOwner: true });
+  }
+}

package/integration/data/components/index.ts

@@ -0,0 +1,5 @@
+
+export { default as DTHeroManager } from "./DTHeroManager";
+export { default as DTHero } from "./DTHero";
+export { default as DTHeroPlayerHand } from "./DTHeroPlayerHand";
+export { default as DTHeroPlayZone } from "./DTHeroPlayZone";

package/integration/data/in/heroIn.helper.ts

@@ -0,0 +1,8 @@
+import DTHero from "../components/DTHero";
+
+export function generateHeroElement(key: string, name: string, damage: number): DTHero {
+  const hero = new DTHero(key);
+  hero.name = name;
+  hero.setDamage(damage);
+  return hero;
+}

package/integration/data/in/playerIn.helper.ts

@@ -0,0 +1,13 @@
+import {DTPlayer} from "../../../src";
+
+export function generatePlayers(count: number): DTPlayer[] {
+  const playerNames = ['LLHOONN','PRIAM','AXELLE','PAYNHOPES','MORGANE'];
+  const players: DTPlayer[] = [];
+  for (let i = 0; i < count; i++) {
+    if (playerNames[i]) {
+      players.push(new DTPlayer(playerNames[i]));
+    }
+  }
+
+  return players;
+}

package/integration/data/out/heroOut.helper.ts

@@ -0,0 +1,48 @@
+import {DIXObject, DTBunchOptions} from "../../../src/types";
+import {bunchDefaultOptions} from "../../../src/constants";
+
+export function dixOutDTHero(key: string, name: string, damage: number, owner: string): DIXObject & { name: string } {
+  return {
+    useClass: 'DTHero',
+    componentType: 'element',
+    options: JSON.stringify({ errors: false }),
+    key,
+    meta: JSON.stringify({ damage }),
+    owner,
+    name,
+  }
+}
+
+export function dixOutDTHeroBunch(useClass: string, key: string, items: string[], owner?: string, options: Partial<DTBunchOptions> = {}): DIXObject {
+  const outputOptionsDix: DTBunchOptions = { ...bunchDefaultOptions, ...options };
+  delete outputOptionsDix.syncId;
+
+  const outputDix: DIXObject = {
+    useClass,
+    componentType: 'bunch',
+    key,
+    items,
+    options: JSON.stringify(outputOptionsDix),
+  }
+
+  if (owner) {
+    outputDix.owner = owner;
+  }
+
+  return outputDix;
+}
+
+export function dixOutDTHeroManager(key: string, items: string[], library: string): DIXObject {
+  return {
+    useClass: 'DTHeroManager',
+    componentType: 'manager',
+    options: JSON.stringify({ errors: false, libraryDeletion: false }),
+    key,
+    items,
+    library,
+    scopes: ['hand', 'playZone']
+  }
+}
+
+
+

package/integration/endings/synchronisation.ending.ts

@@ -0,0 +1,25 @@
+import {DTMaster} from "../../src";
+import {IEnding, IStage, IStageExit} from "../types";
+import DTDIXModule from "../../src/libs/dix/DIXModule.module";
+import * as DIXOverrides from "../data/components";
+
+export default class SynchronizationEnding implements IEnding {
+  exit(stage: IStage): IStageExit {
+    // create a new Master and update From previous DIX
+    const { master, outDIX, expectedDIX } = stage.exit(true);
+
+    const newMaster = new DTMaster(master.getKey(), { syncId: master.getId() });
+    const dixModule = new DTDIXModule(DIXOverrides);
+    newMaster.addModule(dixModule);
+
+    newMaster.updateFromDix(outDIX);
+    // console.log(newMaster.toDIXObject());
+
+    return {
+      master: newMaster,
+      outDIX: newMaster.toDIXObject(),
+      expectedDIX,
+    }
+  }
+
+}

package/integration/scenes/drawCard.scene.ts

@@ -0,0 +1,31 @@
+import {IScene, IStage} from "../types";
+import {generateHeroElement} from "../data/in/heroIn.helper";
+import {dixOutDTHero} from "../data/out/heroOut.helper";
+import {DTHero} from "../data/components";
+
+export default class DrawCardScene implements IScene {
+  play(stage: IStage): void {
+
+    // Each player play draw a new Card from nowhere, which increase HAILEI damage
+    const heroManager = stage.master.getManager('hero');
+    if (heroManager) {
+      const hands = heroManager.getAll('hand');
+
+      hands.forEach(h => {
+        const newCard = generateHeroElement('HENEKET', 'HENEKET', 5);
+        h.add(newCard);
+
+        const haileiCard = h.find({ key: { $eq: 'HAILEI' }});
+        if (haileiCard[0]) {
+          const haileiCardTyped = haileiCard[0] as DTHero;
+          haileiCardTyped.setMeta('damage', 10);
+          stage.dixExit[haileiCardTyped.getId()] = dixOutDTHero(haileiCardTyped.getKey(), haileiCardTyped.name, 10, h.getOwner());
+        }
+
+        stage.dixExit[h.getId()].items.push(newCard.getId());
+        stage.dixExit[heroManager.getLibrary().getId()].items.push(newCard.getId());
+        stage.dixExit[newCard.getId()] = dixOutDTHero(newCard.getKey(), newCard.name, newCard.getDamage(), h.getOwner());
+      });
+    }
+  }
+}

package/integration/scenes/empty.scene.ts

@@ -0,0 +1,6 @@
+import {IScene, IStage} from "../types";
+
+export default class EmptyScene implements IScene {
+  play(stage: IStage): void {
+  }
+}

package/integration/scenes/playCard.scene.ts

@@ -0,0 +1,23 @@
+import {IScene, IStage} from "../types";
+
+export default class PlayCardScene implements IScene {
+  play(stage: IStage): void {
+
+    // Each player play first hand Card
+    const heroManager = stage.master.getManager('hero');
+    if (heroManager) {
+      const hands = heroManager.getAll('hand');
+      const playZone = heroManager.getAll('playZone');
+
+      hands.forEach(h => {
+        const cardToPlay = h.get(0);
+        if (cardToPlay && playZone[0]) {
+          playZone[0].add(cardToPlay);
+
+          stage.dixExit[playZone[0].getId()].items.push(cardToPlay.getId());
+          stage.dixExit[h.getId()].items = stage.dixExit[h.getId()].items.slice(1);
+        }
+      });
+    }
+  }
+}

package/integration/scenes/playerLeave.scene.ts

@@ -0,0 +1,33 @@
+import {IScene, IStage} from "../types";
+import {DTPlayerManager} from "../../src";
+
+export default class PlayerLeaveScene implements IScene {
+  play(stage: IStage): void {
+
+    // A player leave the game
+    // Remove player, hand and all cards from the hand (including Library)
+    const playerManager = stage.master.getManager('player') as DTPlayerManager;
+    const heroManager = stage.master.getManager('hero');
+    const leftPlayer = playerManager?.getLibrary()?.find({ key: { $eq: 'PAYNHOPES' }})[0];
+    const leftPlayerHand = heroManager?.find({ owner: { $eq: leftPlayer?.getId() } })[0];
+
+    if (leftPlayer && leftPlayerHand && leftPlayerHand.getKey() === 'hand') {
+      playerManager.removePlayer(leftPlayer.getId());
+      heroManager.removeMany([ leftPlayerHand.getId() ], { libraryDeletion: true });
+
+      stage.dixExit[playerManager.getLibrary().getId()].items = stage.dixExit[playerManager.getLibrary().getId()]
+        .items.filter((i) => i !== leftPlayer.getId())
+      delete stage.dixExit[leftPlayer.getId()];
+
+      stage.dixExit[heroManager.getId()].items = stage.dixExit[heroManager.getId()]
+        .items.filter((i) => i !== leftPlayerHand.getId());
+      delete stage.dixExit[leftPlayerHand.getId()];
+
+      leftPlayerHand.getAll().forEach((c) => {
+        stage.dixExit[heroManager.getLibrary().getId()].items = stage.dixExit[heroManager.getLibrary().getId()]
+          .items.filter((i) => i !== c.getId());
+        delete stage.dixExit[c.getId()];
+      });
+    }
+  }
+}

package/integration/stages/baseDix.stage.ts

@@ -0,0 +1,137 @@
+import {DTMaster, DTPlayerManager} from "../../src";
+import {generatePlayers} from "../data/in/playerIn.helper";
+import DTHeroManager from "../data/components/DTHeroManager";
+import DTHero from "../data/components/DTHero";
+import {generateHeroElement} from "../data/in/heroIn.helper";
+import DTHeroPlayZone from "../data/components/DTHeroPlayZone";
+import DTHeroPlayerHand from "../data/components/DTHeroPlayerHand";
+import {DIXObject} from "../../src/types";
+import {dixOutDTHero, dixOutDTHeroBunch, dixOutDTHeroManager} from "../data/out/heroOut.helper";
+import {IEnding, IScene, IStage, IStageExit} from "../types";
+import DTDIXModule from "../../src/libs/dix/DIXModule.module";
+import * as DIXOverrides from "../data/components";
+
+export default class BaseDixStage implements IStage {
+  master: DTMaster;
+  dixExit: Record<string, DIXObject> = {};
+
+  constructor(private scene: IScene, private ending?: IEnding) {
+    this.master = new DTMaster('dix');
+  }
+
+  createMaster(key: string, syncId?: string): DTMaster {
+    const master = new DTMaster(key, { syncId: syncId });
+
+    // Initialize Module
+    const dixModule = new DTDIXModule(DIXOverrides);
+    master.addModule(dixModule);
+
+    return master;
+  }
+
+  enter() {
+    this.master = this.createMaster('dyo-test');
+
+    // - Manager player (4 players)
+    const playerManager = new DTPlayerManager('player');
+
+    const playerIds: string[] = [];
+    generatePlayers(4).forEach((player) => {
+      playerManager.addPlayer(player);
+      this.dixExit[player.getId()] = {
+        useClass: 'DTPlayer',
+        componentType: 'element',
+        options: JSON.stringify({ errors: false }),
+        key: player.getKey()
+      };
+      playerIds.push(player.getId());
+    });
+    this.master.addManager(playerManager);
+    this.dixExit[playerManager.getId()] = {
+      useClass: 'DTPlayerManager',
+      componentType: 'manager',
+      options: JSON.stringify({ errors: false, libraryDeletion: false }),
+      key: 'player',
+      items: [],
+      library: playerManager.getLibrary().getId(),
+    }
+    this.dixExit[playerManager.getLibrary().getId()] = {
+      useClass: 'DTBunch',
+      key: 'library',
+      componentType: 'bunch',
+      options: "",
+      items: playerIds,
+    }
+
+    // - Manager : Hero
+    const heroManager = new DTHeroManager();
+
+    const bunchesIds: Record<string, string[]> = {};
+    playerManager.findPlayers({owner: undefined}).forEach((player) => {
+      // -- Hero Elements
+      const elems: DTHero[] = [
+        generateHeroElement('HAILEI', 'HAILEI', 7),
+        generateHeroElement('MELDRINE', 'MELDRINE', 9),
+        generateHeroElement('MAYDENA', 'MAYDENA', 5),
+        generateHeroElement('ILDRESS', 'ILDRESS', 3),
+        generateHeroElement('YSSALIA', 'YSSALIA', 6),
+      ]
+
+      const hand = new DTHeroPlayerHand('hand', elems);
+      hand.setOwner(player.getId());
+
+      elems.forEach(e => {
+        this.dixExit[e.getId()] = dixOutDTHero(e.getKey(), e.name, e.getDamage(), player.getId());
+      })
+
+      heroManager.add(hand, 'hand');
+      this.dixExit[hand.getId()] = {
+        ...dixOutDTHeroBunch('DTHeroPlayerHand','hand', [...elems.map(e => e.getId())], player.getId(), { inheritOwner: true }),
+        scope: 'hand',
+      }
+
+      bunchesIds[hand.getId()] = [...elems.map(e => e.getId())];
+    });
+
+    const playZone = new DTHeroPlayZone('playZone');
+    heroManager.add(playZone, 'playZone');
+    this.dixExit[playZone.getId()] = {
+      ...dixOutDTHeroBunch('DTHeroPlayZone', 'playZone', []),
+      scope: 'playZone',
+    };
+
+    this.master.addManager(heroManager);
+    this.dixExit[heroManager.getId()] = dixOutDTHeroManager('hero', [...Object.keys(bunchesIds), playZone.getId()], heroManager.getLibrary().getId());
+    this.dixExit[heroManager.getLibrary().getId()] = {
+      useClass: 'DTBunch',
+      key: 'library',
+      componentType: 'bunch',
+      options: "",
+      items: Object.values(bunchesIds).reduce((prev, cur) => [...prev, ...cur], []),
+    }
+
+    this.dixExit[this.master.getId()] = {
+      useClass: 'DTMaster',
+      key: 'dyo-test',
+      componentType: 'master',
+      options: JSON.stringify({ errors: false }),
+      items: [playerManager.getId(), heroManager.getId()]
+    }
+  }
+
+  play(): void {
+    this.scene.play(this);
+  }
+
+  exit(skipEnding: boolean = false): IStageExit {
+    if (this.ending && !skipEnding) {
+      return this.ending.exit(this);
+    }
+
+    return {
+      master: this.master,
+      outDIX: this.master.toDIXObject(),
+      expectedDIX: this.dixExit,
+    };
+  }
+}

package/integration/stages/syncDix.stage.ts

@@ -0,0 +1,36 @@
+import BaseDixStage from "./baseDix.stage";
+import {DTMaster} from "../../src";
+import {IStageExit} from "../types";
+
+export default class SyncDixStage extends BaseDixStage {
+  syncedMaster: DTMaster | undefined;
+
+  enter() {
+    super.enter();
+
+    // Sync with other master
+    const syncedMaster = this.createMaster("dyo-test", this.master.getId());
+
+    syncedMaster.updateFromDix(this.master.toDIXObject());
+    this.syncedMaster = syncedMaster;
+  }
+
+  play() {
+    super.play();
+
+    // Sync with other master
+    this.syncedMaster.updateFromDix(this.master.toDIXObject());
+  }
+
+  exit(skipEnding: boolean = false): IStageExit {
+    super.exit(skipEnding);
+
+    return {
+      master: this.syncedMaster,
+      outDIX: this.syncedMaster.toDIXObject(),
+      expectedDIX: this.dixExit,
+    }
+  }
+
+
+}

package/integration/tests/scenario1.spec.ts

@@ -0,0 +1,55 @@
+import {describe, expect, test,} from '@jest/globals';
+import BaseDixStage from "../stages/baseDix.stage";
+import EmptyScene from "../scenes/empty.scene";
+import SyncDixStage from "../stages/syncDix.stage";
+import PlayCardScene from "../scenes/playCard.scene";
+import DrawCardScene from "../scenes/drawCard.scene";
+import PlayerLeaveScene from "../scenes/playerLeave.scene";
+
+describe('Scenario 1 - Play a DYO Test round', () => {
+  test('Scene 1 : Empty scene', () => {
+    const stage = new BaseDixStage(new EmptyScene());
+    stage.enter();
+    stage.play();
+    const { outDIX, expectedDIX } = stage.exit();
+
+    expect(outDIX).toStrictEqual(expectedDIX);
+  });
+
+  test('Scene 2 : Empty scene synchronized', () => {
+    const stage = new SyncDixStage(new EmptyScene());
+    stage.enter();
+    stage.play();
+    const { outDIX, expectedDIX } = stage.exit();
+
+    expect(outDIX).toStrictEqual(expectedDIX);
+  });
+
+  test('Scene 3 : Play a card', () => {
+    const stage = new SyncDixStage(new PlayCardScene());
+    stage.enter();
+    stage.play();
+    const { outDIX, expectedDIX } = stage.exit();
+
+    expect(outDIX).toStrictEqual(expectedDIX);
+  });
+
+  test('Scene 4 : Draw a card', () => {
+    const stage = new SyncDixStage(new DrawCardScene());
+    stage.enter();
+    stage.play();
+    const { outDIX, expectedDIX } = stage.exit();
+
+    expect(outDIX).toStrictEqual(expectedDIX);
+  });
+
+  test('Scene 5 : Player leaves', () => {
+    const stage = new SyncDixStage(new PlayerLeaveScene());
+    stage.enter();
+    stage.play();
+    const { outDIX, expectedDIX } = stage.exit();
+
+    expect(outDIX).toStrictEqual(expectedDIX);
+  });
+
+});

package/integration/types/index.ts

@@ -0,0 +1,24 @@
+import {DTMaster} from "../../src";
+import {DIXObject} from "../../src/types";
+
+export interface IStageExit {
+  master: DTMaster,
+  outDIX: Record<string, DIXObject>,
+  expectedDIX: Record<string, DIXObject>,
+}
+
+export interface IStage {
+  master: DTMaster,
+  dixExit: Record<string, DIXObject>,
+  enter: () => void,
+  play: () => void,
+  exit: (skipEnding: boolean) => IStageExit,
+}
+
+export interface IScene {
+  play: (stage: IStage) => void,
+}
+
+export interface IEnding {
+  exit: (stage: IStage) => IStageExit,
+}

package/jest-integration.config.ts

@@ -0,0 +1,25 @@
+import type { JestConfigWithTsJest } from "ts-jest";
+
+// Jest Configuration for Integration Tests
+// Integration Tests are only for the test/integration folder
+const config: JestConfigWithTsJest = {
+    verbose: true,
+    transform: {
+        "^.+\\.ts?$": [
+            "ts-jest",
+            {
+                useESM: true,
+            },
+        ],
+    },
+    extensionsToTreatAsEsm: [".ts"],
+    moduleNameMapper: {
+        "^(\\.{1,2}/.*)\\.js$": "$1",
+    },
+    testMatch: ["<rootDir>/integration/**/*.spec.ts"],
+    testPathIgnorePatterns: ["<rootDir>/dist/", "<rootDir>/node_modules/", "<rootDir>/test/"],
+};
+
+export default config;
+
+

package/jest.config.ts

@@ -0,0 +1,26 @@
+import type { JestConfigWithTsJest } from "ts-jest";
+
+// Jest Configuration for Unit Tests
+// Unit Tests are only for the test/core folder, excluding DIX methods
+// Other tests are in the integration folder
+const config: JestConfigWithTsJest = {
+  verbose: true,
+  transform: {
+    "^.+\\.ts?$": [
+      "ts-jest",
+      {
+        useESM: true,
+      },
+    ],
+  },
+  extensionsToTreatAsEsm: [".ts"],
+  moduleNameMapper: {
+    "^(\\.{1,2}/.*)\\.js$": "$1",
+  },
+  testMatch: ["<rootDir>/test/core/*.spec.ts"],
+  testPathIgnorePatterns: ["<rootDir>/dist/", "<rootDir>/node_modules/", "<rootDir>/integration/"],
+};
+
+export default config;
+
+