@devrev/ts-adaas 1.13.1-beta.1 → 1.13.1-beta.3

package/dist/common/constants.d.ts

@@ -8,7 +8,6 @@ export declare const STATELESS_EVENT_TYPES: EventType[];
 export declare const STATEFUL_EXTRACTION_EVENT_TYPES: EventType[];
 export declare const STATEFUL_LOADING_EVENT_TYPES: EventType[];
 export declare const STATEFUL_EVENT_TYPES: EventType[];
-export declare const DELETE_EVENT_TYPES: EventType[];
 export declare const ARTIFACT_BATCH_SIZE = 2000;
 export declare const MAX_DEVREV_ARTIFACT_SIZE: number;
 export declare const MAX_DEVREV_FILENAME_LENGTH = 256;

package/dist/common/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/common/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAGhD,eAAO,MAAM,8BAA8B,aAS1C,CAAC;AAEF,eAAO,MAAM,2BAA2B,aAKvC,CAAC;AAEF,eAAO,MAAM,mBAAmB,aAG/B,CAAC;AAEF,eAAO,MAAM,gCAAgC,aAI5C,CAAC;AAEF,eAAO,MAAM,6BAA6B,aAGzC,CAAC;AAEF,eAAO,MAAM,qBAAqB,aAGjC,CAAC;AAEF,eAAO,MAAM,+BAA+B,aAGzC,CAAC;AAEJ,eAAO,MAAM,4BAA4B,aAExC,CAAC;AAEF,eAAO,MAAM,oBAAoB,aAGhC,CAAC;AAEF,eAAO,MAAM,kBAAkB,aAK9B,CAAC;AAEF,eAAO,MAAM,mBAAmB,OAAO,CAAC;AACxC,eAAO,MAAM,wBAAwB,QAAyB,CAAC;AAC/D,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAC9C,eAAO,MAAM,oCAAoC,KAAK,CAAC;AAEvD,eAAO,MAAM,0BAA0B;;;;CAItC,CAAC;AAEF,eAAO,MAAM,eAAe,KAAsB,CAAC;AAEnD,eAAO,MAAM,sBAAsB,QAAiB,CAAC;AACrD,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAC3C,eAAO,MAAM,mBAAmB,QAAY,CAAC;AAE7C,eAAO,MAAM,sBAAsB,QAAgB,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/common/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAGhD,eAAO,MAAM,8BAA8B,aAS1C,CAAC;AAEF,eAAO,MAAM,2BAA2B,aAKvC,CAAC;AAEF,eAAO,MAAM,mBAAmB,aAG/B,CAAC;AAEF,eAAO,MAAM,gCAAgC,aAI5C,CAAC;AAEF,eAAO,MAAM,6BAA6B,aAGzC,CAAC;AAEF,eAAO,MAAM,qBAAqB,aAGjC,CAAC;AAEF,eAAO,MAAM,+BAA+B,aAGzC,CAAC;AAEJ,eAAO,MAAM,4BAA4B,aAExC,CAAC;AAEF,eAAO,MAAM,oBAAoB,aAGhC,CAAC;AAEF,eAAO,MAAM,mBAAmB,OAAO,CAAC;AACxC,eAAO,MAAM,wBAAwB,QAAyB,CAAC;AAC/D,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAC9C,eAAO,MAAM,oCAAoC,KAAK,CAAC;AAEvD,eAAO,MAAM,0BAA0B;;;;CAItC,CAAC;AAEF,eAAO,MAAM,eAAe,KAAsB,CAAC;AAEnD,eAAO,MAAM,sBAAsB,QAAiB,CAAC;AACrD,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAC3C,eAAO,MAAM,mBAAmB,QAAY,CAAC;AAE7C,eAAO,MAAM,sBAAsB,QAAgB,CAAC"}

package/dist/common/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_SLEEP_DELAY_MS = exports.MEMORY_LOG_INTERVAL = exports.HARD_TIMEOUT_MULTIPLIER = exports.DEFAULT_LAMBDA_TIMEOUT = exports.LIBRARY_VERSION = exports.AIRDROP_DEFAULT_ITEM_TYPES = exports.MAX_DEVREV_FILENAME_EXTENSION_LENGTH = exports.MAX_DEVREV_FILENAME_LENGTH = exports.MAX_DEVREV_ARTIFACT_SIZE = exports.ARTIFACT_BATCH_SIZE = exports.DELETE_EVENT_TYPES = exports.STATEFUL_EVENT_TYPES = exports.STATEFUL_LOADING_EVENT_TYPES = exports.STATEFUL_EXTRACTION_EVENT_TYPES = exports.STATELESS_EVENT_TYPES = exports.STATELESS_LOADING_EVENT_TYPES = exports.STATELESS_EXTRACTION_EVENT_TYPES = exports.ALLOWED_EVENT_TYPES = exports.ALLOWED_LOADING_EVENT_TYPES = exports.ALLOWED_EXTRACTION_EVENT_TYPES = void 0;
+exports.DEFAULT_SLEEP_DELAY_MS = exports.MEMORY_LOG_INTERVAL = exports.HARD_TIMEOUT_MULTIPLIER = exports.DEFAULT_LAMBDA_TIMEOUT = exports.LIBRARY_VERSION = exports.AIRDROP_DEFAULT_ITEM_TYPES = exports.MAX_DEVREV_FILENAME_EXTENSION_LENGTH = exports.MAX_DEVREV_FILENAME_LENGTH = exports.MAX_DEVREV_ARTIFACT_SIZE = exports.ARTIFACT_BATCH_SIZE = exports.STATEFUL_EVENT_TYPES = exports.STATEFUL_LOADING_EVENT_TYPES = exports.STATEFUL_EXTRACTION_EVENT_TYPES = exports.STATELESS_EVENT_TYPES = exports.STATELESS_LOADING_EVENT_TYPES = exports.STATELESS_EXTRACTION_EVENT_TYPES = exports.ALLOWED_EVENT_TYPES = exports.ALLOWED_LOADING_EVENT_TYPES = exports.ALLOWED_EXTRACTION_EVENT_TYPES = void 0;
 const extraction_1 = require("../types/extraction");
 const helpers_1 = require("./helpers");
 exports.ALLOWED_EXTRACTION_EVENT_TYPES = [
@@ -42,12 +42,6 @@ exports.STATEFUL_EVENT_TYPES = [
     ...exports.STATEFUL_EXTRACTION_EVENT_TYPES,
     ...exports.STATEFUL_LOADING_EVENT_TYPES,
 ];
-exports.DELETE_EVENT_TYPES = [
-    extraction_1.EventType.StartDeletingExtractorState,
-    extraction_1.EventType.StartDeletingExtractorAttachmentsState,
-    extraction_1.EventType.StartDeletingLoaderState,
-    extraction_1.EventType.StartDeletingLoaderAttachmentState,
-];
 exports.ARTIFACT_BATCH_SIZE = 2000;
 exports.MAX_DEVREV_ARTIFACT_SIZE = 2 * 1024 * 1024 * 1024; // 2GB
 exports.MAX_DEVREV_FILENAME_LENGTH = 256;

package/dist/common/helpers.d.ts

@@ -3,6 +3,11 @@ import { FileToLoad, LoaderEventType, LoaderReport, StatsFileObject } from '../t
 export declare function getTimeoutErrorEventType(eventType: EventType): {
     eventType: ExtractorEventType | LoaderEventType;
 };
+export declare function getNoScriptEventType(eventType: EventType): {
+    eventType: ExtractorEventType;
+} | {
+    eventType: LoaderEventType;
+};
 export declare function getSyncDirection({ event }: {
     event: AirdropEvent;
 }): string;

package/dist/common/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/common/helpers.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,YAAY,EACZ,SAAS,EACT,kBAAkB,EACnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAEL,UAAU,EACV,eAAe,EACf,YAAY,EACZ,eAAe,EAChB,MAAM,kBAAkB,CAAC;AAM1B,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,SAAS,GAAG;IAC9D,SAAS,EAAE,kBAAkB,GAAG,eAAe,CAAC;CACjD,CAmFA;AAED,wBAAgB,gBAAgB,CAAC,EAAE,KAAK,EAAE,EAAE;IAAE,KAAK,EAAE,YAAY,CAAA;CAAE,UAElE;AAED,wBAAgB,cAAc,CAAC,EAC7B,kBAAkB,EAClB,SAAS,GACV,EAAE;IACD,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,SAAS,EAAE,eAAe,EAAE,CAAC;CAC9B,GAAG,UAAU,EAAE,CA8Bf;AAED,wBAAgB,uBAAuB,CAAC,EACtC,aAAa,EACb,MAAM,GACP,EAAE;IACD,aAAa,EAAE,YAAY,EAAE,CAAC;IAC9B,MAAM,EAAE,YAAY,CAAC;CACtB,GAAG,YAAY,EAAE,CA4BjB;AAGD,wBAAgB,iBAAiB,QAiBhC;AAED,wBAAsB,KAAK,CAAC,EAAE,EAAE,MAAM,oBAGrC;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAmBzD;AAED,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,wBAAgB,cAAc,IAAI,UAAU,CAmD3C"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/common/helpers.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,YAAY,EACZ,SAAS,EACT,kBAAkB,EACnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAEL,UAAU,EACV,eAAe,EACf,YAAY,EACZ,eAAe,EAChB,MAAM,kBAAkB,CAAC;AAM1B,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,SAAS,GAAG;IAC9D,SAAS,EAAE,kBAAkB,GAAG,eAAe,CAAC;CACjD,CAmFA;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,SAAS;;;;EA2BxD;AAED,wBAAgB,gBAAgB,CAAC,EAAE,KAAK,EAAE,EAAE;IAAE,KAAK,EAAE,YAAY,CAAA;CAAE,UAElE;AAED,wBAAgB,cAAc,CAAC,EAC7B,kBAAkB,EAClB,SAAS,GACV,EAAE;IACD,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,SAAS,EAAE,eAAe,EAAE,CAAC;CAC9B,GAAG,UAAU,EAAE,CA8Bf;AAED,wBAAgB,uBAAuB,CAAC,EACtC,aAAa,EACb,MAAM,GACP,EAAE;IACD,aAAa,EAAE,YAAY,EAAE,CAAC;IAC9B,MAAM,EAAE,YAAY,CAAC;CACtB,GAAG,YAAY,EAAE,CA4BjB;AAGD,wBAAgB,iBAAiB,QAiBhC;AAED,wBAAsB,KAAK,CAAC,EAAE,EAAE,MAAM,oBAGrC;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAmBzD;AAED,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,wBAAgB,cAAc,IAAI,UAAU,CAmD3C"}

package/dist/common/helpers.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTimeoutErrorEventType = getTimeoutErrorEventType;
+exports.getNoScriptEventType = getNoScriptEventType;
 exports.getSyncDirection = getSyncDirection;
 exports.getFilesToLoad = getFilesToLoad;
 exports.addReportToLoaderReport = addReportToLoaderReport;
@@ -119,6 +120,32 @@ function getTimeoutErrorEventType(eventType) {
             };
     }
 }
+function getNoScriptEventType(eventType) {
+    switch (eventType) {
+        case extraction_1.EventType.StartDeletingExtractorState:
+            return {
+                eventType: extraction_1.ExtractorEventType.ExtractorStateDeletionDone,
+            };
+        case extraction_1.EventType.StartDeletingExtractorAttachmentsState:
+            return {
+                eventType: extraction_1.ExtractorEventType.ExtractorAttachmentsStateDeletionDone,
+            };
+        case extraction_1.EventType.StartDeletingLoaderState:
+            return {
+                eventType: loading_1.LoaderEventType.LoaderStateDeletionDone,
+            };
+        case extraction_1.EventType.StartDeletingLoaderAttachmentState:
+            return {
+                eventType: loading_1.LoaderEventType.LoaderAttachmentStateDeletionDone,
+            };
+        default:
+            console.error('Event type not recognized in getNoScriptEventType function: ' +
+                eventType);
+            return {
+                eventType: loading_1.LoaderEventType.UnknownEventType,
+            };
+    }
+}
 function getSyncDirection({ event }) {
     return event.payload.event_context.mode;
 }

package/dist/workers/spawn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spawn.d.ts","sourceRoot":"","sources":["../../src/workers/spawn.ts"],"names":[],"mappings":"AAYA,OAAO,EAEL,qBAAqB,EACrB,cAAc,EAGf,MAAM,kBAAkB,CAAC;AAqC1B;;;;;;;;;;GAUG;AACH,wBAAsB,KAAK,CAAC,cAAc,EAAE,EAC1C,KAAK,EACL,YAAY,EACZ,UAAU,EACV,oBAAoB,EACpB,OAAO,EACP,cAAc,GACf,EAAE,qBAAqB,CAAC,cAAc,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CA+HvD;AAED,qBAAa,KAAK;IAChB,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,cAAc,CAAU;IAChC,OAAO,CAAC,oBAAoB,CAAkC;IAC9D,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,gBAAgB,CAA4C;IACpE,OAAO,CAAC,gBAAgB,CAA4C;IACpE,OAAO,CAAC,wBAAwB,CAA6C;IAC7E,OAAO,CAAC,OAAO,CAA4C;IAC3D,OAAO,CAAC,eAAe,CAAU;IACjC,OAAO,CAAC,MAAM,CAAS;gBACX,EACV,KAAK,EACL,MAAM,EACN,OAAO,EACP,OAAO,EACP,eAAe,GAChB,EAAE,cAAc;IAgGjB,OAAO,CAAC,aAAa;YAYP,kBAAkB;CAiCjC"}
+{"version":3,"file":"spawn.d.ts","sourceRoot":"","sources":["../../src/workers/spawn.ts"],"names":[],"mappings":"AAYA,OAAO,EAEL,qBAAqB,EACrB,cAAc,EAGf,MAAM,kBAAkB,CAAC;AAmC1B;;;;;;;;;;GAUG;AACH,wBAAsB,KAAK,CAAC,cAAc,EAAE,EAC1C,KAAK,EACL,YAAY,EACZ,UAAU,EACV,oBAAoB,EACpB,OAAO,EACP,cAAc,GACf,EAAE,qBAAqB,CAAC,cAAc,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAqFvD;AAED,qBAAa,KAAK;IAChB,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,cAAc,CAAU;IAChC,OAAO,CAAC,oBAAoB,CAAkC;IAC9D,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,gBAAgB,CAA4C;IACpE,OAAO,CAAC,gBAAgB,CAA4C;IACpE,OAAO,CAAC,wBAAwB,CAA6C;IAC7E,OAAO,CAAC,OAAO,CAA4C;IAC3D,OAAO,CAAC,eAAe,CAAU;IACjC,OAAO,CAAC,MAAM,CAAS;gBACX,EACV,KAAK,EACL,MAAM,EACN,OAAO,EACP,OAAO,EACP,eAAe,GAChB,EAAE,cAAc;IAgGjB,OAAO,CAAC,aAAa;YAYP,kBAAkB;CAiCjC"}

package/dist/workers/spawn.js

@@ -15,7 +15,6 @@ const extraction_1 = require("../types/extraction");
 const workers_1 = require("../types/workers");
 const constants_1 = require("../common/constants");
 const create_worker_1 = require("./create-worker");
-const types_1 = require("../types");
 function getWorkerPath({ event, workerBasePath, }) {
     let path = null;
     switch (event.payload.event_type) {
@@ -111,53 +110,15 @@ async function spawn({ event, initialState, workerPath, initialDomainMapping, op
             return Promise.reject(error);
         }
     }
-    // If the script is not found and the event type is a delete event type, emit a done event.
-    else if (constants_1.DELETE_EVENT_TYPES.includes(event.payload.event_type)) {
-        switch (event.payload.event_type) {
-            case extraction_1.EventType.StartDeletingExtractorAttachmentsState:
-                await (0, control_protocol_1.emit)({
-                    event,
-                    eventType: extraction_1.ExtractorEventType.ExtractorAttachmentsStateDeletionDone,
-                });
-                break;
-            case extraction_1.EventType.StartDeletingLoaderAttachmentState:
-                await (0, control_protocol_1.emit)({
-                    event,
-                    eventType: types_1.LoaderEventType.LoaderAttachmentStateDeletionDone,
-                });
-                break;
-            case extraction_1.EventType.StartDeletingExtractorState:
-                await (0, control_protocol_1.emit)({
-                    event,
-                    eventType: extraction_1.ExtractorEventType.ExtractorStateDeletionDone,
-                });
-                break;
-            case extraction_1.EventType.StartDeletingLoaderState:
-                await (0, control_protocol_1.emit)({
-                    event,
-                    eventType: types_1.LoaderEventType.LoaderStateDeletionDone,
-                });
-                break;
-        }
-        // eslint-disable-next-line no-global-assign
-        console = originalConsole;
-        return Promise.resolve();
-    }
-    // If the script is not found and the event type is not a delete event type, emit an unknown event.
     else {
-        console.error(`Script was not found for event type: ${event.payload.event_type}.`);
+        const { eventType } = (0, helpers_2.getNoScriptEventType)(event.payload.event_type);
         await (0, control_protocol_1.emit)({
             event,
-            eventType: extraction_1.ExtractorEventType.UnknownEventType,
-            data: {
-                error: {
-                    message: `Unrecognized event type in spawn ${event.payload.event_type}.`,
-                },
-            },
+            eventType,
         });
         // eslint-disable-next-line no-global-assign
         console = originalConsole;
-        return Promise.reject();
+        return Promise.resolve();
     }
 }
 class Spawn {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devrev/ts-adaas",
-  "version": "1.13.1-beta.1",
+  "version": "1.13.1-beta.3",
   "description": "Typescript library containing the ADaaS(AirDrop as a Service) control protocol.",
   "type": "commonjs",
   "main": "./dist/index.js",
@@ -54,6 +54,7 @@
     "yargs": "^17.7.2"
   },
   "files": [
-    "dist"
+    "dist/**/*",
+    "!dist/tests/**/*"
   ]
 }

package/dist/tests/backwards-compatibility/backwards-compatibility.test.d.ts

@@ -1,3 +0,0 @@
-import { ApiConstructor, ApiFunction, ApiMethodSignature } from '@microsoft/api-extractor-model';
-export declare function checkFunctionCompatibility(newFunction: ApiFunction | ApiConstructor | ApiMethodSignature, currentFunction: ApiFunction | ApiConstructor | ApiMethodSignature): void;
-//# sourceMappingURL=backwards-compatibility.test.d.ts.map

package/dist/tests/backwards-compatibility/backwards-compatibility.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"backwards-compatibility.test.d.ts","sourceRoot":"","sources":["../../../src/tests/backwards-compatibility/backwards-compatibility.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,cAAc,EAGd,WAAW,EAGX,kBAAkB,EAKnB,MAAM,gCAAgC,CAAC;AAgBxC,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,WAAW,GAAG,cAAc,GAAG,kBAAkB,EAC9D,eAAe,EAAE,WAAW,GAAG,cAAc,GAAG,kBAAkB,QAuHnE"}

package/dist/tests/backwards-compatibility/backwards-compatibility.test.js

@@ -1,441 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkFunctionCompatibility = checkFunctionCompatibility;
-const api_extractor_model_1 = require("@microsoft/api-extractor-model");
-const helpers_1 = require("./helpers");
-function checkFunctionCompatibility(newFunction, currentFunction) {
-    var _a;
-    const lengthOfPreviousParameters = currentFunction.parameters.length;
-    it(`Function ${newFunction.displayName} should have at least as many parameters as the current function`, () => {
-        expect(newFunction.parameters.length).toBeGreaterThanOrEqual(currentFunction.parameters.length);
-    });
-    it(`Function ${newFunction.displayName} should have parameters in the same order as the current function`, () => {
-        const newFunctionParamNames = newFunction.parameters
-            .slice(0, lengthOfPreviousParameters)
-            .map((p) => p.name);
-        const currentFunctionParamNames = currentFunction.parameters.map((p) => p.name);
-        // Check each parameter position for destructured parameter compatibility
-        for (let i = 0; i <
-            Math.min(newFunctionParamNames.length, currentFunctionParamNames.length); i++) {
-            const newParam = newFunctionParamNames[i];
-            const currentParam = currentFunctionParamNames[i];
-            // If both are destructured parameters (contain '{')
-            if (newParam.includes('{') && currentParam.includes('{')) {
-                // Extract field names from destructured parameters
-                const extractFields = (param) => param
-                    .replace(/[{}\s]/g, '')
-                    .split(',')
-                    .filter((f) => f.length > 0);
-                const newFields = extractFields(newParam);
-                const currentFields = extractFields(currentParam);
-                // Check that all current fields are present in new fields
-                const missingFields = currentFields.filter((field) => !newFields.includes(field));
-                expect(missingFields).toEqual([]);
-            }
-            else {
-                // For non-destructured parameters, they must match exactly
-                expect(newParam).toEqual(currentParam);
-            }
-        }
-    });
-    it(`Function ${newFunction.displayName} should have compatible parameter types with the current function`, () => {
-        const newFunctionParamTypes = newFunction.parameters
-            .slice(0, lengthOfPreviousParameters)
-            .map((p) => p.parameterTypeExcerpt.text);
-        const currentFunctionParameterTypes = currentFunction.parameters.map((p) => p.parameterTypeExcerpt.text);
-        expect(newFunctionParamTypes).toEqual(currentFunctionParameterTypes);
-    });
-    // Check return type compatibility
-    // This check fails if it's a constructor, as those don't have a return type
-    if (currentFunction instanceof api_extractor_model_1.ApiFunction &&
-        newFunction instanceof api_extractor_model_1.ApiFunction) {
-        if (!((_a = currentFunction.returnTypeExcerpt) === null || _a === void 0 ? void 0 : _a.isEmpty)) {
-            if (newFunction.returnTypeExcerpt.text !=
-                currentFunction.returnTypeExcerpt.text) {
-                // This will pass, if the new implementation is an object and the current one is not specified or a hard-coded type.
-                if (!(currentFunction.returnTypeExcerpt.text.split(' ').length != 1 &&
-                    newFunction.returnTypeExcerpt.text.split(' ').length == 1)) {
-                    it(`Function ${newFunction.displayName} should have the same return type as the current function`, () => {
-                        expect(newFunction.returnTypeExcerpt.text).toEqual(currentFunction.returnTypeExcerpt.text);
-                    });
-                }
-            }
-        }
-    }
-    it(`Function ${newFunction.displayName} should have all new parameters as optional`, () => {
-        const newParameters = newFunction.parameters.slice(lengthOfPreviousParameters);
-        expect(newParameters.every((p) => p.isOptional)).toBe(true);
-    });
-    it(`Function ${newFunction.displayName} should not have any optional parameters that became required`, () => {
-        const minLength = Math.min(newFunction.parameters.length, currentFunction.parameters.length);
-        for (let i = 0; i < minLength; i++) {
-            const newParam = newFunction.parameters[i];
-            const currentParam = currentFunction.parameters[i];
-            // If current parameter was optional, new parameter should also be optional
-            if (currentParam.isOptional && !newParam.isOptional) {
-                throw new Error(`Parameter ${newParam.name} became required but was optional`);
-            }
-            // Skip interface compatibility check for destructured parameters
-            if (newParam.name.includes('{') || currentParam.name.includes('{')) {
-                continue;
-            }
-        }
-    });
-}
-describe('Backwards Compatibility', () => {
-    let failure = false;
-    afterEach(() => {
-        var _a;
-        // Check if current test failed
-        if (expect.getState().currentTestName &&
-            ((_a = expect.getState().suppressedErrors) === null || _a === void 0 ? void 0 : _a.length) > 0) {
-            failure = true;
-        }
-    });
-    describe('Exports', () => {
-        describe('should verify that all exports in current are still in new', () => {
-            const { newApiMembers, currentApiMembers } = (0, helpers_1.loadApiData)();
-            const newExports = newApiMembers.map((m) => m.displayName);
-            const currentExports = currentApiMembers.map((m) => m.displayName);
-            it.each(currentExports)('should contain export: %s', (exportName) => {
-                expect(newExports).toContain(exportName);
-            });
-        });
-    });
-    describe('Functions', () => {
-        describe('should have all current functions exported in new', () => {
-            const { newApiMembers, currentApiMembers } = (0, helpers_1.loadApiData)();
-            const newFunctions = (0, helpers_1.getFunctions)(newApiMembers);
-            const currentFunctions = (0, helpers_1.getFunctions)(currentApiMembers);
-            const newFunctionNames = newFunctions.map((f) => f.name);
-            for (const currentFunction of currentFunctions) {
-                it(`should contain function: ${currentFunction.name}`, () => {
-                    expect(newFunctionNames).toContain(currentFunction.name);
-                });
-            }
-        });
-        describe('should verify function compatibility for each function', () => {
-            const { newApiMembers, currentApiMembers } = (0, helpers_1.loadApiData)();
-            const newFunctions = (0, helpers_1.getFunctions)(newApiMembers);
-            const currentFunctions = (0, helpers_1.getFunctions)(currentApiMembers);
-            for (const newFunction of newFunctions) {
-                const currentFunction = currentFunctions.find((f) => f.name === newFunction.name);
-                // Skip if function doesn't exist in current API
-                if (!currentFunction) {
-                    continue;
-                }
-                checkFunctionCompatibility(newFunction, currentFunction);
-            }
-            // TODO: Check that optional promotion works only one way (no required parameters becoming optional, but optional parameters can become required)
-            // TODO: Check that function overloads weren't removed
-            // TODO: Verify that function parameter destructuring patterns maintain compatibility
-            // TODO: Check that function parameter default values don't change in breaking ways
-        });
-    });
-    describe('Classes', () => {
-        describe('should verify class property counts and compatibility', () => {
-            const { newApiMembers, currentApiMembers } = (0, helpers_1.loadApiData)();
-            const newClasses = (0, helpers_1.getClasses)(newApiMembers);
-            const currentClasses = (0, helpers_1.getClasses)(currentApiMembers);
-            for (const newClass of newClasses) {
-                const currentClass = currentClasses.find((c) => c.name === newClass.name);
-                // Skip if class doesn't exist in current API
-                if (!currentClass) {
-                    continue;
-                }
-                const newClassProperties = (0, helpers_1.getProperties)(newClass.members);
-                const currentClassProperties = (0, helpers_1.getProperties)(currentClass.members);
-                describe(`Class ${newClass.name} should have at least all public properties from the current class`, () => {
-                    const newPropertyNames = newClassProperties.map((p) => p.name);
-                    for (const currentProperty of currentClassProperties) {
-                        it(`should contain property: ${currentProperty.name}`, () => {
-                            expect(newPropertyNames).toContain(currentProperty.name);
-                        });
-                    }
-                });
-                describe(`Class ${newClass.name} should not have any optional properties that became required`, () => {
-                    for (const currentProperty of currentClassProperties) {
-                        it(`should not have optional property that became required: ${currentProperty.name}`, () => {
-                            const newProperty = newClassProperties.find((p) => p.name === currentProperty.name);
-                            if (newProperty && currentProperty.isOptional) {
-                                // If the current property was optional, the new property should also be optional
-                                expect(newProperty.isOptional).toBe(true);
-                            }
-                        });
-                    }
-                });
-                // Check property compatibility
-                const oldProperties = currentClassProperties;
-                const newProperties = newClassProperties;
-                for (const newProperty of newProperties) {
-                    const currentProperty = oldProperties.find((p) => p.name === newProperty.name);
-                    // If the property is new, there's no need to check for compatibility
-                    if (!currentProperty) {
-                        continue;
-                    }
-                    it(`Class ${newClass.name} property ${newProperty.name} should have the same type as the current property`, () => {
-                        expect(newProperty.propertyTypeExcerpt.text).toEqual(currentProperty.propertyTypeExcerpt.text);
-                    });
-                    it(`Class ${newClass.name} property ${newProperty.name} should have the same optionality as the current property`, () => {
-                        expect(newProperty.isOptional).toEqual(currentProperty.isOptional);
-                    });
-                }
-                // Check constructor signature compatibility (same rules as functions)
-                const currentMethod = (0, helpers_1.getConstructor)(currentClass.members);
-                const newMethod = (0, helpers_1.getConstructor)(newClass.members);
-                checkFunctionCompatibility(newMethod, currentMethod);
-                // Check method count
-                const newClassMethods = (0, helpers_1.getFunctions)(newClass.members);
-                const currentClassMethods = (0, helpers_1.getFunctions)(currentClass.members);
-                describe(`Class ${newClass.name} should export all public methods from the current class`, () => {
-                    const newMethodNames = newClassMethods.map((m) => m.name);
-                    for (const currentMethod of currentClassMethods) {
-                        it(`should contain method: ${currentMethod.name}`, () => {
-                            expect(newMethodNames).toContain(currentMethod.name);
-                        });
-                    }
-                });
-                // Check method compatibility (same rules as functions)
-                // Make sure to allow optional parameters to be added to the end
-                for (const newMethod of newClassMethods) {
-                    const currentMethod = currentClassMethods.find((m) => m.name === newMethod.name);
-                    // If the method is new, there's no need to check for compatibility
-                    if (!currentMethod) {
-                        continue;
-                    }
-                    checkFunctionCompatibility(newMethod, currentMethod);
-                }
-                // TODO: Verify class inheritance hierarchy hasn't changed in breaking ways
-                // TODO: Check that class mixins maintain their composition behavior
-                // TODO: Verify that abstract class methods remain abstract or are properly implemented
-            }
-        });
-    });
-    describe('Interfaces', () => {
-        const { newApiMembers, currentApiMembers } = (0, helpers_1.loadApiData)();
-        const newInterfaces = (0, helpers_1.getInterfaces)(newApiMembers);
-        const currentInterfaces = (0, helpers_1.getInterfaces)(currentApiMembers);
-        describe('should verify interface property counts and compatibility', () => {
-            for (const newInterface of newInterfaces) {
-                const currentInterface = currentInterfaces.find((i) => i.name === newInterface.name);
-                if (!currentInterface) {
-                    continue;
-                }
-                const newInterfaceProperties = (0, helpers_1.getPropertySignatures)(newInterface.members);
-                const currentInterfaceProperties = (0, helpers_1.getPropertySignatures)(currentInterface.members);
-                it(`Interface ${newInterface.name} should have at least as many properties as the current interface`, () => {
-                    expect(newInterfaceProperties.length).toBeGreaterThanOrEqual(currentInterfaceProperties.length);
-                });
-                it(`Interface ${newInterface.name} should not have any optional properties that became required`, () => {
-                    const requiredProperties = newInterfaceProperties.filter((p) => !p.isOptional);
-                    expect(requiredProperties.length).toBeLessThanOrEqual(currentInterfaceProperties.filter((p) => !p.isOptional).length);
-                });
-                // Check property compatibility
-                const oldProperties = currentInterfaceProperties;
-                const newProperties = newInterfaceProperties;
-                for (const newProperty of newProperties) {
-                    const currentProperty = oldProperties.find((p) => p.name === newProperty.name);
-                    // If the property is new, there's no need to check for compatibility
-                    if (!currentProperty) {
-                        continue;
-                    }
-                    it(`Interface ${newInterface.name} property ${newProperty.name} should have the same type as the current property`, () => {
-                        expect(newProperty.propertyTypeExcerpt.text).toEqual(currentProperty.propertyTypeExcerpt.text);
-                    });
-                    it(`Interface ${newInterface.name} property ${newProperty.name} should have not been made required if it was optional`, () => {
-                        // If the new property is required, it must have been required before.
-                        // Otherwise we break backwards-compatibility.
-                        expect(
-                        // If it was required before, it can be either now.
-                        !currentProperty.isOptional ||
-                            // If it was optional before, it can only be optional now.
-                            newProperty.isOptional).toEqual(true);
-                    });
-                }
-                // Check method count
-                const newInterfaceMethods = (0, helpers_1.getMethodSignatures)(newInterface.members);
-                const currentInterfaceMethods = (0, helpers_1.getMethodSignatures)(currentInterface.members);
-                it(`Interface ${newInterface.name} should have at least as many public methods as the current interface`, () => {
-                    expect(newInterfaceMethods.length).toBeGreaterThanOrEqual(currentInterfaceMethods.length);
-                });
-                // Check method compatibility (same rules as functions)
-                // Make sure to allow optional parameters to be added to the end
-                for (const newMethod of newInterfaceMethods) {
-                    const currentMethod = currentInterfaceMethods.find((m) => m.name === newMethod.name);
-                    // If the method is new, there's no need to check for compatibility
-                    if (!currentMethod) {
-                        continue;
-                    }
-                    checkFunctionCompatibility(newMethod, currentMethod);
-                }
-            }
-        });
-        // TODO: Verify interface inheritance hierarchy hasn't changed
-        // TODO: Check that interface merging behavior is preserved
-        // TODO: Verify that interface index signatures maintain their key/value types
-    });
-    describe('Enums', () => {
-        let newEnums;
-        let currentEnums;
-        describe('should verify enum value counts and existence', () => {
-            const { newApiMembers, currentApiMembers } = (0, helpers_1.loadApiData)();
-            newEnums = (0, helpers_1.getEnums)(newApiMembers);
-            currentEnums = (0, helpers_1.getEnums)(currentApiMembers);
-            // Verify no enum values were removed
-            for (const newEnum of newEnums) {
-                const currentEnum = currentEnums.find((e) => e.name === newEnum.name);
-                // If it's a new enum, there's no need to check for compatibility
-                if (!currentEnum) {
-                    continue;
-                }
-                const currentEnumValues = currentEnum.members;
-                const newEnumValues = newEnum.members;
-                it(`Enum ${newEnum.name} should have at least as many enum values as the current enum`, () => {
-                    expect(newEnumValues.length).toBeGreaterThanOrEqual(currentEnumValues.length);
-                });
-                for (const currentEnumValue of currentEnumValues) {
-                    const newEnumValue = newEnumValues.find((v) => v.name === currentEnumValue.name);
-                    // If it's a new enum value, there's no need to check for compatibility
-                    if (!newEnumValue) {
-                        continue;
-                    }
-                    it(`Enum ${newEnum.name} should contain enum value: ${currentEnumValue.name}`, () => {
-                        expect(newEnumValue).toBeDefined();
-                    });
-                }
-            }
-        });
-        // Verify numeric enum values haven't changed (if numeric enum)
-        describe('should verify numeric enum values have not changed', () => {
-            const { newApiMembers, currentApiMembers } = (0, helpers_1.loadApiData)();
-            newEnums = (0, helpers_1.getEnums)(newApiMembers);
-            currentEnums = (0, helpers_1.getEnums)(currentApiMembers);
-            for (const newEnum of newEnums) {
-                const currentEnum = currentEnums.find((e) => e.name === newEnum.name);
-                // If it's a new enum, there's no need to check for compatibility
-                if (!currentEnum) {
-                    continue;
-                }
-                // Helper function to determine if an enum is numeric based on its members' initializer values
-                const isNumericEnum = (enumMembers) => {
-                    return enumMembers.every((member) => {
-                        var _a, _b, _c;
-                        // Check if the member has an initializer and if it's a numeric value
-                        const initializerText = (_c = (_b = (_a = member.excerptTokens) === null || _a === void 0 ? void 0 : _a.find((token) => token.kind === 'Content' && /^\d+$/.test(token.text.trim()))) === null || _b === void 0 ? void 0 : _b.text) === null || _c === void 0 ? void 0 : _c.trim();
-                        return (initializerText !== undefined && /^\d+$/.test(initializerText));
-                    });
-                };
-                const newEnumNumeric = isNumericEnum([...newEnum.members]);
-                const currentEnumNumeric = isNumericEnum([...currentEnum.members]);
-                it(`Enum ${newEnum.name} should have the same numeric type as the current enum`, () => {
-                    expect(newEnumNumeric).toBe(currentEnumNumeric);
-                });
-                const currentEnumValues = currentEnum.members;
-                const newEnumValues = newEnum.members;
-                it(`Enum ${newEnum.name} should have at least as many enum values as the current enum`, () => {
-                    expect(newEnumValues.length).toBeGreaterThanOrEqual(currentEnumValues.length);
-                });
-                for (const currentEnumValue of currentEnumValues) {
-                    const newEnumValue = newEnumValues.find((v) => v.name === currentEnumValue.name);
-                    // If it's not defined, an existing value is missing from the new enum
-                    it(`Enum ${newEnum.name} should contain enum value: ${currentEnumValue.name}`, () => {
-                        expect(newEnumValue).toBeDefined();
-                    });
-                    it(`Enum ${newEnum.name} should have the same value for enum member: ${currentEnumValue.name}`, () => {
-                        var _a, _b;
-                        // Both can be undefined, but they should always equal each other
-                        const newValue = (_a = newEnumValue.initializerExcerpt) === null || _a === void 0 ? void 0 : _a.text;
-                        const currentValue = (_b = currentEnumValue.initializerExcerpt) === null || _b === void 0 ? void 0 : _b.text;
-                        expect(newValue).toEqual(currentValue);
-                    });
-                }
-            }
-        });
-        // TODO: Check that new enum values were only added at the end (best practice)
-        // TODO: Verify that const enums maintain their compile-time behavior
-        // TODO: Check that enum member values don't change in breaking ways
-        describe('should verify enum value types have been added to the end', () => {
-            const { newApiMembers, currentApiMembers } = (0, helpers_1.loadApiData)();
-            newEnums = (0, helpers_1.getEnums)(newApiMembers);
-            currentEnums = (0, helpers_1.getEnums)(currentApiMembers);
-            for (const newEnum of newEnums) {
-                const currentEnum = currentEnums.find((e) => e.name === newEnum.name);
-                // If it's a new enum, there's no need to check for compatibility
-                if (!currentEnum) {
-                    continue;
-                }
-                const currentEnumValues = currentEnum.members.map((a) => a.name);
-                const newEnumValues = newEnum.members
-                    .slice(0, currentEnumValues.length)
-                    .map((a) => a.name);
-                // This might appear to not be working sometimes, but remember that the order of enum values is determined by the enum member key name
-                it(`Enum ${newEnum.name} should have added new options to the end of the array`, () => {
-                    expect(newEnumValues).toStrictEqual(currentEnumValues);
-                });
-            }
-        });
-    });
-    describe('Types', () => {
-        const { newApiMembers, currentApiMembers } = (0, helpers_1.loadApiData)();
-        const newTypes = (0, helpers_1.getTypes)(newApiMembers);
-        const currentTypes = (0, helpers_1.getTypes)(currentApiMembers);
-        // Verify type aliases weren't removed
-        describe("should verify type aliases weren't removed", () => {
-            for (const newType of newTypes) {
-                const currentType = currentTypes.find((t) => t.name === newType.name);
-                if (!currentType) {
-                    continue;
-                }
-                it(`Type ${newType.name} should not have been removed`, () => {
-                    expect(currentType).toBeDefined();
-                });
-            }
-        });
-        // Verify that the type alias is the same as the current type alias
-        describe('should verify type aliases are the same as the current type aliases', () => {
-            for (const newType of newTypes) {
-                const currentType = currentTypes.find((t) => t.name === newType.name);
-                if (!currentType) {
-                    continue;
-                }
-                it(`Type ${newType.name} should have the same type as the current type`, () => {
-                    // Replace all whitespace with an empty string to ignore whitespace differences
-                    expect(newType.typeExcerpt.text.replace(/\s/g, '')).toEqual(currentType.typeExcerpt.text.replace(/\s/g, ''));
-                });
-            }
-        });
-        // TODO: Verify union types didn't become more restrictive (no types removed from union)
-        // TODO: Verify intersection types didn't become more permissive (no required types removed)
-        // TODO: Check generic type parameter compatibility
-    });
-    describe('Method Signatures', () => {
-        // TODO: Verify generic constraints haven't become more restrictive
-        // TODO: Check that default parameter values are still compatible
-        // TODO: Verify rest parameters (...args) compatibility
-        // TODO: Check function signature overloads
-    });
-    describe('Generics', () => {
-        // TODO: Verify generic type parameters weren't removed
-        // TODO: Check that generic constraints didn't become more restrictive
-        // TODO: Verify generic parameter names haven't changed (affects explicit type arguments)
-        // TODO: Check variance compatibility (covariant/contravariant)
-    });
-    describe('Property Types', () => {
-        // TODO: Check readonly properties didn't become mutable (or vice versa in breaking way)
-        // TODO: Verify array types compatibility (T[] vs Array<T>)
-        // TODO: Check Promise/async compatibility
-        // TODO: Verify callback function signature compatibility
-    });
-    describe('Accessibility', () => {
-        // TODO: Verify public members didn't become private/protected
-        // TODO: Check that protected members didn't become private
-        // TODO: Ensure no breaking changes in static vs instance members
-    });
-    afterAll(() => {
-        // If there are any failures, don't update the current API baseline files
-        if (failure) {
-            return;
-        }
-        (0, helpers_1.updateCurrentApiJson)();
-    });
-});