@google-psat/report 0.9.0-2 → 0.10.0

package/dist/dashboard/hooks/useCookieListing/index.js

@@ -0,0 +1,412 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * External dependencies
+ */
+import { useMemo } from 'react';
+import { I18n } from '@google-psat/i18n';
+import { BLOCK_STATUS } from '@google-psat/common';
+import { useSidebar, calculateBlockedReasonsFilterValues, calculateDynamicFilterValues, calculateExemptionReason, evaluateSelectAllOption, evaluateStaticFilterValues, } from '@google-psat/design-system';
+/**
+ * Internal dependencies
+ */
+import NamePrefixIconSelector from '../../components/utils/NamePrefixIconSelector';
+const useCookieListing = (tabCookies, selectedFrameUrl, persistenceKey = 'cookiesListing', selectedSite) => {
+    const { activePanelQuery, clearActivePanelQuery } = useSidebar(({ state }) => ({
+        activePanelQuery: state.activePanel.query,
+        clearActivePanelQuery: state.activePanel.clearQuery,
+    }));
+    //@ts-ignore -- PSAT_EXTENSTION is added only when the report is downloaded from the extension. Since optional chaining is done it will return false if it doesnt exist.
+    const isExtension = Boolean(globalThis?.PSAT_EXTENSION);
+    const parsedQuery = useMemo(() => JSON.parse(activePanelQuery || '{}'), [activePanelQuery]);
+    const tablePersistentSettingsKey = useMemo(() => {
+        if (selectedSite) {
+            return persistenceKey + '#' + selectedSite + selectedFrameUrl;
+        }
+        return persistenceKey + '#' + selectedFrameUrl;
+    }, [persistenceKey, selectedFrameUrl, selectedSite]);
+    const tableColumns = useMemo(() => {
+        const baseColumns = [
+            {
+                header: I18n.getMessage('name'),
+                accessorKey: 'parsedCookie.name',
+                cell: (info) => info,
+                enableHiding: false,
+                widthWeightagePercentage: 13,
+                enableBodyCellPrefixIcon: true,
+                bodyCellPrefixIcon: {
+                    Element: NamePrefixIconSelector,
+                },
+                showBodyCellPrefixIcon: (row) => {
+                    const isBlocked = Boolean(row.originalData?.blockingStatus
+                        ?.inboundBlock !== BLOCK_STATUS.NOT_BLOCKED ||
+                        row.originalData?.blockingStatus
+                            ?.outboundBlock !== BLOCK_STATUS.NOT_BLOCKED);
+                    const isDomainInAllowList = Boolean(row.originalData?.isDomainInAllowList);
+                    return isBlocked || isDomainInAllowList;
+                },
+            },
+            {
+                header: I18n.getMessage('scope'),
+                accessorKey: 'isFirstParty',
+                cell: (info) => !info ? I18n.getMessage('thirdParty') : I18n.getMessage('firstParty'),
+                widthWeightagePercentage: 8,
+            },
+            {
+                header: I18n.getMessage('domain'),
+                accessorKey: 'parsedCookie.domain',
+                cell: (info) => info,
+                widthWeightagePercentage: 9,
+            },
+            {
+                header: I18n.getMessage('partitionKey'),
+                accessorKey: 'parsedCookie.partitionKey',
+                cell: (info) => info,
+                widthWeightagePercentage: 9,
+            },
+            {
+                header: I18n.getMessage('sameSite'),
+                accessorKey: 'parsedCookie.sameSite',
+                cell: (info) => I18n.getMessage((info?.toString() || '').toLowerCase()),
+                widthWeightagePercentage: 8,
+            },
+            {
+                header: I18n.getMessage('category'),
+                accessorKey: 'analytics.category',
+                cell: (info) => I18n.getMessage(info.toLowerCase() || 'uncategorized'),
+                widthWeightagePercentage: 10,
+            },
+            {
+                header: I18n.getMessage('platform'),
+                accessorKey: 'analytics.platform',
+                cell: (info) => (info ? info : I18n.getMessage('unknown')),
+                widthWeightagePercentage: 10,
+            },
+            {
+                header: I18n.getMessage('httpOnly'),
+                accessorKey: 'parsedCookie.httponly',
+                cell: (info) => (_jsx("p", { className: "flex justify-center items-center", children: info ? _jsx("span", { className: "font-serif", children: "\u2713" }) : '' })),
+                widthWeightagePercentage: 5,
+            },
+            {
+                header: I18n.getMessage('secure'),
+                accessorKey: 'parsedCookie.secure',
+                cell: (info) => (_jsx("p", { className: "flex justify-center items-center", children: info ? _jsx("span", { className: "font-serif", children: "\u2713" }) : '' })),
+                widthWeightagePercentage: 5,
+            },
+            {
+                header: I18n.getMessage('value'),
+                accessorKey: 'parsedCookie.value',
+                cell: (info) => info,
+                widthWeightagePercentage: 10,
+            },
+            {
+                header: I18n.getMessage('path'),
+                accessorKey: 'parsedCookie.path',
+                cell: (info) => info,
+                widthWeightagePercentage: 4,
+            },
+            {
+                header: I18n.getMessage('expires'),
+                accessorKey: 'parsedCookie.expires',
+                cell: (info) => info === 'Session' || !info ? I18n.getMessage('session') : info,
+                widthWeightagePercentage: 7,
+            },
+        ];
+        if (isExtension) {
+            baseColumns.push({
+                header: I18n.getMessage('priority'),
+                accessorKey: 'parsedCookie.priority',
+                isHiddenByDefault: true,
+                cell: (info) => I18n.getMessage(info?.toLowerCase()),
+                widthWeightagePercentage: 4,
+            }, {
+                header: I18n.getMessage('size'),
+                accessorKey: 'parsedCookie.size',
+                isHiddenByDefault: true,
+                cell: (info) => info,
+                widthWeightagePercentage: 3,
+            });
+        }
+        return baseColumns;
+    }, [isExtension]);
+    const filters = useMemo(() => {
+        let baseFilters = {
+            'analytics.category': {
+                title: I18n.getMessage('category'),
+                hasStaticFilterValues: true,
+                hasPrecalculatedFilterValues: true,
+                filterValues: evaluateStaticFilterValues({
+                    [I18n.getMessage('analytics')]: {
+                        selected: false,
+                    },
+                    [I18n.getMessage('functional')]: {
+                        selected: false,
+                    },
+                    [I18n.getMessage('marketing')]: {
+                        selected: false,
+                    },
+                    [I18n.getMessage('uncategorized')]: {
+                        selected: false,
+                    },
+                }, 'analytics.category', parsedQuery, clearActivePanelQuery),
+                sortValues: true,
+                useGenericPersistenceKey: true,
+                comparator: (value, filterValue) => {
+                    const val = value;
+                    return (I18n.getMessage(val?.toLowerCase() || 'uncategorized') ===
+                        filterValue);
+                },
+            },
+            isFirstParty: {
+                title: I18n.getMessage('scope'),
+                hasStaticFilterValues: true,
+                hasPrecalculatedFilterValues: true,
+                filterValues: evaluateStaticFilterValues({
+                    [I18n.getMessage('firstParty')]: {
+                        selected: false,
+                    },
+                    [I18n.getMessage('thirdParty')]: {
+                        selected: false,
+                    },
+                }, 'isFirstParty', parsedQuery, clearActivePanelQuery),
+                useGenericPersistenceKey: true,
+                comparator: (value, filterValue) => {
+                    const val = Boolean(value);
+                    return val === (filterValue === I18n.getMessage('firstParty'));
+                },
+            },
+            'parsedCookie.domain': {
+                title: I18n.getMessage('domain'),
+            },
+            'parsedCookie.httponly': {
+                title: I18n.getMessage('httpOnly'),
+                hasStaticFilterValues: true,
+                filterValues: {
+                    [I18n.getMessage('true')]: {
+                        selected: false,
+                    },
+                    [I18n.getMessage('false')]: {
+                        selected: false,
+                    },
+                },
+                useGenericPersistenceKey: true,
+                comparator: (value, filterValue) => {
+                    const val = Boolean(value);
+                    return val === (filterValue === I18n.getMessage('true'));
+                },
+            },
+            'parsedCookie.sameSite': {
+                title: I18n.getMessage('sameSite'),
+                hasStaticFilterValues: true,
+                filterValues: {
+                    [I18n.getMessage('none')]: {
+                        selected: false,
+                    },
+                    [I18n.getMessage('lax')]: {
+                        selected: false,
+                    },
+                    [I18n.getMessage('strict')]: {
+                        selected: false,
+                    },
+                },
+                useGenericPersistenceKey: true,
+                comparator: (value, filterValue) => {
+                    const val = value;
+                    return val?.toLowerCase() === filterValue.toLowerCase();
+                },
+            },
+            'parsedCookie.secure': {
+                title: I18n.getMessage('secure'),
+                hasStaticFilterValues: true,
+                filterValues: {
+                    [I18n.getMessage('true')]: {
+                        selected: false,
+                    },
+                    [I18n.getMessage('false')]: {
+                        selected: false,
+                    },
+                },
+                useGenericPersistenceKey: true,
+                comparator: (value, filterValue) => {
+                    const val = Boolean(value);
+                    return val === (filterValue === I18n.getMessage('true'));
+                },
+            },
+            'parsedCookie.path': {
+                title: I18n.getMessage('path'),
+            },
+            'parsedCookie.expires': {
+                title: I18n.getMessage('retentionPeriod'),
+                hasStaticFilterValues: true,
+                filterValues: {
+                    [I18n.getMessage('session')]: {
+                        selected: false,
+                    },
+                    [I18n.getMessage('shortTerm')]: {
+                        selected: false,
+                    },
+                    [I18n.getMessage('mediumTerm')]: {
+                        selected: false,
+                    },
+                    [I18n.getMessage('longTerm')]: {
+                        selected: false,
+                    },
+                    [I18n.getMessage('extentedTerm')]: {
+                        selected: false,
+                    },
+                },
+                useGenericPersistenceKey: true,
+                comparator: (value, filterValue) => {
+                    let diff = 0;
+                    const val = value;
+                    switch (filterValue) {
+                        case I18n.getMessage('session'):
+                            return val === 'Session';
+                        case I18n.getMessage('shortTerm'):
+                            diff = Date.parse(val) - Date.now();
+                            return diff < 86400000;
+                        case I18n.getMessage('mediumTerm'):
+                            diff = Date.parse(val) - Date.now();
+                            return diff >= 86400000 && diff < 604800000;
+                        case I18n.getMessage('longTerm'):
+                            diff = Date.parse(val) - Date.now();
+                            return diff >= 604800000 && diff < 2629743833;
+                        case I18n.getMessage('extentedTerm'):
+                            diff = Date.parse(val) - Date.now();
+                            return diff >= 2629743833;
+                        default:
+                            return false;
+                    }
+                },
+            },
+            'analytics.platform': {
+                title: I18n.getMessage('platform'),
+                hasStaticFilterValues: true,
+                hasPrecalculatedFilterValues: true,
+                filterValues: calculateDynamicFilterValues('analytics.platform', tabCookies, parsedQuery?.filter?.['analytics.platform'], clearActivePanelQuery),
+                sortValues: true,
+                useGenericPersistenceKey: true,
+            },
+            blockedReasons: {
+                title: I18n.getMessage('blockedReasons'),
+                hasStaticFilterValues: true,
+                hasPrecalculatedFilterValues: true,
+                enableSelectAllOption: true,
+                isSelectAllOptionSelected: evaluateSelectAllOption('blockedReasons', parsedQuery, clearActivePanelQuery),
+                filterValues: calculateBlockedReasonsFilterValues(tabCookies, parsedQuery?.filter?.blockedReasons, clearActivePanelQuery),
+                sortValues: true,
+                useGenericPersistenceKey: true,
+                comparator: (value, filterValue) => {
+                    return value?.includes(filterValue);
+                },
+            },
+            exemptionReason: {
+                title: I18n.getMessage('exemptionReasons'),
+                hasStaticFilterValues: true,
+                hasPrecalculatedFilterValues: true,
+                enableSelectAllOption: true,
+                isSelectAllOptionSelected: evaluateSelectAllOption('exemptionReason', parsedQuery, clearActivePanelQuery),
+                filterValues: calculateExemptionReason(tabCookies, clearActivePanelQuery, parsedQuery?.filter?.exemptionReason),
+                comparator: (value, filterValue) => {
+                    const val = value;
+                    return val === filterValue;
+                },
+                useGenericPersistenceKey: true,
+            },
+        };
+        if (isExtension) {
+            const { exemptionReason, ...rest } = baseFilters;
+            baseFilters = {
+                ...rest,
+                'parsedCookie.partitionKey': {
+                    title: I18n.getMessage('partitionKey'),
+                    hasStaticFilterValues: true,
+                    filterValues: {
+                        [I18n.getMessage('set')]: {
+                            selected: false,
+                        },
+                        [I18n.getMessage('notSet')]: {
+                            selected: false,
+                        },
+                    },
+                    useGenericPersistenceKey: true,
+                    comparator: (value, filterValue) => {
+                        const val = value;
+                        return val
+                            ? filterValue === I18n.getMessage('set')
+                            : filterValue === I18n.getMessage('notSet');
+                    },
+                },
+                headerType: {
+                    title: I18n.getMessage('setVia'),
+                    hasStaticFilterValues: true,
+                    filterValues: {
+                        [I18n.getMessage('http')]: {
+                            selected: false,
+                        },
+                        [I18n.getMessage('jS')]: {
+                            selected: false,
+                        },
+                    },
+                    useGenericPersistenceKey: true,
+                    comparator: (value, filterValue) => {
+                        switch (filterValue) {
+                            case I18n.getMessage('jS'):
+                                return value === 'javascript';
+                            case I18n.getMessage('http'):
+                                return value === 'request' || value === 'response';
+                            default:
+                                return true;
+                        }
+                    },
+                },
+                'parsedCookie.priority': {
+                    title: I18n.getMessage('priority'),
+                    hasStaticFilterValues: true,
+                    filterValues: {
+                        [I18n.getMessage('low')]: {
+                            selected: false,
+                        },
+                        [I18n.getMessage('medium')]: {
+                            selected: false,
+                        },
+                        [I18n.getMessage('high')]: {
+                            selected: false,
+                        },
+                    },
+                    useGenericPersistenceKey: true,
+                    comparator: (value, filterValue) => {
+                        const val = I18n.getMessage(value?.toLowerCase());
+                        return val === filterValue;
+                    },
+                },
+                exemptionReason,
+            };
+        }
+        return baseFilters;
+    }, [clearActivePanelQuery, parsedQuery, tabCookies, isExtension]);
+    const searchKeys = useMemo(() => ['parsedCookie.name', 'parsedCookie.domain'], []);
+    return {
+        tableColumns,
+        filters,
+        searchKeys,
+        tablePersistentSettingsKey,
+        isSidebarOpen: parsedQuery?.filter ? true : false,
+    };
+};
+export default useCookieListing;

package/dist/dashboard/index.js

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export { default as SiteReport } from './components/siteReport';
+export { default as SiteMapReport } from './components/siteMapReport';
+export { default as extractReportData } from './components/utils/extractReportData';
+export { default as extractCookies } from './components/utils/extractCookies';

package/dist/index.js

@@ -0,0 +1,16 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './dashboard';

package/dist-types/dashboard/components/cookiesWithIssues/index.d.ts

@@ -0,0 +1,8 @@
+import { type CookieTableData } from '@google-psat/common';
+interface CookiesWithIssuesProps {
+    cookies: CookieTableData[];
+    selectedSite: string | null;
+    hostName: string;
+}
+declare const CookiesWithIssues: ({ cookies, selectedSite, hostName, }: CookiesWithIssuesProps) => import("react/jsx-runtime").JSX.Element;
+export default CookiesWithIssues;

package/dist-types/dashboard/components/header/index.d.ts

@@ -0,0 +1,6 @@
+interface HeaderProps {
+    url: string | undefined | null;
+    dateTime: string;
+}
+declare const Header: ({ url, dateTime }: HeaderProps) => import("react/jsx-runtime").JSX.Element;
+export default Header;

package/dist-types/dashboard/components/siteMapReport/cookies.d.ts

@@ -0,0 +1,15 @@
+import { type CompleteJson, type LibraryData, type TabCookies, type TabFrames } from '@google-psat/common';
+interface CookiesTabProps {
+    selectedSite?: string;
+    tabCookies: TabCookies;
+    tabFrames: TabFrames;
+    completeJson: CompleteJson[] | null;
+    path: string;
+    libraryMatches: {
+        [url: string]: LibraryData;
+    } | null;
+    query?: string;
+    clearQuery?: () => void;
+}
+declare const CookiesTab: ({ selectedSite, tabCookies, tabFrames, completeJson, path, libraryMatches, query, clearQuery, }: CookiesTabProps) => import("react/jsx-runtime").JSX.Element;
+export default CookiesTab;

package/dist-types/dashboard/components/siteMapReport/index.d.ts

@@ -0,0 +1,11 @@
+import type { CookieFrameStorageType, CompleteJson, LibraryData } from '@google-psat/common';
+interface SiteMapReportProps {
+    landingPageCookies: CookieFrameStorageType;
+    completeJson: CompleteJson[] | null;
+    path: string;
+    libraryMatches: {
+        [url: string]: LibraryData;
+    } | null;
+}
+declare const SiteMapReport: ({ landingPageCookies, completeJson, path, libraryMatches, }: SiteMapReportProps) => import("react/jsx-runtime").JSX.Element;
+export default SiteMapReport;

package/dist-types/dashboard/components/siteMapReport/layout.d.ts

@@ -0,0 +1,18 @@
+/**
+ * External dependencies.
+ */
+import React from 'react';
+import { type CookieFrameStorageType, type CompleteJson, type LibraryData } from '@google-psat/common';
+import { type SidebarItems } from '@google-psat/design-system';
+interface LayoutProps {
+    landingPageCookies: CookieFrameStorageType;
+    completeJson: CompleteJson[] | null;
+    sidebarData: SidebarItems;
+    setSidebarData: React.Dispatch<React.SetStateAction<SidebarItems>>;
+    path: string;
+    libraryMatches: {
+        [url: string]: LibraryData;
+    } | null;
+}
+declare const Layout: ({ landingPageCookies, completeJson, sidebarData, setSidebarData, path, libraryMatches, }: LayoutProps) => import("react/jsx-runtime").JSX.Element;
+export default Layout;

package/dist-types/dashboard/components/siteMapReport/sidebarData.d.ts

@@ -0,0 +1,3 @@
+import { type SidebarItems } from '@google-psat/design-system';
+declare const sidebarData: SidebarItems;
+export default sidebarData;

package/dist-types/dashboard/components/siteMapReport/sitemapCookiesWithIssues.d.ts

@@ -0,0 +1,10 @@
+/**
+ * External dependencies.
+ */
+import type { CookieTableData } from '@google-psat/common';
+interface SiteMapCookiesWithIssuesProps {
+    cookies: CookieTableData[];
+    path: string;
+}
+declare const SiteMapCookiesWithIssues: ({ cookies, path, }: SiteMapCookiesWithIssuesProps) => import("react/jsx-runtime").JSX.Element;
+export default SiteMapCookiesWithIssues;

package/dist-types/dashboard/components/siteReport/components/layout.d.ts

@@ -0,0 +1,13 @@
+/**
+ * External dependencies.
+ */
+import React from 'react';
+import { type SidebarItems } from '@google-psat/design-system';
+interface LayoutProps {
+    selectedSite: string | null;
+    setSidebarData: React.Dispatch<React.SetStateAction<SidebarItems>>;
+    query?: string;
+    clearQuery?: () => void;
+}
+declare const Layout: ({ selectedSite, setSidebarData, query, clearQuery, }: LayoutProps) => import("react/jsx-runtime").JSX.Element;
+export default Layout;

package/dist-types/dashboard/components/siteReport/index.d.ts

@@ -0,0 +1,17 @@
+import { type CompleteJson, type CookieJsonDataType, type LibraryData, type TechnologyData } from '@google-psat/common';
+interface SiteReportProps {
+    cookies: {
+        [frame: string]: {
+            [key: string]: CookieJsonDataType;
+        };
+    };
+    technologies: TechnologyData[];
+    completeJson: CompleteJson[] | null;
+    selectedSite: string | null;
+    path: string;
+    libraryMatches: LibraryData | null;
+    query?: string;
+    clearQuery?: () => void;
+}
+declare const SiteReport: ({ cookies, technologies, completeJson, selectedSite, path, libraryMatches, query, clearQuery, }: SiteReportProps) => import("react/jsx-runtime").JSX.Element;
+export default SiteReport;

package/dist-types/dashboard/components/siteReport/stateProviders/contentStore/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * External dependencies.
+ */
+import { type PropsWithChildren } from 'react';
+import { type CompleteJson, type CookieJsonDataType, type CookieTableData, type TechnologyData, type LibraryData } from '@google-psat/common';
+export interface ContentStore {
+    state: {
+        tabCookies: {
+            [key: string]: CookieTableData;
+        };
+        technologies: TechnologyData[] | undefined;
+        completeJson: CompleteJson[] | null;
+        path: string;
+        libraryMatches: LibraryData | null;
+    };
+}
+export declare const Context: import("use-context-selector").Context<ContentStore>;
+interface ContentStoreProviderProps {
+    cookies: {
+        [frame: string]: {
+            [key: string]: CookieJsonDataType;
+        };
+    };
+    technologies?: TechnologyData[];
+    completeJson: CompleteJson[] | null;
+    path: string;
+    libraryMatches: LibraryData | null;
+}
+export declare const Provider: ({ cookies, technologies, completeJson, children, path, libraryMatches, }: PropsWithChildren<ContentStoreProviderProps>) => import("react/jsx-runtime").JSX.Element;
+export declare function useContentStore(): ContentStore;
+export declare function useContentStore<T>(selector: (state: ContentStore) => T): T;
+export {};

package/dist-types/dashboard/components/siteReport/tabs/cookies/cookiesLandingContainer/cookieLanding/blockedCookiesSection.d.ts

@@ -0,0 +1,8 @@
+import { type TabCookies, type TabFrames } from '@google-psat/common';
+interface BlockedCookiesSectionProps {
+    tabCookies: TabCookies | null;
+    cookiesWithIssues: TabCookies | null;
+    tabFrames: TabFrames | null;
+}
+declare const BlockedCookiesSection: ({ tabCookies, cookiesWithIssues, tabFrames, }: BlockedCookiesSectionProps) => import("react/jsx-runtime").JSX.Element;
+export default BlockedCookiesSection;

package/dist-types/dashboard/components/siteReport/tabs/cookies/cookiesLandingContainer/cookieLanding/cookiesSection.d.ts

@@ -0,0 +1,7 @@
+import type { TabCookies, TabFrames } from '@google-psat/common';
+interface CookiesSectionProps {
+    tabCookies: TabCookies | null;
+    tabFrames: TabFrames | null;
+}
+declare const CookiesSection: ({ tabCookies, tabFrames }: CookiesSectionProps) => import("react/jsx-runtime").JSX.Element;
+export default CookiesSection;

package/dist-types/dashboard/components/siteReport/tabs/cookies/cookiesLandingContainer/cookieLanding/exemptedCookiesSection.d.ts

@@ -0,0 +1,7 @@
+import { type TabFrames, type TabCookies } from '@google-psat/common';
+interface ExemptedCookiesSectionProps {
+    tabCookies: TabCookies | null;
+    tabFrames: TabFrames | null;
+}
+declare const ExemptedCookiesSection: ({ tabCookies, tabFrames, }: ExemptedCookiesSectionProps) => import("react/jsx-runtime").JSX.Element;
+export default ExemptedCookiesSection;

package/dist-types/dashboard/components/siteReport/tabs/cookies/cookiesLandingContainer/cookieLanding/framesSection.d.ts

@@ -0,0 +1,2 @@
+declare const FramesSection: () => import("react/jsx-runtime").JSX.Element;
+export default FramesSection;

package/dist-types/dashboard/components/siteReport/tabs/cookies/cookiesLandingContainer/cookieLanding/index.d.ts

@@ -0,0 +1,2 @@
+export { default as CookiesSection } from './cookiesSection';
+export { default as BlockedCookiesSection } from './blockedCookiesSection';

package/dist-types/dashboard/components/siteReport/tabs/cookies/cookiesLandingContainer/cookieLanding/knownBreakages.d.ts

@@ -0,0 +1,9 @@
+import type { LibraryData } from '@google-psat/common';
+interface KnownBreakagesProps {
+    libraryMatches: LibraryData;
+    libraryMatchesUrlCount?: {
+        [url: string]: number;
+    };
+}
+declare const KnownBreakages: ({ libraryMatches, libraryMatchesUrlCount, }: KnownBreakagesProps) => import("react/jsx-runtime").JSX.Element;
+export default KnownBreakages;

package/dist-types/dashboard/components/siteReport/tabs/cookies/cookiesLandingContainer/cookieLanding/landing.d.ts

@@ -0,0 +1,15 @@
+import type { LibraryData, TabCookies, TabFrames } from '@google-psat/common';
+interface LandingProps {
+    tabFrames: TabFrames;
+    tabCookies: TabCookies;
+    cookiesWithIssues: TabCookies;
+    downloadReport?: () => Promise<void>;
+    libraryMatches: LibraryData | null;
+    isSiteMapLandingContainer?: boolean;
+    menuBarScrollContainerId?: string;
+    libraryMatchesUrlCount?: {
+        [url: string]: number;
+    };
+}
+declare const Landing: ({ tabFrames, tabCookies, cookiesWithIssues, downloadReport, libraryMatches, libraryMatchesUrlCount, menuBarScrollContainerId, }: LandingProps) => import("react/jsx-runtime").JSX.Element;
+export default Landing;