@connectid-tools/idp-selector-react 6.4.1

package/TabHook.js

@@ -0,0 +1,37 @@
+import { useEffect } from 'react';
+export function useOverrideTab(element, nextElement) {
+    useEffect(() => {
+        if (!(element === null || element === void 0 ? void 0 : element.current) || !(nextElement === null || nextElement === void 0 ? void 0 : nextElement.current))
+            return;
+        const handleKeyDown = (event) => {
+            if (event.code === 'Tab' && element.current === document.activeElement) {
+                nextElement.current.focus();
+                event.preventDefault();
+            }
+        };
+        element.current.addEventListener('keydown', handleKeyDown);
+        return () => {
+            if (!(element === null || element === void 0 ? void 0 : element.current))
+                return;
+            element.current.removeEventListener('keydown', handleKeyDown);
+        };
+    }, [element, nextElement]);
+}
+export function useOverrideShiftTab(element, nextElement) {
+    useEffect(() => {
+        if (!(element === null || element === void 0 ? void 0 : element.current) || !(nextElement === null || nextElement === void 0 ? void 0 : nextElement.current))
+            return;
+        const handleKeyDown = (event) => {
+            if (event.shiftKey && event.code === 'Tab' && element.current === document.activeElement) {
+                nextElement.current.focus();
+                event.preventDefault();
+            }
+        };
+        element.current.addEventListener('keydown', handleKeyDown);
+        return () => {
+            if (!(element === null || element === void 0 ? void 0 : element.current))
+                return;
+            element.current.removeEventListener('keydown', handleKeyDown);
+        };
+    }, [element, nextElement]);
+}

package/ThemeContext.d.ts

@@ -0,0 +1,2 @@
+import { CidButtonTheme } from './types';
+export declare const ThemeContext: import("react").Context<CidButtonTheme>;

package/ThemeContext.js

@@ -0,0 +1,2 @@
+import { createContext } from 'react';
+export const ThemeContext = createContext('dark');

package/analytics.d.ts

@@ -0,0 +1 @@
+export declare const useAnalytics: () => void;

package/analytics.js

@@ -0,0 +1,88 @@
+const PROD_WRITE_KEY = 'LrD9CEGUEy1O3s73nGbaGcyTqELujozJ';
+const DEV_WRITE_KEY = 'PWlESErGso9uTimwmGB7SsnxCpKF8pRl';
+const WRITE_KEY = 'production' === 'production' ? PROD_WRITE_KEY : DEV_WRITE_KEY;
+export const useAnalytics = () => {
+    // copied from https://segment.com/docs/connections/sources/catalog/libraries/website/javascript/quickstart/
+    // @ts-ignore
+    // Create a queue, but don't obliterate an existing one!
+    var analytics = (window.analytics = window.analytics || []);
+    // If the real analytics.js is already on the page return.
+    if (analytics.initialize)
+        return;
+    // If the snippet was invoked already show an error.
+    if (analytics.invoked) {
+        if (window.console && console.error) {
+            console.error('Segment snippet included twice.');
+        }
+        return;
+    }
+    // Invoked flag, to make sure the snippet
+    // is never invoked twice.
+    analytics.invoked = true;
+    // A list of the methods in Analytics.js to stub.
+    analytics.methods = [
+        'trackSubmit',
+        'trackClick',
+        'trackLink',
+        'trackForm',
+        'pageview',
+        'identify',
+        'reset',
+        'group',
+        'track',
+        'ready',
+        'alias',
+        'debug',
+        'page',
+        'once',
+        'off',
+        'on',
+        'addSourceMiddleware',
+        'addIntegrationMiddleware',
+        'setAnonymousId',
+        'addDestinationMiddleware',
+    ];
+    // Define a factory to create stubs. These are placeholders
+    // for methods in Analytics.js so that you never have to wait
+    // for it to load to actually record data. The `method` is
+    // stored as the first argument, so we can replay the data.
+    // @ts-ignore
+    analytics.factory = function (method) {
+        return function () {
+            var args = Array.prototype.slice.call(arguments);
+            args.unshift(method);
+            analytics.push(args);
+            return analytics;
+        };
+    };
+    // For each of our methods, generate a queueing stub.
+    for (var i = 0; i < analytics.methods.length; i++) {
+        var key = analytics.methods[i];
+        analytics[key] = analytics.factory(key);
+    }
+    // Define a method to load Analytics.js from our CDN,
+    // and that will be sure to only ever load it once.
+    // @ts-ignore
+    analytics.load = function (key, options) {
+        // Create an async script element based on your key.
+        var script = document.createElement('script');
+        script.type = 'text/javascript';
+        script.async = true;
+        script.src = 'https://cdn.segment.com/analytics.js/v1/' + key + '/analytics.min.js';
+        // Insert our script next to the first script element.
+        var first = document.getElementsByTagName('script')[0];
+        // @ts-ignore
+        first.parentNode.insertBefore(script, first);
+        analytics._loadOptions = options;
+    };
+    analytics._writeKey = WRITE_KEY;
+    // Add a version to keep track of what's in the wild.
+    analytics.SNIPPET_VERSION = '4.15.2';
+    // Load Analytics.js with your key, which will automatically
+    // load the tools you've enabled for your account. Boosh!
+    analytics.load(WRITE_KEY);
+    // Make the first page call to load the integrations. If
+    // you'd like to manually name or tag the page, edit or
+    // move this call however you'd like.
+    analytics.page();
+};

package/certification.d.ts

@@ -0,0 +1,8 @@
+import { AuthorisationServer, CertificationStatus, Claim, Device, RequiredCertification } from './types';
+export declare const filterAuthorisationServers: (authorisationServers: AuthorisationServer[], showAllParticipants: boolean, certificationStatus: CertificationStatus, claims: Claim[], requiredCertifications?: RequiredCertification[]) => AuthorisationServer[];
+export declare const getManualAuthorisationServer: (authorisationServers: AuthorisationServer[], showAllParticipants: boolean) => AuthorisationServer | undefined;
+export declare const removeExpiredOrNotStartedCertifications: (authorisationServers: AuthorisationServer[]) => AuthorisationServer[];
+export declare const filterAuthorisationServerByClaims: (authorisationServers: AuthorisationServer[], claims: Claim[]) => AuthorisationServer[];
+export declare const mapAuthorisationServerToDeviceType: (authorisationServers: AuthorisationServer[], deviceType: Device) => Map<AuthorisationServer, Device>;
+export declare const filterAuthorisationServerByCertification: (authorisationServers: AuthorisationServer[], status: CertificationStatus, requiredCertifications?: RequiredCertification[]) => AuthorisationServer[];
+export declare const hasStarted: (startDateStr: string) => boolean;

package/certification.js

@@ -0,0 +1,103 @@
+const requiredCertificationsMap = {
+    'TDIF.IDP': { type: 'TDIF Accreditation', variant: 'Identity Provider' },
+    'Redirect.FAPI2': { type: 'Redirect', variant: 'FAPI2 Adv. OP w/Private Key, PAR' },
+};
+export const filterAuthorisationServers = (authorisationServers, showAllParticipants, certificationStatus, claims, requiredCertifications) => {
+    if (showAllParticipants)
+        return authorisationServers;
+    const authorisationServersWithValidCertifications = removeExpiredOrNotStartedCertifications(authorisationServers);
+    const filteredAuthorisationServersByClaims = filterAuthorisationServerByClaims(authorisationServersWithValidCertifications, claims);
+    const filteredAuthorisationServers = filterAuthorisationServerByCertification(filteredAuthorisationServersByClaims, certificationStatus, requiredCertifications);
+    return filteredAuthorisationServers;
+};
+export const getManualAuthorisationServer = (authorisationServers, showAllParticipants) => {
+    const filtered = showAllParticipants
+        ? authorisationServers
+        : removeExpiredOrNotStartedCertifications(authorisationServers);
+    return filtered.find(({ AuthorisationServerCertifications }) => AuthorisationServerCertifications === null || AuthorisationServerCertifications === void 0 ? void 0 : AuthorisationServerCertifications.find(({ ProfileVariant }) => ProfileVariant === 'Fallback Identity Service Provider'));
+};
+export const removeExpiredOrNotStartedCertifications = (authorisationServers) => {
+    const certifiedAuthorisationServers = [...authorisationServers];
+    certifiedAuthorisationServers.forEach((authorisationServer) => {
+        authorisationServer.AuthorisationServerCertifications =
+            authorisationServer.AuthorisationServerCertifications.filter(({ Status, CertificationStartDate, CertificationExpirationDate }) => Status === 'Certified' && !isExpired(CertificationExpirationDate) && hasStarted(CertificationStartDate));
+    });
+    return certifiedAuthorisationServers;
+};
+export const filterAuthorisationServerByClaims = (authorisationServers, claims) => {
+    const nameClaims = ['given_name', 'middle_name', 'family_name'];
+    const hasNameClaims = claims.find((claim) => nameClaims.includes(claim));
+    // All name claims (given_name, middle_name, family_name) are mapped to `name` in the authorisation server
+    // So if an authorisation server has any name claim, remove all name claims and leave only `name`
+    const profileVariants = hasNameClaims
+        ? ['name', ...claims.filter((claim) => !nameClaims.includes(claim))]
+        : claims;
+    return authorisationServers.filter((authorisationServer) => {
+        const authorisationServerProfileVariants = authorisationServer.AuthorisationServerCertifications.filter(({ ProfileType }) => ProfileType === 'ConnectID Claims').map((cert) => cert.ProfileVariant);
+        return profileVariants.every((profileVariant) => authorisationServerProfileVariants.includes(profileVariant));
+    });
+};
+export const mapAuthorisationServerToDeviceType = (authorisationServers, deviceType) => {
+    const authServerMap = new Map();
+    if (deviceType === 'mobile') {
+        authorisationServers.forEach((authorisationServer) => {
+            authServerMap.set(authorisationServer, 'mobile');
+        });
+        return authServerMap;
+    }
+    authorisationServers.map((authorisationServer) => {
+        const channelCertifications = authorisationServer.AuthorisationServerCertifications.filter((cert) => cert.ProfileType === 'Channel');
+        authServerMap.set(authorisationServer, channelCertifications.length === 1 && channelCertifications[0].ProfileVariant === 'app' ? 'desktop' : 'mobile');
+    });
+    return authServerMap;
+};
+export const filterAuthorisationServerByCertification = (authorisationServers, status, requiredCertifications) => {
+    const filteredByStatus = filterByStatus(authorisationServers, status);
+    const filteredByStatusAndRequiredCertifications = filterByRequiredCertifications(filteredByStatus, requiredCertifications);
+    return filteredByStatusAndRequiredCertifications;
+};
+const filterByStatus = (authorisationServers, status) => {
+    if (status === 'All')
+        return authorisationServers;
+    if (status === 'Active') {
+        return authorisationServers.filter(({ AuthorisationServerCertifications }) => AuthorisationServerCertifications.find(({ ProfileVariant, ProfileType }) => ProfileType === 'Redirect' && ProfileVariant === 'FAPI2 Adv. OP w/Private Key, PAR'));
+    }
+    throw Error(`Status ${status} not supported`);
+};
+// The idea is to loop the requiredCertications and check if all
+// of them were found in the auth server certifications (AND)
+// if so return the auth server
+const filterByRequiredCertifications = (authorisationServers, requiredCertifications) => {
+    if (!requiredCertifications)
+        return authorisationServers;
+    return authorisationServers.filter(({ AuthorisationServerCertifications }) => {
+        let requiredCertificationsFound = 0;
+        requiredCertifications.forEach((required) => {
+            const found = AuthorisationServerCertifications.find(({ ProfileType, ProfileVariant }) => ProfileType === requiredCertificationsMap[required].type &&
+                ProfileVariant === requiredCertificationsMap[required].variant);
+            if (found)
+                requiredCertificationsFound++;
+        });
+        return requiredCertificationsFound === requiredCertifications.length;
+    });
+};
+const isExpired = (expiryDateStr) => {
+    const expiryDate = parseCertificationDate(expiryDateStr);
+    expiryDate.setHours(23);
+    expiryDate.setMinutes(59);
+    expiryDate.setSeconds(59);
+    const today = new Date();
+    return expiryDate.getTime() < today.getTime();
+};
+export const hasStarted = (startDateStr) => {
+    const startDate = parseCertificationDate(startDateStr);
+    startDate.setHours(0);
+    startDate.setMinutes(0);
+    startDate.setSeconds(0);
+    const today = new Date();
+    return startDate.getTime() <= today.getTime();
+};
+const parseCertificationDate = (dateStr) => {
+    const dateArr = dateStr.split('/');
+    return new Date(`${dateArr[2]}-${dateArr[1]}-${dateArr[0]}`);
+};

package/certification.test.d.ts

@@ -0,0 +1 @@
+export {};

package/certification.test.js

@@ -0,0 +1,387 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { filterAuthorisationServerByClaims, filterAuthorisationServers, getManualAuthorisationServer, mapAuthorisationServerToDeviceType, removeExpiredOrNotStartedCertifications, } from './certification';
+describe('filterAuthorisationServers', () => {
+    it('should return all authorisation servers if showAllParticipants is true regardless of certification status, required certifications and claims', () => {
+        const authorisationServers = [
+            // no certifications at all
+            {
+                AuthorisationServerId: '71fe3927-f596-4192-ab9a-f6644cdb9b21',
+                CustomerFriendlyLogoUri: 'https://static.sandbox.connectid.com.au/BankA.svg',
+                CustomerFriendlyName: 'Mock Bank B',
+                AuthorisationServerCertifications: [],
+            },
+        ];
+        assert.deepStrictEqual(filterAuthorisationServers(authorisationServers, true, 'Active', ['email'], ['TDIF.IDP']), authorisationServers);
+    });
+    it('should filter authorisation servers if showAllParticipants is false', () => {
+        Object.defineProperty(global, 'navigator', { value: { userAgent: 'xxxdesktop' }, configurable: true });
+        const authorisationServers = [
+            // no certifications at all
+            {
+                AuthorisationServerId: '71fe3927-f596-4192-ab9a-f6644cdb9b21',
+                CustomerFriendlyLogoUri: 'https://static.sandbox.connectid.com.au/BankA.svg',
+                CustomerFriendlyName: 'Mock Bank B',
+                AuthorisationServerCertifications: [],
+            },
+            // expired
+            {
+                AuthorisationServerId: '71fe3927-f596-4192-ab9a-f6644cdb9b22',
+                CustomerFriendlyLogoUri: 'https://static.sandbox.connectid.com.au/BankA.svg',
+                CustomerFriendlyName: 'Mock Bank C',
+                AuthorisationServerCertifications: [
+                    {
+                        CertificationStartDate: '10/04/1900',
+                        CertificationExpirationDate: '10/04/2000',
+                        Status: 'Certified',
+                        ProfileVariant: 'FAPI2 Adv. OP w/Private Key, PAR',
+                        ProfileType: 'Redirect',
+                    },
+                ],
+            },
+            // fapi2, web and email claim
+            {
+                AuthorisationServerId: '71fe3927-f596-4192-ab9a-f6644cdb9b23',
+                CustomerFriendlyLogoUri: 'https://static.sandbox.connectid.com.au/BankA.svg',
+                CustomerFriendlyName: 'Mock Bank D',
+                AuthorisationServerCertifications: [
+                    {
+                        CertificationStartDate: '10/04/1900',
+                        CertificationExpirationDate: '10/04/2099',
+                        Status: 'Certified',
+                        ProfileVariant: 'FAPI2 Adv. OP w/Private Key, PAR',
+                        ProfileType: 'Redirect',
+                    },
+                    {
+                        CertificationStartDate: '10/04/1900',
+                        CertificationExpirationDate: '10/04/2099',
+                        Status: 'Certified',
+                        ProfileVariant: 'web',
+                        ProfileType: 'Channel',
+                    },
+                    {
+                        CertificationStartDate: '10/04/1900',
+                        CertificationExpirationDate: '10/04/2099',
+                        Status: 'Certified',
+                        ProfileVariant: 'email',
+                        ProfileType: 'ConnectID Claims',
+                    },
+                ],
+            },
+            // fapi2, web and birthdate claim
+            {
+                AuthorisationServerId: '71fe3927-f596-4192-ab9a-f6644cdb9b24',
+                CustomerFriendlyLogoUri: 'https://static.sandbox.connectid.com.au/BankA.svg',
+                CustomerFriendlyName: 'Mock Bank E',
+                AuthorisationServerCertifications: [
+                    {
+                        CertificationStartDate: '10/04/1900',
+                        CertificationExpirationDate: '10/04/2099',
+                        Status: 'Certified',
+                        ProfileVariant: 'FAPI2 Adv. OP w/Private Key, PAR',
+                        ProfileType: 'Redirect',
+                    },
+                    {
+                        CertificationStartDate: '10/04/1900',
+                        CertificationExpirationDate: '10/04/2099',
+                        Status: 'Certified',
+                        ProfileVariant: 'web',
+                        ProfileType: 'Channel',
+                    },
+                    {
+                        CertificationStartDate: '10/04/1900',
+                        CertificationExpirationDate: '10/04/2099',
+                        Status: 'Certified',
+                        ProfileVariant: 'birthdate',
+                        ProfileType: 'ConnectID Claims',
+                    },
+                ],
+            },
+        ];
+        assert.deepStrictEqual(filterAuthorisationServers(authorisationServers, false, 'Active', ['email'], ['Redirect.FAPI2']), [authorisationServers[2]]);
+    });
+});
+describe('getManualAuthorisationServer', () => {
+    const authorisationServers = [
+        {
+            AuthorisationServerId: '71fe3927-f596-4192-ab9a-f6644cdb9b2b',
+            CustomerFriendlyLogoUri: 'https://static.sandbox.connectid.com.au/BankA.svg',
+            CustomerFriendlyName: 'Mock Bank A',
+            // expired
+            AuthorisationServerCertifications: [
+                {
+                    CertificationExpirationDate: '10/04/2000',
+                    Status: 'Certified',
+                    ProfileVariant: 'Fallback Identity Service Provider',
+                    // @ts-ignore
+                    ProfileType: 'ConnectID',
+                },
+            ],
+        },
+    ];
+    it('should return expired manual servers if showAllParticipants is true', () => {
+        assert.deepStrictEqual(getManualAuthorisationServer(authorisationServers, true), authorisationServers[0]);
+    });
+    it('should not return expired manual servers if showAllParticipants is false', () => {
+        assert.deepStrictEqual(getManualAuthorisationServer(authorisationServers, false), undefined);
+    });
+});
+describe('filterAuthorisationServerByClaims', () => {
+    const authorisationServers = [
+        {
+            AuthorisationServerId: '1',
+            CustomerFriendlyLogoUri: 'https://static.sandbox.connectid.com.au/BankA.svg',
+            CustomerFriendlyName: 'Mock Bank A',
+            AuthorisationServerCertifications: [
+                {
+                    CertificationStartDate: '10/04/1900',
+                    CertificationExpirationDate: '10/04/2099',
+                    Status: 'Certified',
+                    ProfileVariant: 'email',
+                    ProfileType: 'ConnectID Claims',
+                },
+            ],
+        },
+        {
+            AuthorisationServerId: '2',
+            CustomerFriendlyLogoUri: 'https://static.sandbox.connectid.com.au/BankA.svg',
+            CustomerFriendlyName: 'Mock Bank B',
+            // no claims
+            AuthorisationServerCertifications: [],
+        },
+        {
+            AuthorisationServerId: '3',
+            CustomerFriendlyLogoUri: 'https://static.sandbox.connectid.com.au/BankA.svg',
+            CustomerFriendlyName: 'Mock Bank C',
+            AuthorisationServerCertifications: [
+                // multiple claims
+                {
+                    CertificationStartDate: '10/04/1900',
+                    CertificationExpirationDate: '10/04/2099',
+                    Status: 'Certified',
+                    ProfileVariant: 'email',
+                    ProfileType: 'ConnectID Claims',
+                },
+                {
+                    CertificationStartDate: '10/04/1900',
+                    CertificationExpirationDate: '10/04/2099',
+                    Status: 'Certified',
+                    ProfileVariant: 'birthdate',
+                    ProfileType: 'ConnectID Claims',
+                },
+                {
+                    CertificationStartDate: '10/04/1900',
+                    CertificationExpirationDate: '10/04/2099',
+                    Status: 'Certified',
+                    ProfileVariant: 'name',
+                    ProfileType: 'ConnectID Claims',
+                },
+            ],
+        },
+    ];
+    it('should return no authorisation servers when claim is address', () => {
+        assert.deepStrictEqual(filterAuthorisationServerByClaims(authorisationServers, ['address']), []);
+    });
+    it('should return bank C and A when claim email', () => {
+        assert.deepStrictEqual(filterAuthorisationServerByClaims(authorisationServers, ['email']), [
+            authorisationServers[0],
+            authorisationServers[2],
+        ]);
+    });
+    it('should return bank C when claim is email and birthdate', () => {
+        assert.deepStrictEqual(filterAuthorisationServerByClaims(authorisationServers, ['email', 'birthdate']), [
+            authorisationServers[2],
+        ]);
+    });
+    it('should return bank C when claim is given_name, middle_name and birthdate', () => {
+        assert.deepStrictEqual(filterAuthorisationServerByClaims(authorisationServers, ['given_name', 'middle_name', 'birthdate']), [authorisationServers[2]]);
+    });
+    it('should return bank C when claim is name', () => {
+        assert.deepStrictEqual(filterAuthorisationServerByClaims(authorisationServers, ['given_name']), [
+            authorisationServers[2],
+        ]);
+    });
+});
+describe('removeExpiredCertifications', () => {
+    it('should remove expired or not started certifications', () => {
+        const authorisationServers = [
+            {
+                AuthorisationServerId: '1',
+                CustomerFriendlyLogoUri: 'https://static.sandbox.connectid.com.au/BankA.svg',
+                CustomerFriendlyName: 'Mock Bank A',
+                AuthorisationServerCertifications: [
+                    // certified and not expired
+                    {
+                        CertificationStartDate: '10/04/1900',
+                        CertificationExpirationDate: '10/04/2099',
+                        Status: 'Certified',
+                        ProfileVariant: 'web',
+                        ProfileType: 'Channel',
+                    },
+                    // not certified and not expired
+                    {
+                        CertificationStartDate: '10/04/1900',
+                        CertificationExpirationDate: '10/04/2099',
+                        Status: 'Deprecated',
+                        ProfileVariant: 'FAPI2 Adv. OP w/Private Key, PAR',
+                        ProfileType: 'Redirect',
+                    },
+                ],
+            },
+            {
+                AuthorisationServerId: '2',
+                CustomerFriendlyLogoUri: 'https://static.sandbox.connectid.com.au/BankA.svg',
+                CustomerFriendlyName: 'Mock Bank B',
+                // no certifications
+                AuthorisationServerCertifications: [],
+            },
+            {
+                AuthorisationServerId: '3',
+                CustomerFriendlyLogoUri: 'https://static.sandbox.connectid.com.au/BankA.svg',
+                CustomerFriendlyName: 'Mock Bank C',
+                AuthorisationServerCertifications: [
+                    // certified but expired
+                    {
+                        CertificationStartDate: '10/04/1900',
+                        CertificationExpirationDate: '10/04/2000',
+                        Status: 'Certified',
+                        ProfileVariant: 'web',
+                        ProfileType: 'Channel',
+                    },
+                ],
+            },
+            {
+                AuthorisationServerId: '4',
+                CustomerFriendlyLogoUri: 'https://static.sandbox.connectid.com.au/BankA.svg',
+                CustomerFriendlyName: 'Mock Bank D',
+                AuthorisationServerCertifications: [
+                    // certified and not expired but not started
+                    {
+                        CertificationStartDate: '10/04/2098',
+                        CertificationExpirationDate: '10/04/2099',
+                        Status: 'Certified',
+                        ProfileVariant: 'web',
+                        ProfileType: 'Channel',
+                    },
+                ],
+            },
+        ];
+        const expected = [
+            {
+                AuthorisationServerId: '1',
+                CustomerFriendlyLogoUri: 'https://static.sandbox.connectid.com.au/BankA.svg',
+                CustomerFriendlyName: 'Mock Bank A',
+                AuthorisationServerCertifications: [
+                    // certified and not expired
+                    {
+                        CertificationStartDate: '10/04/1900',
+                        CertificationExpirationDate: '10/04/2099',
+                        Status: 'Certified',
+                        ProfileVariant: 'web',
+                        ProfileType: 'Channel',
+                    },
+                ],
+            },
+            {
+                AuthorisationServerId: '2',
+                CustomerFriendlyLogoUri: 'https://static.sandbox.connectid.com.au/BankA.svg',
+                CustomerFriendlyName: 'Mock Bank B',
+                // no certifications
+                AuthorisationServerCertifications: [],
+            },
+            {
+                AuthorisationServerId: '3',
+                CustomerFriendlyLogoUri: 'https://static.sandbox.connectid.com.au/BankA.svg',
+                CustomerFriendlyName: 'Mock Bank C',
+                AuthorisationServerCertifications: [],
+            },
+            {
+                AuthorisationServerId: '4',
+                CustomerFriendlyLogoUri: 'https://static.sandbox.connectid.com.au/BankA.svg',
+                CustomerFriendlyName: 'Mock Bank D',
+                AuthorisationServerCertifications: [],
+            },
+        ];
+        assert.deepStrictEqual(removeExpiredOrNotStartedCertifications(authorisationServers), expected);
+    });
+});
+describe('filterAuthorisationServerByDevice', () => {
+    const authorisationServers = [
+        {
+            AuthorisationServerId: '71fe3927-f596-4192-ab9a-f6644cdb9b2b',
+            CustomerFriendlyLogoUri: 'https://static.sandbox.connectid.com.au/BankA.svg',
+            CustomerFriendlyName: 'Mock Bank A',
+            AuthorisationServerCertifications: [
+                {
+                    CertificationStartDate: '10/04/1900',
+                    CertificationExpirationDate: '10/04/2024',
+                    Status: 'Certified',
+                    ProfileVariant: 'web',
+                    ProfileType: 'Channel',
+                },
+            ],
+        },
+        {
+            AuthorisationServerId: '71fe3927-f596-4192-ab9a-f6644cdb9b2x',
+            CustomerFriendlyLogoUri: 'https://static.sandbox.connectid.com.au/BankA.svg',
+            CustomerFriendlyName: 'Mock Bank B',
+            AuthorisationServerCertifications: [
+                {
+                    CertificationStartDate: '10/04/1900',
+                    CertificationExpirationDate: '10/04/2024',
+                    Status: 'Certified',
+                    ProfileVariant: 'web',
+                    ProfileType: 'Channel',
+                },
+            ],
+        },
+        {
+            AuthorisationServerId: 'fa8573a1-953a-4085-b5f7-070a42a4d5a9',
+            CustomerFriendlyLogoUri: 'https://static.sandbox.connectid.com.au/BankC.svg',
+            CustomerFriendlyName: 'Mock Bank C',
+            AuthorisationServerCertifications: [
+                {
+                    CertificationStartDate: '10/04/1900',
+                    CertificationExpirationDate: '10/04/2024',
+                    Status: 'Certified',
+                    ProfileVariant: 'app',
+                    ProfileType: 'Channel',
+                },
+            ],
+        },
+        {
+            AuthorisationServerId: 'fa8573a1-953a-4085-b5f7-070a42a4d5a1',
+            CustomerFriendlyLogoUri: 'https://static.sandbox.connectid.com.au/BankC.svg',
+            CustomerFriendlyName: 'Mock Bank D',
+            AuthorisationServerCertifications: [],
+        },
+    ];
+    it('should return all auth servers when device is mobile', () => {
+        const authServers = mapAuthorisationServerToDeviceType(authorisationServers, 'mobile');
+        const values = Array.from(authServers.values());
+        assert.deepStrictEqual(values.every((value) => value === 'mobile'), true);
+    });
+    it('should not return auth servers with only app cert when device is desktop', () => {
+        const authServers = mapAuthorisationServerToDeviceType(authorisationServers, 'desktop');
+        const filteredAuthServers = Array.from(authServers)
+            .filter(([_, device]) => device === 'mobile')
+            .map(([key, _]) => key);
+        assert.deepStrictEqual(filteredAuthServers, [
+            authorisationServers[0],
+            authorisationServers[1],
+            authorisationServers[3],
+        ]);
+    });
+    it('should not return auth servers with only app cert when device is tablet', () => {
+        const authServers = mapAuthorisationServerToDeviceType(authorisationServers, 'tablet');
+        console.log(authServers);
+        const filteredAuthServers = Array.from(authServers)
+            .filter(([_, device]) => device === 'mobile')
+            .map(([key, _]) => key);
+        assert.deepStrictEqual(filteredAuthServers, [
+            authorisationServers[0],
+            authorisationServers[1],
+            authorisationServers[3],
+        ]);
+    });
+});

package/global.css

@@ -0,0 +1,11 @@
+@import url('https://fonts.googleapis.com/css2?family=DM+Sans:opsz,wght@9..40,400;9..40,500;9..40,700&display=swap');
+
+:root {
+  --font: 'DM Sans', sans-serif;
+  --charcoal: #262626;
+  --charcoal10: #e9e9e9;
+  --charcoal50: #939393;
+  --charcoal75: #5C5C5C;
+  --grey: #464646;
+  --mint: #BEEDD2;
+}

package/index.d.ts

@@ -0,0 +1 @@
+export { CidButton } from './CidButton';

package/index.js

@@ -0,0 +1 @@
+export { CidButton } from './CidButton';