refactor: upgrade AddonAPIKit and propograte changes

also fix param input of instance:edit

packs/BP/scripts/API/ConstructAPI.js

@@ -1,11 +1,11 @@
-import { AddonAPI } from "../lib/AddonAPIKit";
+import { AddonAPIServer } from "../lib/AddonAPIKit";
 import { PACK_IDENTIFIER } from "../consts";
 import { InstancesController } from "./controllers/InstancesController";
 import { structureCollection } from "../classes/Structure/StructureCollection";
 import { BuildersController } from "./controllers/BuildersController";
 import { Builders } from "../classes/Builder/Builders";
 
-class ConstructAPI extends AddonAPI {
+class ConstructAPI extends AddonAPIServer {
     constructor(version) {
         super(PACK_IDENTIFIER, version);
         const instancesController = new InstancesController(structureCollection);

packs/BP/scripts/API/ConstructAPIModel.js

@@ -1,4 +1,6 @@
-import { PROTO } from '../../lib/AddonAPIKit';
+import { PROTO } from "../../lib/AddonAPIKit";
+
+// Instances
 
 const LocationModel = PROTO.Object({
     x: PROTO.Float64,
@@ -42,3 +44,17 @@ export const EditInstanceParameterModel = PROTO.Object({
     instanceName: PROTO.String,
     instance: InstanceModel
 });
+
+// Builders
+
+export const BuilderModel = PROTO.Object({
+    playerId: PROTO.String,
+    easyPlace: PROTO.Boolean,
+    fastEasyPlace: PROTO.Boolean,
+    materialGrabber: PROTO.Boolean,
+    materialInstanceName: PROTO.String
+});
+
+export const BuilderIdParameterModel = PROTO.Object({
+    playerId: PROTO.String
+});

packs/BP/scripts/API/controllers/BuildersController.js

@@ -1,6 +1,6 @@
 import { BuilderNotFoundError } from "../../classes/Errors/BuilderNotFoundError";
 import { APICallerError } from "../../lib/AddonAPIKit";
-import { BuilderIdParameterModel } from "../models/BuildersModel";
+import { BuilderIdParameterModel } from "../ConstructAPIModel";
 
 export class BuildersController extends APIController {
     #context;

packs/BP/scripts/API/controllers/InstancesController.js

@@ -2,7 +2,7 @@ import { InstanceExistsError } from "../../classes/Errors/InstanceExistsError";
 import { InstanceNotFoundError } from "../../classes/Errors/InstanceNotFoundError";
 import { StructureNotFoundError } from "../../classes/Errors/StructureNotFoundError";
 import { APICallerError, VoidModel, APIController } from "../../lib/AddonAPIKit";
-import { AddInstanceParameterModel, InstanceModel, InstanceNameParameterModel, InstancesModel, StructureMaterialsModel } from "../models/InstancesModel";
+import { AddInstanceParameterModel, EditInstanceParameterModel, InstanceModel, InstanceNameParameterModel, InstancesModel, StructureMaterialsModel } from "../ConstructAPIModel";
 
 export class InstancesController extends APIController {
     #context;
@@ -12,7 +12,7 @@ export class InstancesController extends APIController {
         this.addEndpoint("instances", this.getInstances, VoidModel, InstancesModel);
         this.addEndpoint("instance:get", this.getInstance, InstanceNameParameterModel, InstanceModel);
         this.addEndpoint("instance:add", this.addInstance, AddInstanceParameterModel, InstanceModel);
-        this.addEndpoint("instance:edit", this.editInstance, InstanceModel, InstanceModel);
+        this.addEndpoint("instance:edit", this.editInstance, EditInstanceParameterModel, InstanceModel);
         this.addEndpoint("instance:delete", this.deleteInstance, InstanceNameParameterModel, VoidModel);
         this.addEndpoint("instance:materials", this.getMaterials, InstanceNameParameterModel, StructureMaterialsModel);
         this.#context = context;

packs/BP/scripts/API/models/BuildersModel.js

@@ -1,13 +0,0 @@
-import { PROTO } from "../../lib/AddonAPIKit";
-
-export const BuilderModel = PROTO.Object({
-    playerId: PROTO.String,
-    easyPlace: PROTO.Boolean,
-    fastEasyPlace: PROTO.Boolean,
-    materialGrabber: PROTO.Boolean,
-    materialInstanceName: PROTO.String
-});
-
-export const BuilderIdParameterModel = PROTO.Object({
-    playerId: PROTO.String
-});

packs/BP/scripts/lib/AddonAPIKit.js

@@ -640,9 +640,9 @@ var APIErrorEnum = Object.freeze({
 // src/Errors/APICallerError.js
 var APICallerError = class extends Error {
   constructor(error) {
-    super(error.message);
+    const message = error.name + ": " + error.message;
-    this.errorName = error.name;
+    super(message);
-    this.errorMessage = error.message;
+    this.thrownError = error;
     this.errorCode = APIErrorEnum.Caller;
     this.name = "APICallerError";
   }
@@ -651,7 +651,8 @@ var APICallerError = class extends Error {
 // src/Errors/APIServerError.js
 var APIServerError = class extends Error {
   constructor(error) {
-    super(error.message);
+    const message = error.name + ": " + error.message;
+    super(message);
     this.thrownError = error;
     this.errorCode = APIErrorEnum.Server;
     this.name = "APIServerError";
@@ -686,12 +687,8 @@ var EndpointModel = PROTO.String;
 var EndpointsModel = PROTO.Array(EndpointModel);
 
 // src/APIController.js
-var APIController = class _APIController {
+var APIController = class {
   #endpoints = {};
-  constructor() {
-    if (this.constructor === _APIController)
-      throw new Error("Cannot instantiate abstract class 'APIController'");
-  }
   get endpoints() {
     return this.#endpoints;
   }
@@ -704,6 +701,7 @@ var APIController = class _APIController {
 var EndpointsController = class extends APIController {
   #api;
   constructor(api) {
+    super();
     this.#api = api;
     this.addEndpoint("endpoints", this.getEndpoints, VoidModel, EndpointsModel);
     this.addEndpoint("endpoints:has", this.hasEndpoint, EndpointModel, PROTO.Boolean);
@@ -716,8 +714,8 @@ var EndpointsController = class extends APIController {
   }
 };
 
-// src/AddonAPI.js
+// src/AddonAPIServer.js
-var AddonAPI = class {
+var AddonAPIServer = class {
   #name;
   #version;
   #allEndpoints;
@@ -812,30 +810,56 @@ var APIEndpointNotFoundError = class extends Error {
 };
 
 // src/AddonAPICaller.js
-var AddonAPICaller = class {
+var AddonAPICaller = class _AddonAPICaller {
   static #validEndpointCache = [];
   static async call(endpoint, parameterModel, parameterMap, returnDataModel) {
-    if (this.#validEndpointCache.length === 0) {
+    await _AddonAPICaller.#tryPopulateEndpointCache(endpoint);
-      const endpointBase = endpoint.split(":")[0];
+    if (_AddonAPICaller.#endpointExists(endpoint)) {
-      await this.#populateValidEndpointCache(endpointBase);
+      const response = await IPC.invoke(endpoint, parameterModel, parameterMap, returnDataModel).then((result) => result.value);
-    }
+      return _AddonAPICaller.#unwrapPacket(response);
-    if (this.#validEndpointCache.includes(endpoint))
+    } else {
-      return await IPC.invoke(endpoint, parameterModel, parameterMap, returnDataModel).then((result) => result.value);
-    else
       throw new APIEndpointNotFoundError(endpoint);
     }
+  }
+  static async #tryPopulateEndpointCache(endpoint) {
+    if (_AddonAPICaller.#validEndpointCache.length === 0) {
+      const endpointBase = endpoint.split(":")[0];
+      await _AddonAPICaller.#populateValidEndpointCache(endpointBase);
+    }
+  }
+  static #endpointExists(endpoint) {
+    return _AddonAPICaller.#validEndpointCache.includes(endpoint);
+  }
   static async #populateValidEndpointCache(endpointBase) {
     const endpointsEndpoint = endpointBase + ":endpoints";
     const validEndpoints = await IPC.invoke(endpointsEndpoint, VoidModel, void 0, PROTO.Boolean);
-    this.#validEndpointCache.push(...validEndpoints);
+    _AddonAPICaller.#validEndpointCache.push(...validEndpoints);
+  }
+  static #unwrapPacket(packet) {
+    const { data, error } = packet;
+    if (error.code === APIErrorEnum.Success)
+      return data;
+    else
+      _AddonAPICaller.#throwAPIError(packet.error);
+  }
+  static #throwAPIError(errorData) {
+    switch (errorData.code) {
+      case APIErrorEnum.Caller:
+        throw new APICallerError(errorData);
+      case APIErrorEnum.Server:
+        throw new APIServerError(errorData);
+      case APIErrorEnum.Unknown:
+      default:
+        throw new Error(errorData.message);
+    }
   }
 };
 export {
   APICallerError,
   APIController,
   APIErrorEnum,
-  AddonAPI,
   AddonAPICaller,
+  AddonAPIServer,
   PROTO,
   VoidModel
 };