@parca/profile 0.19.140 → 0.19.142

package/dist/ProfileView/components/ProfileFilters/useProfileFiltersUrlState.test.js

@@ -1,455 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-// eslint-disable-next-line import/named
-import { act, renderHook, waitFor } from '@testing-library/react';
-// eslint-disable-next-line import/no-unresolved
-import { NuqsTestingAdapter } from 'nuqs/adapters/testing';
-import { describe, expect, it, vi } from 'vitest';
-import { decodeProfileFilters, useProfileFiltersUrlState } from './useProfileFiltersUrlState';
-// Helper to create wrapper with NuqsTestingAdapter
-const createWrapper = (searchParams = {}, onUrlUpdate) => {
-    const Wrapper = ({ children }) => (_jsx(NuqsTestingAdapter, { searchParams: searchParams, onUrlUpdate: onUrlUpdate, hasMemory: true, children: children }));
-    Wrapper.displayName = 'NuqsTestingWrapper';
-    return Wrapper;
-};
-describe('useProfileFiltersUrlState', () => {
-    describe('decodeProfileFilters', () => {
-        it('should return empty array for empty string', () => {
-            expect(decodeProfileFilters('')).toEqual([]);
-        });
-        it('should return empty array for undefined', () => {
-            expect(decodeProfileFilters(undefined)).toEqual([]);
-        });
-        it('should decode stack filter with function_name', () => {
-            // Format: type:field:match:value -> s:fn:=:testFunc
-            const encoded = 's:fn:=:testFunc';
-            const result = decodeProfileFilters(encoded);
-            expect(result).toHaveLength(1);
-            expect(result[0]).toMatchObject({
-                type: 'stack',
-                field: 'function_name',
-                matchType: 'equal',
-                value: 'testFunc',
-            });
-        });
-        it('should decode frame filter with binary', () => {
-            const encoded = 'f:b:!=:libc.so';
-            const result = decodeProfileFilters(encoded);
-            expect(result).toHaveLength(1);
-            expect(result[0]).toMatchObject({
-                type: 'frame',
-                field: 'binary',
-                matchType: 'not_equal',
-                value: 'libc.so',
-            });
-        });
-        it('should decode filter with contains match', () => {
-            const encoded = 's:fn:~:runtime';
-            const result = decodeProfileFilters(encoded);
-            expect(result).toHaveLength(1);
-            expect(result[0]).toMatchObject({
-                type: 'stack',
-                field: 'function_name',
-                matchType: 'contains',
-                value: 'runtime',
-            });
-        });
-        it('should decode filter with not_contains match', () => {
-            const encoded = 'f:b:!~:node';
-            const result = decodeProfileFilters(encoded);
-            expect(result).toHaveLength(1);
-            expect(result[0]).toMatchObject({
-                type: 'frame',
-                field: 'binary',
-                matchType: 'not_contains',
-                value: 'node',
-            });
-        });
-        it('should decode filter with starts_with match', () => {
-            const encoded = 's:fn:^:std::';
-            const result = decodeProfileFilters(encoded);
-            expect(result).toHaveLength(1);
-            expect(result[0]).toMatchObject({
-                type: 'stack',
-                field: 'function_name',
-                matchType: 'starts_with',
-                value: 'std::',
-            });
-        });
-        it('should decode filter with not_starts_with match', () => {
-            const encoded = 'f:fn:!^:tokio::';
-            const result = decodeProfileFilters(encoded);
-            expect(result).toHaveLength(1);
-            expect(result[0]).toMatchObject({
-                type: 'frame',
-                field: 'function_name',
-                matchType: 'not_starts_with',
-                value: 'tokio::',
-            });
-        });
-        it('should decode multiple filters', () => {
-            const encoded = 's:fn:=:testFunc,f:b:!=:libc.so';
-            const result = decodeProfileFilters(encoded);
-            expect(result).toHaveLength(2);
-            expect(result[0]).toMatchObject({
-                type: 'stack',
-                field: 'function_name',
-                matchType: 'equal',
-                value: 'testFunc',
-            });
-            expect(result[1]).toMatchObject({
-                type: 'frame',
-                field: 'binary',
-                matchType: 'not_equal',
-                value: 'libc.so',
-            });
-        });
-        it('should decode preset filter', () => {
-            const encoded = 'p:hide_libc:enabled';
-            const result = decodeProfileFilters(encoded);
-            expect(result).toHaveLength(1);
-            expect(result[0]).toMatchObject({
-                type: 'hide_libc',
-                value: 'enabled',
-            });
-        });
-        it('should handle values with colons', () => {
-            const encoded = 'p:some_preset:value:with:colons';
-            const result = decodeProfileFilters(encoded);
-            expect(result).toHaveLength(1);
-            expect(result[0]).toMatchObject({
-                type: 'some_preset',
-                value: 'value:with:colons',
-            });
-        });
-        it('should decode all field types', () => {
-            const testCases = [
-                { encoded: 's:fn:=:test', expectedField: 'function_name' },
-                { encoded: 's:b:=:test', expectedField: 'binary' },
-                { encoded: 's:sn:=:test', expectedField: 'system_name' },
-                { encoded: 's:f:=:test', expectedField: 'filename' },
-                { encoded: 's:a:=:test', expectedField: 'address' },
-                { encoded: 's:ln:=:test', expectedField: 'line_number' },
-            ];
-            for (const { encoded, expectedField } of testCases) {
-                const result = decodeProfileFilters(encoded);
-                expect(result[0].field).toBe(expectedField);
-            }
-        });
-        it('should return empty array for malformed input', () => {
-            // This should not throw - it returns empty array on error
-            expect(() => decodeProfileFilters('malformed')).not.toThrow();
-        });
-        it('should generate unique IDs for each filter', () => {
-            const encoded = 's:fn:=:func1,s:fn:=:func2,s:fn:=:func3';
-            const result = decodeProfileFilters(encoded);
-            const ids = result.map(f => f.id);
-            const uniqueIds = new Set(ids);
-            expect(uniqueIds.size).toBe(ids.length);
-        });
-    });
-    describe('Basic functionality', () => {
-        it('should initialize with empty filters when no URL params', () => {
-            const { result } = renderHook(() => useProfileFiltersUrlState(), { wrapper: createWrapper() });
-            expect(result.current.appliedFilters).toEqual([]);
-        });
-        it('should read filters from URL', async () => {
-            const { result } = renderHook(() => useProfileFiltersUrlState(), {
-                wrapper: createWrapper({ profile_filters: 's:fn:=:testFunc' }),
-            });
-            await waitFor(() => {
-                expect(result.current.appliedFilters).toHaveLength(1);
-                expect(result.current.appliedFilters[0]).toMatchObject({
-                    type: 'stack',
-                    field: 'function_name',
-                    matchType: 'equal',
-                    value: 'testFunc',
-                });
-            });
-        });
-        it('should update URL when setting filters', async () => {
-            const onUrlUpdate = vi.fn();
-            const { result } = renderHook(() => useProfileFiltersUrlState(), {
-                wrapper: createWrapper({}, onUrlUpdate),
-            });
-            const newFilters = [
-                {
-                    id: 'test-1',
-                    type: 'frame',
-                    field: 'binary',
-                    matchType: 'not_contains',
-                    value: 'libc.so',
-                },
-            ];
-            act(() => {
-                result.current.setAppliedFilters(newFilters);
-            });
-            await waitFor(() => {
-                expect(onUrlUpdate).toHaveBeenCalled();
-                const lastCall = onUrlUpdate.mock.calls[onUrlUpdate.mock.calls.length - 1][0];
-                expect(lastCall.searchParams.get('profile_filters')).toBe('f:b:!~:libc.so');
-            });
-        });
-        it('should clear URL param when setting empty filters', async () => {
-            const onUrlUpdate = vi.fn();
-            const { result } = renderHook(() => useProfileFiltersUrlState(), {
-                wrapper: createWrapper({ profile_filters: 's:fn:=:testFunc' }, onUrlUpdate),
-            });
-            act(() => {
-                result.current.setAppliedFilters([]);
-            });
-            await waitFor(() => {
-                expect(onUrlUpdate).toHaveBeenCalled();
-                const lastCall = onUrlUpdate.mock.calls[onUrlUpdate.mock.calls.length - 1][0];
-                expect(lastCall.searchParams.has('profile_filters')).toBe(false);
-            });
-        });
-    });
-    describe('forceApplyFilters', () => {
-        it('should provide forceApplyFilters method', () => {
-            const { result } = renderHook(() => useProfileFiltersUrlState(), { wrapper: createWrapper() });
-            expect(typeof result.current.forceApplyFilters).toBe('function');
-        });
-        it('should force apply filters overwriting existing', async () => {
-            const onUrlUpdate = vi.fn();
-            const { result } = renderHook(() => useProfileFiltersUrlState(), {
-                wrapper: createWrapper({ profile_filters: 's:fn:=:existingFunc' }, onUrlUpdate),
-            });
-            // Verify existing filter is loaded
-            await waitFor(() => {
-                expect(result.current.appliedFilters).toHaveLength(1);
-            });
-            const newFilters = [
-                {
-                    id: 'forced-1',
-                    type: 'frame',
-                    field: 'binary',
-                    matchType: 'not_contains',
-                    value: 'forcedValue',
-                },
-            ];
-            act(() => {
-                result.current.forceApplyFilters(newFilters);
-            });
-            await waitFor(() => {
-                expect(onUrlUpdate).toHaveBeenCalled();
-                const lastCall = onUrlUpdate.mock.calls[onUrlUpdate.mock.calls.length - 1][0];
-                expect(lastCall.searchParams.get('profile_filters')).toBe('f:b:!~:forcedValue');
-            });
-        });
-        it('should clear filters when force applying empty array', async () => {
-            const onUrlUpdate = vi.fn();
-            const { result } = renderHook(() => useProfileFiltersUrlState(), {
-                wrapper: createWrapper({ profile_filters: 's:fn:=:existingFunc' }, onUrlUpdate),
-            });
-            act(() => {
-                result.current.forceApplyFilters([]);
-            });
-            await waitFor(() => {
-                expect(onUrlUpdate).toHaveBeenCalled();
-                const lastCall = onUrlUpdate.mock.calls[onUrlUpdate.mock.calls.length - 1][0];
-                expect(lastCall.searchParams.has('profile_filters')).toBe(false);
-            });
-        });
-    });
-    describe('Preset filter encoding', () => {
-        it('should encode preset filters correctly', async () => {
-            const onUrlUpdate = vi.fn();
-            const { result } = renderHook(() => useProfileFiltersUrlState(), {
-                wrapper: createWrapper({}, onUrlUpdate),
-            });
-            const presetFilters = [
-                {
-                    id: 'preset-1',
-                    type: 'hide_libc',
-                    value: 'enabled',
-                },
-            ];
-            act(() => {
-                result.current.setAppliedFilters(presetFilters);
-            });
-            await waitFor(() => {
-                expect(onUrlUpdate).toHaveBeenCalled();
-                const lastCall = onUrlUpdate.mock.calls[onUrlUpdate.mock.calls.length - 1][0];
-                expect(lastCall.searchParams.get('profile_filters')).toBe('p:hide_libc:enabled');
-            });
-        });
-        it('should handle mixed preset and regular filters', async () => {
-            const onUrlUpdate = vi.fn();
-            const { result } = renderHook(() => useProfileFiltersUrlState(), {
-                wrapper: createWrapper({}, onUrlUpdate),
-            });
-            const mixedFilters = [
-                {
-                    id: 'preset-1',
-                    type: 'hide_libc',
-                    value: 'enabled',
-                },
-                {
-                    id: 'regular-1',
-                    type: 'frame',
-                    field: 'binary',
-                    matchType: 'not_contains',
-                    value: 'node',
-                },
-            ];
-            act(() => {
-                result.current.setAppliedFilters(mixedFilters);
-            });
-            await waitFor(() => {
-                expect(onUrlUpdate).toHaveBeenCalled();
-                const lastCall = onUrlUpdate.mock.calls[onUrlUpdate.mock.calls.length - 1][0];
-                expect(lastCall.searchParams.get('profile_filters')).toBe('p:hide_libc:enabled,f:b:!~:node');
-            });
-        });
-    });
-    describe('URL encoding edge cases', () => {
-        it('should handle special characters in filter values', async () => {
-            const onUrlUpdate = vi.fn();
-            const { result } = renderHook(() => useProfileFiltersUrlState(), {
-                wrapper: createWrapper({}, onUrlUpdate),
-            });
-            const filtersWithSpecialChars = [
-                {
-                    id: 'special-1',
-                    type: 'stack',
-                    field: 'function_name',
-                    matchType: 'contains',
-                    value: 'std::vector<int>',
-                },
-            ];
-            act(() => {
-                result.current.setAppliedFilters(filtersWithSpecialChars);
-            });
-            await waitFor(() => {
-                expect(onUrlUpdate).toHaveBeenCalled();
-                const lastCall = onUrlUpdate.mock.calls[onUrlUpdate.mock.calls.length - 1][0];
-                const filterValue = lastCall.searchParams.get('profile_filters');
-                // The value should contain the encoded special characters
-                expect(filterValue).toContain('std%3A%3Avector%3Cint%3E');
-            });
-        });
-        it('should filter out incomplete filters when encoding', async () => {
-            const onUrlUpdate = vi.fn();
-            const { result } = renderHook(() => useProfileFiltersUrlState(), {
-                wrapper: createWrapper({}, onUrlUpdate),
-            });
-            const incompleteFilters = [
-                {
-                    id: 'complete-1',
-                    type: 'frame',
-                    field: 'binary',
-                    matchType: 'not_contains',
-                    value: 'valid',
-                },
-                {
-                    id: 'incomplete-1',
-                    type: 'frame',
-                    // Missing field, matchType
-                    value: '',
-                },
-                {
-                    id: 'incomplete-2',
-                    type: undefined,
-                    value: 'value',
-                },
-            ];
-            act(() => {
-                result.current.setAppliedFilters(incompleteFilters);
-            });
-            await waitFor(() => {
-                expect(onUrlUpdate).toHaveBeenCalled();
-                const lastCall = onUrlUpdate.mock.calls[onUrlUpdate.mock.calls.length - 1][0];
-                // Only the complete filter should be encoded
-                expect(lastCall.searchParams.get('profile_filters')).toBe('f:b:!~:valid');
-            });
-        });
-    });
-    describe('Memoization', () => {
-        it('should return empty array with consistent structure when no filters', () => {
-            const { result } = renderHook(() => useProfileFiltersUrlState(), { wrapper: createWrapper() });
-            // Empty filters should be an empty array (not undefined or null)
-            expect(Array.isArray(result.current.appliedFilters)).toBe(true);
-            expect(result.current.appliedFilters).toHaveLength(0);
-        });
-        it('should always return array (never undefined)', () => {
-            const { result } = renderHook(() => useProfileFiltersUrlState(), { wrapper: createWrapper() });
-            expect(Array.isArray(result.current.appliedFilters)).toBe(true);
-            expect(result.current.appliedFilters).toEqual([]);
-        });
-        it('should return correctly structured filters from URL', async () => {
-            const { result } = renderHook(() => useProfileFiltersUrlState(), {
-                wrapper: createWrapper({ profile_filters: 's:fn:=:testFunc' }),
-            });
-            await waitFor(() => {
-                expect(result.current.appliedFilters).toHaveLength(1);
-            });
-            // Verify the filter structure is correct
-            const filter = result.current.appliedFilters[0];
-            expect(filter).toHaveProperty('id');
-            expect(filter).toHaveProperty('type', 'stack');
-            expect(filter).toHaveProperty('field', 'function_name');
-            expect(filter).toHaveProperty('matchType', 'equal');
-            // eslint-disable-next-line jest-dom/prefer-to-have-value
-            expect(filter).toHaveProperty('value', 'testFunc');
-        });
-    });
-    describe('View switching scenarios', () => {
-        it('should completely replace filters when switching views using forceApplyFilters', async () => {
-            const onUrlUpdate = vi.fn();
-            const { result } = renderHook(() => useProfileFiltersUrlState(), {
-                wrapper: createWrapper({ profile_filters: 's:fn:=:viewAFunc,f:b:!=:viewABinary' }, onUrlUpdate),
-            });
-            await waitFor(() => {
-                expect(result.current.appliedFilters).toHaveLength(2);
-            });
-            // Switch to View B (completely different filter)
-            const viewBFilters = [
-                {
-                    id: 'viewB-1',
-                    type: 'frame',
-                    field: 'function_name',
-                    matchType: 'contains',
-                    value: 'viewBOnly',
-                },
-            ];
-            act(() => {
-                result.current.forceApplyFilters(viewBFilters);
-            });
-            await waitFor(() => {
-                expect(onUrlUpdate).toHaveBeenCalled();
-                const lastCall = onUrlUpdate.mock.calls[onUrlUpdate.mock.calls.length - 1][0];
-                const filterValue = lastCall.searchParams.get('profile_filters');
-                // View A's filters should be completely gone
-                expect(filterValue).not.toContain('viewAFunc');
-                expect(filterValue).not.toContain('viewABinary');
-                // Only View B's filter should be present
-                expect(filterValue).toBe('f:fn:~:viewBOnly');
-            });
-        });
-        it('should not change filters when clicking the same view tab', async () => {
-            const { result } = renderHook(() => useProfileFiltersUrlState(), {
-                wrapper: createWrapper({ profile_filters: 's:fn:=:existingFilter' }),
-            });
-            await waitFor(() => {
-                expect(result.current.appliedFilters).toHaveLength(1);
-            });
-            // Apply the same filters (simulating clicking the same view tab)
-            const sameFilters = [
-                {
-                    id: 'same-1',
-                    type: 'stack',
-                    field: 'function_name',
-                    matchType: 'equal',
-                    value: 'existingFilter',
-                },
-            ];
-            act(() => {
-                result.current.forceApplyFilters(sameFilters);
-            });
-            await waitFor(() => {
-                expect(result.current.appliedFilters).toHaveLength(1);
-                expect(result.current.appliedFilters[0].value).toBe('existingFilter');
-            });
-        });
-    });
-});

package/dist/hooks/urlParsers.d.ts

@@ -1,18 +0,0 @@
-import { createParser } from 'nuqs';
-export declare const stringParam: import("nuqs").SingleParserBuilder<string>;
-export declare const boolParam: import("nuqs").SingleParserBuilder<boolean>;
-export declare const intParam: import("nuqs").SingleParserBuilder<number>;
-export declare const commaArrayParam: import("nuqs").SingleParserBuilder<string[]>;
-export declare const invertCallStackParser: Omit<import("nuqs").SingleParserBuilder<boolean>, "parseServerSide"> & {
-    readonly defaultValue: boolean;
-    parseServerSide(value: string | string[] | undefined): boolean;
-};
-export declare const groupByParser: import("nuqs").SingleParserBuilder<string[]>;
-export declare const flamechartDimensionParser: import("nuqs").SingleParserBuilder<string[]>;
-export declare const tableColumnsParser: import("nuqs").SingleParserBuilder<string[]>;
-export declare const hiddenBinariesParser: Omit<import("nuqs").SingleParserBuilder<string[]>, "parseServerSide"> & {
-    readonly defaultValue: string[];
-    parseServerSide(value: string | string[] | undefined): string[];
-};
-export declare function jsonParser<T>(): ReturnType<typeof createParser<T>>;
-//# sourceMappingURL=urlParsers.d.ts.map

package/dist/hooks/urlParsers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"urlParsers.d.ts","sourceRoot":"","sources":["../../src/hooks/urlParsers.ts"],"names":[],"mappings":"AAaA,OAAO,EAAC,YAAY,EAAgE,MAAM,MAAM,CAAC;AAKjG,eAAO,MAAM,WAAW,4CAAkC,CAAC;AAC3D,eAAO,MAAM,SAAS,6CAAmC,CAAC;AAC1D,eAAO,MAAM,QAAQ,4CAAmC,CAAC;AACzD,eAAO,MAAM,eAAe,8CAAuD,CAAC;AAGpF,eAAO,MAAM,qBAAqB;;;CAA+B,CAAC;AAClE,eAAO,MAAM,aAAa,8CAAkB,CAAC;AAC7C,eAAO,MAAM,yBAAyB,8CAAkB,CAAC;AACzD,eAAO,MAAM,kBAAkB,8CAAkB,CAAC;AAClD,eAAO,MAAM,oBAAoB;;;CAAkC,CAAC;AAGpE,wBAAgB,UAAU,CAAC,CAAC,KAAK,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC,CAAC,CAMlE"}

package/dist/hooks/urlParsers.js

@@ -1,32 +0,0 @@
-// Copyright 2022 The Parca Authors
-// 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
-//
-// http://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.
-import { createParser, parseAsArrayOf, parseAsBoolean, parseAsInteger, parseAsString } from 'nuqs';
-const opts = { history: 'replace' };
-// === Base parsers with common options ===
-export const stringParam = parseAsString.withOptions(opts);
-export const boolParam = parseAsBoolean.withOptions(opts);
-export const intParam = parseAsInteger.withOptions(opts);
-export const commaArrayParam = parseAsArrayOf(parseAsString, ',').withOptions(opts);
-// === Param-specific parsers with defaults ===
-export const invertCallStackParser = boolParam.withDefault(false);
-export const groupByParser = commaArrayParam;
-export const flamechartDimensionParser = commaArrayParam;
-export const tableColumnsParser = commaArrayParam;
-export const hiddenBinariesParser = commaArrayParam.withDefault([]);
-// === JSON parser with BigInt support ===
-export function jsonParser() {
-    return createParser({
-        parse: (value) => JSON.parse(value),
-        serialize: (value) => JSON.stringify(value, (_, v) => (typeof v === 'bigint' ? v.toString() : v)),
-    }).withOptions(opts);
-}

package/dist/hooks/useColorBy.d.ts

@@ -1,5 +0,0 @@
-export declare const useColorBy: () => {
-    colorBy: string;
-    setColorBy: (value: string) => void;
-};
-//# sourceMappingURL=useColorBy.d.ts.map

package/dist/hooks/useColorBy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useColorBy.d.ts","sourceRoot":"","sources":["../../src/hooks/useColorBy.ts"],"names":[],"mappings":"AAqBA,eAAO,MAAM,UAAU,QAAO;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CAkBrC,CAAC"}

package/dist/hooks/useColorBy.js

@@ -1,26 +0,0 @@
-// Copyright 2022 The Parca Authors
-// 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
-//
-// http://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.
-import { useCallback } from 'react';
-import { useQueryState } from 'nuqs';
-import { USER_PREFERENCES, useUserPreference } from '@parca/hooks';
-import { stringParam } from './urlParsers';
-export const useColorBy = () => {
-    const [colorByPreference, setColorByPreference] = useUserPreference(USER_PREFERENCES.COLOR_BY.key);
-    const [colorByRaw, setRawColorBy] = useQueryState('color_by', stringParam);
-    const colorBy = colorByRaw ?? colorByPreference ?? 'binary';
-    const setColorBy = useCallback((value) => {
-        void setRawColorBy(value);
-        setColorByPreference(value);
-    }, [setRawColorBy, setColorByPreference]);
-    return { colorBy, setColorBy };
-};

package/dist/hooks/useDashboardItems.d.ts

@@ -1,5 +0,0 @@
-export declare const useDashboardItems: () => {
-    dashboardItems: string[];
-    setDashboardItems: (items: string[]) => void;
-};
-//# sourceMappingURL=useDashboardItems.d.ts.map

package/dist/hooks/useDashboardItems.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useDashboardItems.d.ts","sourceRoot":"","sources":["../../src/hooks/useDashboardItems.ts"],"names":[],"mappings":"AAqBA,eAAO,MAAM,iBAAiB,QAAO;IACnC,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,iBAAiB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;CAsB9C,CAAC"}

package/dist/hooks/useDashboardItems.js

@@ -1,27 +0,0 @@
-// Copyright 2022 The Parca Authors
-// 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
-//
-// http://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.
-import { useCallback, useMemo } from 'react';
-import { parseAsArrayOf, parseAsString, useQueryState } from 'nuqs';
-import { useParcaContext } from '@parca/components';
-const opts = { history: 'replace' };
-export const useDashboardItems = () => {
-    const { defaultDashboardItems } = useParcaContext();
-    const parser = useMemo(() => parseAsArrayOf(parseAsString, ',')
-        .withDefault(defaultDashboardItems ?? ['flamegraph'])
-        .withOptions(opts), [defaultDashboardItems]);
-    const [dashboardItems, setRawDashboardItems] = useQueryState('dashboard_items', parser);
-    const setDashboardItems = useCallback((items) => {
-        void setRawDashboardItems(items);
-    }, [setRawDashboardItems]);
-    return { dashboardItems, setDashboardItems };
-};