@devrev/ts-adaas 1.9.0 → 1.10.0-beta.1

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

@@ -0,0 +1,401 @@
+"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);
+        expect(newFunctionParamNames).toEqual(currentFunctionParamNames);
+    });
+    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)) {
+            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`);
+            }
+        }
+    });
+}
+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)();
+    });
+});

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

@@ -0,0 +1,21 @@
+import { ApiClass, ApiConstructor, ApiEnum, ApiFunction, ApiInterface, ApiItem, ApiMethodSignature, ApiProperty, ApiPropertySignature, ApiTypeAlias } from '@microsoft/api-extractor-model';
+export declare const newApiMdPath: string;
+export declare const currentApiMdPath: string;
+export declare const newApiJsonPath: string;
+export declare const currentApiJsonPath: string;
+export declare function generateApiReport(): void;
+export declare const loadApiData: () => {
+    newApiMembers: readonly ApiItem[];
+    currentApiMembers: readonly ApiItem[];
+};
+export declare const getFunctions: (members: readonly ApiItem[]) => ApiFunction[];
+export declare const getConstructor: (members: readonly ApiItem[]) => ApiConstructor;
+export declare const getEnums: (members: readonly ApiItem[]) => ApiEnum[];
+export declare const getClasses: (members: readonly ApiItem[]) => ApiClass[];
+export declare const getProperties: (members: readonly ApiItem[]) => ApiProperty[];
+export declare const getTypes: (members: readonly ApiItem[]) => ApiTypeAlias[];
+export declare const getInterfaces: (members: readonly ApiItem[]) => ApiInterface[];
+export declare const getMethodSignatures: (members: readonly ApiItem[]) => ApiMethodSignature[];
+export declare const getPropertySignatures: (members: readonly ApiItem[]) => ApiPropertySignature[];
+export declare const updateCurrentApiJson: () => void;
+//# sourceMappingURL=helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/tests/backwards-compatibility/helpers.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EACR,cAAc,EACd,OAAO,EAEP,WAAW,EACX,YAAY,EACZ,OAAO,EACP,kBAAkB,EAElB,WAAW,EACX,oBAAoB,EACpB,YAAY,EAEb,MAAM,gCAAgC,CAAC;AAMxC,eAAO,MAAM,YAAY,QAA8C,CAAC;AACxE,eAAO,MAAM,gBAAgB,QAAsC,CAAC;AACpE,eAAO,MAAM,cAAc,QAAoD,CAAC;AAChF,eAAO,MAAM,kBAAkB,QAAsC,CAAC;AAGtE,wBAAgB,iBAAiB,IAAI,IAAI,CAkDxC;AAGD,eAAO,MAAM,WAAW,QAAO;IAAE,aAAa,EAAE,SAAS,OAAO,EAAE,CAAC;IAAC,iBAAiB,EAAE,SAAS,OAAO,EAAE,CAAA;CAoBxG,CAAC;AAGF,eAAO,MAAM,YAAY,GAAI,SAAS,SAAS,OAAO,EAAE,KAAG,WAAW,EAErE,CAAA;AAED,eAAO,MAAM,cAAc,GAAI,SAAS,SAAS,OAAO,EAAE,KAAG,cAE5D,CAAA;AAED,eAAO,MAAM,QAAQ,GAAI,SAAS,SAAS,OAAO,EAAE,KAAG,OAAO,EAE7D,CAAA;AAED,eAAO,MAAM,UAAU,GAAI,SAAS,SAAS,OAAO,EAAE,KAAG,QAAQ,EAEhE,CAAA;AAED,eAAO,MAAM,aAAa,GAAI,SAAS,SAAS,OAAO,EAAE,KAAG,WAAW,EAEtE,CAAA;AAED,eAAO,MAAM,QAAQ,GAAI,SAAS,SAAS,OAAO,EAAE,KAAG,YAAY,EAElE,CAAA;AAED,eAAO,MAAM,aAAa,GAAI,SAAS,SAAS,OAAO,EAAE,KAAG,YAAY,EAEvE,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAI,SAAS,SAAS,OAAO,EAAE,KAAG,kBAAkB,EAEnF,CAAA;AAED,eAAO,MAAM,qBAAqB,GAAI,SAAS,SAAS,OAAO,EAAE,KAAG,oBAAoB,EAEvF,CAAA;AAGD,eAAO,MAAM,oBAAoB,YAYhC,CAAA"}

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

@@ -0,0 +1,150 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateCurrentApiJson = exports.getPropertySignatures = exports.getMethodSignatures = exports.getInterfaces = exports.getTypes = exports.getProperties = exports.getClasses = exports.getEnums = exports.getConstructor = exports.getFunctions = exports.loadApiData = exports.currentApiJsonPath = exports.newApiJsonPath = exports.currentApiMdPath = exports.newApiMdPath = void 0;
+exports.generateApiReport = generateApiReport;
+const api_extractor_1 = require("@microsoft/api-extractor");
+const api_extractor_model_1 = require("@microsoft/api-extractor-model");
+const fs = __importStar(require("fs"));
+const node_child_process_1 = require("node:child_process");
+const path = __importStar(require("path"));
+exports.newApiMdPath = path.join(__dirname, 'temp', 'ts-adaas.md');
+exports.currentApiMdPath = path.join(__dirname, 'ts-adaas.md');
+exports.newApiJsonPath = path.join(__dirname, 'temp', 'ts-adaas.api.json');
+exports.currentApiJsonPath = path.join(__dirname, 'latest.json');
+// Generate API report before all tests run
+function generateApiReport() {
+    // Before running the api extractor, make sure that the code compiles using `tsc` command
+    const tscCommand = 'npm run build';
+    try {
+        (0, node_child_process_1.execSync)(tscCommand);
+    }
+    catch (error) {
+        // Jest has a nice feature: if any of the setup scripts throw an error, the test run will fail
+        // This Error is rethrown to get more information from the error.
+        throw new Error(`Failed to compile code using tsc command:\n${error.stdout.toString()}`);
+    }
+    const apiExtractorJsonPath = path.join(__dirname, 'api-extractor.json');
+    // Ensure the temp and report directories exist
+    const tempDir = path.join(__dirname, 'temp');
+    const reportDir = path.join(__dirname, 'report');
+    if (!fs.existsSync(tempDir)) {
+        fs.mkdirSync(tempDir, { recursive: true });
+        console.log(`Created temp directory: ${tempDir}`);
+    }
+    if (!fs.existsSync(reportDir)) {
+        fs.mkdirSync(reportDir, { recursive: true });
+        console.log(`Created report directory: ${reportDir}`);
+    }
+    const extractorConfig = api_extractor_1.ExtractorConfig.loadFileAndPrepare(apiExtractorJsonPath);
+    const extractorResult = api_extractor_1.Extractor.invoke(extractorConfig, {
+        localBuild: true,
+        showVerboseMessages: false,
+    });
+    if (extractorResult.succeeded) {
+        console.log(`API Extractor completed successfully`);
+        process.exitCode = 0;
+    }
+    else {
+        console.error(`API Extractor completed with ${extractorResult.errorCount} errors` +
+            ` and ${extractorResult.warningCount} warnings`);
+        process.exitCode = 1;
+    }
+}
+// Helper function to load API data
+const loadApiData = () => {
+    if (!fs.existsSync(exports.newApiJsonPath)) {
+        throw new Error('New API reports not found. Run the generate-api-report test first.');
+    }
+    if (!fs.existsSync(exports.currentApiJsonPath)) {
+        throw new Error('Latest API baseline not found. Run backwards compatibility tests first to generate latest.json.');
+    }
+    const newApiModel = new api_extractor_model_1.ApiModel().loadPackage(exports.newApiJsonPath);
+    const newApiMembers = newApiModel.entryPoints[0].members;
+    const currentApiModel = new api_extractor_model_1.ApiModel().loadPackage(exports.currentApiJsonPath);
+    const currentApiMembers = currentApiModel.entryPoints[0].members;
+    return { newApiMembers, currentApiMembers };
+};
+exports.loadApiData = loadApiData;
+// Helper functions for getting different kinds of items from the API members
+const getFunctions = (members) => {
+    return members.filter((m) => m instanceof api_extractor_model_1.ApiFunction && m.kind === 'Function');
+};
+exports.getFunctions = getFunctions;
+const getConstructor = (members) => {
+    return members.filter((m) => m instanceof api_extractor_model_1.ApiConstructor && m.kind === 'Constructor')[0];
+};
+exports.getConstructor = getConstructor;
+const getEnums = (members) => {
+    return members.filter((m) => m instanceof api_extractor_model_1.ApiEnum && m.kind === 'Enum');
+};
+exports.getEnums = getEnums;
+const getClasses = (members) => {
+    return members.filter((m) => m instanceof api_extractor_model_1.ApiClass && m.kind === 'Class');
+};
+exports.getClasses = getClasses;
+const getProperties = (members) => {
+    return members.filter((m) => m instanceof api_extractor_model_1.ApiProperty && m.kind === 'Property');
+};
+exports.getProperties = getProperties;
+const getTypes = (members) => {
+    return members.filter((m) => m instanceof api_extractor_model_1.ApiTypeAlias && m.kind === 'TypeAlias');
+};
+exports.getTypes = getTypes;
+const getInterfaces = (members) => {
+    return members.filter((m) => m instanceof api_extractor_model_1.ApiInterface && m.kind === 'Interface');
+};
+exports.getInterfaces = getInterfaces;
+const getMethodSignatures = (members) => {
+    return members.filter((m) => m instanceof api_extractor_model_1.ApiMethodSignature && m.kind === 'MethodSignature');
+};
+exports.getMethodSignatures = getMethodSignatures;
+const getPropertySignatures = (members) => {
+    return members.filter((m) => m instanceof api_extractor_model_1.ApiPropertySignature && m.kind === 'PropertySignature');
+};
+exports.getPropertySignatures = getPropertySignatures;
+const updateCurrentApiJson = () => {
+    if (fs.existsSync(exports.newApiMdPath) && fs.existsSync(exports.newApiJsonPath)) {
+        fs.copyFileSync(exports.newApiMdPath, exports.currentApiMdPath);
+        // Copy new API JSON into latest.json after all tests pass
+        const latestJsonPath = path.join(__dirname, 'latest.json');
+        fs.copyFileSync(exports.newApiJsonPath, latestJsonPath);
+        console.log(`Updated current API baseline files and created latest.json.`);
+    }
+    else {
+        console.warn('No new API reports found.');
+    }
+};
+exports.updateCurrentApiJson = updateCurrentApiJson;

package/dist/tests/backwards-compatibility/jest.setup.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=jest.setup.d.ts.map

package/dist/tests/backwards-compatibility/jest.setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jest.setup.d.ts","sourceRoot":"","sources":["../../../src/tests/backwards-compatibility/jest.setup.ts"],"names":[],"mappings":""}

package/dist/tests/backwards-compatibility/jest.setup.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("./helpers");
+// Run the API report generation
+(0, helpers_1.generateApiReport)();

package/dist/tests/mock-server.d.ts

@@ -18,3 +18,4 @@ export declare class MockServer {
     }[];
     clearRequests(): void;
 }
+//# sourceMappingURL=mock-server.d.ts.map

package/dist/tests/mock-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-server.d.ts","sourceRoot":"","sources":["../../src/tests/mock-server.ts"],"names":[],"mappings":"AAGA,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAA4B;IAC1C,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,WAAW,CAAgB;IACnC,OAAO,CAAC,QAAQ,CAA0D;gBAE9D,IAAI,CAAC,EAAE,MAAM;IAIzB,OAAO,CAAC,qBAAqB;IAe7B,OAAO,CAAC,aAAa;IA8Nf,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAiBtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAc3B,UAAU,IAAI,MAAM;IAIpB,OAAO,IAAI,MAAM;IAIjB,cAAc,IAAI,MAAM,EAAE;IAI1B,WAAW;gBA9RuB,MAAM;aAAO,MAAM;eAAS,GAAG;;IAkSjE,aAAa;CAGd"}

package/dist/tests/test-helpers.d.ts

@@ -7,3 +7,4 @@ export declare function createItems(count: number): Item[];
 export declare function normalizeItem(item: Item): NormalizedItem;
 export declare function createAttachment(id: number): NormalizedAttachment;
 export declare function createAttachments(count: number): NormalizedAttachment[];
+//# sourceMappingURL=test-helpers.d.ts.map

package/dist/tests/test-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-helpers.d.ts","sourceRoot":"","sources":["../../src/tests/test-helpers.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,IAAI,EACJ,oBAAoB,EACpB,cAAc,EACf,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEjE,wBAAgB,WAAW,CAAC,EAC1B,SAAS,EACT,iBAAsB,EACtB,QAAQ,EACR,KAAK,EACL,KAAK,EACL,gBAAqB,EACrB,gBAAqB,EACrB,qBAA0B,EAC1B,0BAA+B,GAChC,EAAE,oBAAoB,GAAG,YAAY,CA4ErC;AAED,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAO3C;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,EAAE,CAEjD;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,cAAc,CASxD;AAED,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,oBAAoB,CAQjE;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,oBAAoB,EAAE,CAEvE"}

package/dist/tests/test-helpers.interfaces.d.ts

@@ -11,3 +11,4 @@ export interface CreateEventInterface {
     eventContextOverrides?: Partial<EventContext>;
     executionMetadataOverrides?: Partial<AirdropEvent['execution_metadata']>;
 }
+//# sourceMappingURL=test-helpers.interfaces.d.ts.map

package/dist/tests/test-helpers.interfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-helpers.interfaces.d.ts","sourceRoot":"","sources":["../../src/tests/test-helpers.interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EACL,YAAY,EACZ,SAAS,EACT,gBAAgB,EAChB,YAAY,EACb,MAAM,qBAAqB,CAAC;AAE7B,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,SAAS,CAAC;IACrB,iBAAiB,CAAC,EAAE,gBAAgB,EAAE,CAAC;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gBAAgB,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC;IACpD,gBAAgB,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC;IACpD,qBAAqB,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC;IAC9C,0BAA0B,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,oBAAoB,CAAC,CAAC,CAAC;CAC1E"}

package/dist/tests/timeout-handling/extraction.d.ts

@@ -1,3 +1,4 @@
 import { AirdropEvent } from '../../index';
 declare const run: (events: AirdropEvent[], workerPath: string) => Promise<void>;
 export default run;
+//# sourceMappingURL=extraction.d.ts.map

package/dist/tests/timeout-handling/extraction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extraction.d.ts","sourceRoot":"","sources":["../../../src/tests/timeout-handling/extraction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAS,MAAM,aAAa,CAAC;AAMlD,QAAA,MAAM,GAAG,GAAU,QAAQ,YAAY,EAAE,EAAE,YAAY,MAAM,kBAc5D,CAAC;AAEF,eAAe,GAAG,CAAC"}

package/dist/tests/timeout-handling/timeout-1.d.ts

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=timeout-1.d.ts.map

package/dist/tests/timeout-handling/timeout-1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout-1.d.ts","sourceRoot":"","sources":["../../../src/tests/timeout-handling/timeout-1.ts"],"names":[],"mappings":""}

package/dist/tests/timeout-handling/timeout-1.test.d.ts

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=timeout-1.test.d.ts.map