dyo-tools 0.3.0 → 0.4.0

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;
+
+

package/package.json

@@ -1,18 +1,29 @@
 {
   "name": "dyo-tools",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "",
   "main": "dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/types/index.d.ts"
+    }
+  },
   "scripts": {
+    "build": "tsc -p tsconfig.json",
     "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 --lines 97 --functions 97 --branches 97 --statements 97 npm test",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js  --config=jest.config.ts",
+    "test:integration": "node --experimental-vm-modules node_modules/jest/bin/jest.js  --config=jest-integration.config.ts",
+    "test:coverage:unit": "c8 --temp-directory .coverage/v8 --reports-dir coverage/unit --clean npm run test",
+    "test:coverage:integration": "c8 --temp-directory .coverage/v8 --reports-dir coverage/integration --no-clean npm run test:integration",
+    "test:coverage": "npm run test:coverage:unit && npm run test:coverage:integration && c8 report --temp-directory .coverage/v8 --reports-dir coverage --reporter=text --reporter=lcov --reporter=html",
     "typedoc": "typedoc --plugin typedoc-plugin-rename-defaults --entryPointStrategy expand ./src --exclude 'src/index.ts'"
   },
   "repository": {
@@ -29,23 +40,24 @@
   },
   "homepage": "https://gitlab.com/dyo-system/dyo-tools#readme",
   "devDependencies": {
-    "@babel/preset-env": "^7.23.9",
-    "@types/jest": "^29.5.12",
-    "@types/uuid": "^9.0.8",
-    "@typescript-eslint/eslint-plugin": "^6.21.0",
-    "@typescript-eslint/parser": "^6.21.0",
-    "c8": "^9.1.0",
-    "eslint": "^8.56.0",
+    "@babel/preset-env": "^7.28.5",
+    "@types/jest": "^30.0.0",
+    "@types/uuid": "^11.0.0",
+    "@typescript-eslint/eslint-plugin": "^7.18.0",
+    "@typescript-eslint/parser": "^7.18.0",
+    "c8": "^10.1.3",
+    "eslint": "^8.57.1",
     "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-config-airbnb-typescript": "^17.1.0",
-    "eslint-plugin-import": "^2.29.1",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.1.2",
-    "typedoc": "^0.25.8",
-    "typedoc-plugin-rename-defaults": "^0.7.0",
-    "typescript": "4.8.4"
+    "eslint-config-airbnb-typescript": "^18.0.0",
+    "eslint-plugin-import": "^2.32.0",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.5",
+    "ts-node": "^10.9.2",
+    "typedoc": "^0.28.15",
+    "typedoc-plugin-rename-defaults": "^0.7.3",
+    "typescript": "^5.9.3"
   },
   "dependencies": {
-    "uuid": "^9.0.1"
+    "uuid": "^13.0.0"
   }
 }