@devrev/ts-adaas 1.13.1-beta.2 → 1.13.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devrev/ts-adaas",
-  "version": "1.13.1-beta.2",
+  "version": "1.13.1",
   "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)();
-    });
-});

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

@@ -1,21 +0,0 @@
-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

@@ -1 +0,0 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/tests/backwards-compatibility/helpers.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,QAAQ,EACR,cAAc,EACd,OAAO,EACP,WAAW,EACX,YAAY,EACZ,OAAO,EACP,kBAAkB,EAElB,WAAW,EACX,oBAAoB,EACpB,YAAY,EACb,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;AAKtE,wBAAgB,iBAAiB,IAAI,IAAI,CAkDxC;AAGD,eAAO,MAAM,WAAW,QAAO;IAC7B,aAAa,EAAE,SAAS,OAAO,EAAE,CAAC;IAClC,iBAAiB,EAAE,SAAS,OAAO,EAAE,CAAC;CAqBvC,CAAC;AAGF,eAAO,MAAM,YAAY,GAAI,SAAS,SAAS,OAAO,EAAE,KAAG,WAAW,EAIrE,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,SAAS,SAAS,OAAO,EAAE,KAAG,cAM5D,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAI,SAAS,SAAS,OAAO,EAAE,KAAG,OAAO,EAI7D,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,SAAS,SAAS,OAAO,EAAE,KAAG,QAAQ,EAIhE,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,SAAS,SAAS,OAAO,EAAE,KAAG,WAAW,EAItE,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAI,SAAS,SAAS,OAAO,EAAE,KAAG,YAAY,EAIlE,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,SAAS,SAAS,OAAO,EAAE,KAAG,YAAY,EAIvE,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAC9B,SAAS,SAAS,OAAO,EAAE,KAC1B,kBAAkB,EAKpB,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,SAAS,SAAS,OAAO,EAAE,KAC1B,oBAAoB,EAKtB,CAAC;AAEF,eAAO,MAAM,oBAAoB,YAYhC,CAAC"}

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

@@ -1,151 +0,0 @@
-"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');
-/* eslint-disable @typescript-eslint/no-explicit-any */
-// 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

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

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

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