@helsenorge/designsystem-react 16.0.0 → 16.2.0

package/lib/hooks/useSort.d.ts

@@ -0,0 +1,88 @@
+import { SortDirection } from '../components/UNSAFE_Table/constants';
+/** Values that should never be treated as "an object to sort one level deeper into" */
+type SortLeaf = string | number | boolean | bigint | symbol | null | undefined | Date | readonly unknown[] | ((...args: never[]) => unknown);
+/**
+ * A sort key for TData: rejects unknown property names (so typos are caught), while still allowing
+ * one level of dot-notation into a nested property (e.g. "kontor.navn"). Nested properties with dynamic
+ * keys (e.g. Record<string, number>) accept any suffix after the dot, since their keys aren't statically known.
+ */
+export type SortKey<TData> = {
+    [K in Extract<keyof TData, string>]: NonNullable<TData[K]> extends SortLeaf ? K : K | `${K}.${Extract<keyof NonNullable<TData[K]>, string>}`;
+}[Extract<keyof TData, string>];
+export type SortValueGetter<TData> = (item: TData, sortKey: SortKey<TData>) => unknown;
+/** A comparator function with the same signature as Array.prototype.sort */
+export type SortComparer<TData> = (a: TData, b: TData) => number;
+/** A named sort option, e.g. for a FilterSort dropdown, mapping an option key to a column key + direction. */
+export interface SortOption<TData> {
+    columnKey: SortKey<TData>;
+    direction?: SortDirection;
+}
+/** Decides whether a sortOptions entry matches the current sort state. Default: compareSortOption. */
+export type SortOptionMatcher<TData> = (option: SortOption<TData>, columnKey: SortKey<TData> | undefined, direction: SortDirection | undefined) => boolean;
+export interface SortableHeadCellProps {
+    /** Sort direction, for displaying the current sort state on the column header (e.g. aria-sort) */
+    sortDir?: SortDirection;
+}
+export interface UseSortOptions<TData> {
+    /** The items to sort */
+    data: TData[];
+    /** Key to sort by on mount (uncontrolled mode) */
+    initialSortColumnKey?: SortKey<TData>;
+    /** Sort direction on mount (uncontrolled mode). Default: SortDirection.asc */
+    initialSortDirection?: SortDirection;
+    /** Currently sorted key (controlled mode). When set, the consumer owns the sort state and must update it based on onSortChange. */
+    sortColumnKey?: SortKey<TData>;
+    /** Current sort direction (controlled mode). Default: SortDirection.asc */
+    sortDirection?: SortDirection;
+    /** Disable internal sorting of data, e.g. when sorting happens server-side. requestSort still updates state and calls onSortChange. */
+    disableInternalSort?: boolean;
+    /**
+     * Get the value to sort an item by. Default: reads the sort key as a property from the item, with support for dot-notation paths like "person.name".
+     * Memoize this (e.g. with useCallback) if provided inline, otherwise sortedData recomputes on every render.
+     */
+    getSortValue?: SortValueGetter<TData>;
+    /**
+     * Custom comparators per sort key, for keys that need their own ordering (e.g. status ranking). The comparator should sort ascending; direction is applied by the hook.
+     * Memoize this (e.g. with useMemo) if provided inline, otherwise sortedData recomputes on every render.
+     */
+    sorters?: Partial<Record<SortKey<TData>, SortComparer<TData>>>;
+    /** Called whenever the sort changes */
+    onSortChange?: (columnKey: SortKey<TData>, sortDirection: SortDirection) => void;
+    /**
+     * Named sort options (e.g. for a FilterSort dropdown), each mapping an option key to a column key + direction.
+     * When provided, the hook exposes `sortOptionKey` (the option matching the current sort, if any) and
+     * `setSortOption` (set the sort directly from an option's key, e.g. straight from a <select>'s onChange).
+     */
+    sortOptions?: Record<string, SortOption<TData>>;
+    /**
+     * Custom matcher for deciding which sortOptions entry matches the current sort. Default: matches on exact
+     * columnKey, treating a missing direction as SortDirection.asc. Only needed for non-standard matching.
+     */
+    matchSortOption?: SortOptionMatcher<TData>;
+}
+export interface UseSortReturn<TData> {
+    /** The items, sorted by the current sort (or as-is when disableInternalSort is set) */
+    sortedData: TData[];
+    /** The key currently sorted by */
+    sortColumnKey: SortKey<TData> | undefined;
+    /** The current sort direction */
+    sortDirection: SortDirection | undefined;
+    /** Sort by a key. Toggles direction when the key is already sorted. */
+    requestSort: (columnKey: SortKey<TData>) => void;
+    /** Set both sort key and direction directly, without toggling. Useful when a control (e.g. a FilterSort dropdown) maps its own options to a fixed (key, direction) pair. */
+    setSort: (columnKey: SortKey<TData>, direction?: SortDirection) => void;
+    /** Get props for TableHeadCell to display the current sort state (aria-sort). Sorting itself is triggered by the consumer, e.g. via requestSort/onSortChange from a FilterSort control. */
+    getSortProps: (columnKey: SortKey<TData>) => SortableHeadCellProps;
+    /** The sortOptions key matching the current sort state, if any. undefined if sortOptions wasn't provided or none match. */
+    sortOptionKey: string | undefined;
+    /** Set the sort from a sortOptions key, e.g. straight from a <select>'s onChange. No-ops if the key isn't found in sortOptions. */
+    setSortOption: (optionKey: string) => void;
+}
+/**
+ * Sort state and type-aware sorting for any list (tables, filtered result lists etc.).
+ * Strings sort with Norwegian locale and numeric collation, numbers/booleans/Dates sort natively,
+ * and null/undefined always sort last. Supports uncontrolled mode (internal state),
+ * controlled mode (sortColumnKey/sortDirection props) and server-side sorting (disableInternalSort).
+ */
+export declare const useSort: <TData>(options: UseSortOptions<TData>) => UseSortReturn<TData>;
+export {};

package/lib/hooks/useSort.js

@@ -0,0 +1,91 @@
+import { n as SortDirection } from "../constants3.js";
+import { useMemo, useState } from "react";
+//#region src/hooks/useSort.ts
+var getValueByPath = (item, path) => path.split(".").reduce((value, key) => value !== null && typeof value === "object" ? value[key] : void 0, item);
+var compareSortValues = (a, b) => {
+	if (a === null || a === void 0) return b === null || b === void 0 ? 0 : 1;
+	if (b === null || b === void 0) return -1;
+	if (typeof a === "number" && typeof b === "number") return a - b;
+	if (typeof a === "boolean" && typeof b === "boolean") return Number(a) - Number(b);
+	if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime();
+	return String(a).localeCompare(String(b), "nb", {
+		numeric: true,
+		sensitivity: "base"
+	});
+};
+var sortBy = (accessor, direction = SortDirection.asc) => (a, b) => {
+	const aValue = accessor(a);
+	const bValue = accessor(b);
+	if (aValue === null || aValue === void 0 || bValue === null || bValue === void 0) return compareSortValues(aValue, bValue);
+	const result = compareSortValues(aValue, bValue);
+	return direction === SortDirection.desc ? -result : result;
+};
+var defaultMatchSortOption = (option, columnKey, direction) => option.columnKey === columnKey && (option.direction ?? SortDirection.asc) === (direction ?? SortDirection.asc);
+/**
+* Sort state and type-aware sorting for any list (tables, filtered result lists etc.).
+* Strings sort with Norwegian locale and numeric collation, numbers/booleans/Dates sort natively,
+* and null/undefined always sort last. Supports uncontrolled mode (internal state),
+* controlled mode (sortColumnKey/sortDirection props) and server-side sorting (disableInternalSort).
+*/
+var useSort = (options) => {
+	const { data, initialSortColumnKey, initialSortDirection, sortColumnKey, sortDirection, disableInternalSort, getSortValue, sorters, onSortChange, sortOptions, matchSortOption = defaultMatchSortOption } = options;
+	const [internalSort, setInternalSort] = useState(() => initialSortColumnKey ? {
+		columnKey: initialSortColumnKey,
+		direction: initialSortDirection ?? SortDirection.asc
+	} : void 0);
+	const isControlled = sortColumnKey !== void 0;
+	const sort = isControlled ? {
+		columnKey: sortColumnKey,
+		direction: sortDirection ?? SortDirection.asc
+	} : internalSort;
+	const requestSort = (columnKey) => {
+		const direction = sort?.columnKey === columnKey && sort.direction === SortDirection.asc ? SortDirection.desc : SortDirection.asc;
+		if (!isControlled) setInternalSort({
+			columnKey,
+			direction
+		});
+		onSortChange?.(columnKey, direction);
+	};
+	const setSort = (columnKey, direction = SortDirection.asc) => {
+		if (!isControlled) setInternalSort({
+			columnKey,
+			direction
+		});
+		onSortChange?.(columnKey, direction);
+	};
+	const currentSortColumnKey = sort?.columnKey;
+	const currentSortDirection = sort?.direction;
+	const sortedData = useMemo(() => {
+		if (!currentSortColumnKey || disableInternalSort) return data;
+		const customComparer = sorters?.[currentSortColumnKey];
+		const comparer = customComparer ? (a, b) => currentSortDirection === SortDirection.desc ? -customComparer(a, b) : customComparer(a, b) : sortBy((item) => (getSortValue ?? getValueByPath)(item, currentSortColumnKey), currentSortDirection);
+		return [...data].sort(comparer);
+	}, [
+		data,
+		currentSortColumnKey,
+		currentSortDirection,
+		disableInternalSort,
+		getSortValue,
+		sorters
+	]);
+	const getSortProps = (columnKey) => ({ sortDir: sort?.columnKey === columnKey ? sort.direction : void 0 });
+	const sortOptionKey = sortOptions ? Object.entries(sortOptions).find(([, option]) => matchSortOption(option, currentSortColumnKey, currentSortDirection))?.[0] : void 0;
+	const setSortOption = (optionKey) => {
+		const option = sortOptions?.[optionKey];
+		if (option) setSort(option.columnKey, option.direction);
+	};
+	return {
+		sortedData,
+		sortColumnKey: sort?.columnKey,
+		sortDirection: sort?.direction,
+		requestSort,
+		setSort,
+		getSortProps,
+		sortOptionKey,
+		setSortOption
+	};
+};
+//#endregion
+export { useSort };
+
+//# sourceMappingURL=useSort.js.map

package/lib/hooks/useSort.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSort.js","names":[],"sources":["../../src/hooks/useSort.ts"],"sourcesContent":["import { useMemo, useState } from 'react';\n\nimport { SortDirection } from '../components/UNSAFE_Table/constants';\n\n/** Values that should never be treated as \"an object to sort one level deeper into\" */\ntype SortLeaf =\n  string | number | boolean | bigint | symbol | null | undefined | Date | readonly unknown[] | ((...args: never[]) => unknown);\n\n/**\n * A sort key for TData: rejects unknown property names (so typos are caught), while still allowing\n * one level of dot-notation into a nested property (e.g. \"kontor.navn\"). Nested properties with dynamic\n * keys (e.g. Record<string, number>) accept any suffix after the dot, since their keys aren't statically known.\n */\nexport type SortKey<TData> = {\n  [K in Extract<keyof TData, string>]: NonNullable<TData[K]> extends SortLeaf\n    ? K\n    : K | `${K}.${Extract<keyof NonNullable<TData[K]>, string>}`;\n}[Extract<keyof TData, string>];\n\nexport type SortValueGetter<TData> = (item: TData, sortKey: SortKey<TData>) => unknown;\n\n/** A comparator function with the same signature as Array.prototype.sort */\nexport type SortComparer<TData> = (a: TData, b: TData) => number;\n\n/** A named sort option, e.g. for a FilterSort dropdown, mapping an option key to a column key + direction. */\nexport interface SortOption<TData> {\n  columnKey: SortKey<TData>;\n  direction?: SortDirection;\n}\n\n/** Decides whether a sortOptions entry matches the current sort state. Default: compareSortOption. */\nexport type SortOptionMatcher<TData> = (\n  option: SortOption<TData>,\n  columnKey: SortKey<TData> | undefined,\n  direction: SortDirection | undefined\n) => boolean;\n\nexport interface SortableHeadCellProps {\n  /** Sort direction, for displaying the current sort state on the column header (e.g. aria-sort) */\n  sortDir?: SortDirection;\n}\n\nexport interface UseSortOptions<TData> {\n  /** The items to sort */\n  data: TData[];\n  /** Key to sort by on mount (uncontrolled mode) */\n  initialSortColumnKey?: SortKey<TData>;\n  /** Sort direction on mount (uncontrolled mode). Default: SortDirection.asc */\n  initialSortDirection?: SortDirection;\n  /** Currently sorted key (controlled mode). When set, the consumer owns the sort state and must update it based on onSortChange. */\n  sortColumnKey?: SortKey<TData>;\n  /** Current sort direction (controlled mode). Default: SortDirection.asc */\n  sortDirection?: SortDirection;\n  /** Disable internal sorting of data, e.g. when sorting happens server-side. requestSort still updates state and calls onSortChange. */\n  disableInternalSort?: boolean;\n  /**\n   * Get the value to sort an item by. Default: reads the sort key as a property from the item, with support for dot-notation paths like \"person.name\".\n   * Memoize this (e.g. with useCallback) if provided inline, otherwise sortedData recomputes on every render.\n   */\n  getSortValue?: SortValueGetter<TData>;\n  /**\n   * Custom comparators per sort key, for keys that need their own ordering (e.g. status ranking). The comparator should sort ascending; direction is applied by the hook.\n   * Memoize this (e.g. with useMemo) if provided inline, otherwise sortedData recomputes on every render.\n   */\n  sorters?: Partial<Record<SortKey<TData>, SortComparer<TData>>>;\n  /** Called whenever the sort changes */\n  onSortChange?: (columnKey: SortKey<TData>, sortDirection: SortDirection) => void;\n  /**\n   * Named sort options (e.g. for a FilterSort dropdown), each mapping an option key to a column key + direction.\n   * When provided, the hook exposes `sortOptionKey` (the option matching the current sort, if any) and\n   * `setSortOption` (set the sort directly from an option's key, e.g. straight from a <select>'s onChange).\n   */\n  sortOptions?: Record<string, SortOption<TData>>;\n  /**\n   * Custom matcher for deciding which sortOptions entry matches the current sort. Default: matches on exact\n   * columnKey, treating a missing direction as SortDirection.asc. Only needed for non-standard matching.\n   */\n  matchSortOption?: SortOptionMatcher<TData>;\n}\n\nexport interface UseSortReturn<TData> {\n  /** The items, sorted by the current sort (or as-is when disableInternalSort is set) */\n  sortedData: TData[];\n  /** The key currently sorted by */\n  sortColumnKey: SortKey<TData> | undefined;\n  /** The current sort direction */\n  sortDirection: SortDirection | undefined;\n  /** Sort by a key. Toggles direction when the key is already sorted. */\n  requestSort: (columnKey: SortKey<TData>) => void;\n  /** Set both sort key and direction directly, without toggling. Useful when a control (e.g. a FilterSort dropdown) maps its own options to a fixed (key, direction) pair. */\n  setSort: (columnKey: SortKey<TData>, direction?: SortDirection) => void;\n  /** Get props for TableHeadCell to display the current sort state (aria-sort). Sorting itself is triggered by the consumer, e.g. via requestSort/onSortChange from a FilterSort control. */\n  getSortProps: (columnKey: SortKey<TData>) => SortableHeadCellProps;\n  /** The sortOptions key matching the current sort state, if any. undefined if sortOptions wasn't provided or none match. */\n  sortOptionKey: string | undefined;\n  /** Set the sort from a sortOptions key, e.g. straight from a <select>'s onChange. No-ops if the key isn't found in sortOptions. */\n  setSortOption: (optionKey: string) => void;\n}\n\ninterface SortState<TData> {\n  columnKey: SortKey<TData>;\n  direction: SortDirection;\n}\n\ntype SortableValue = string | number | boolean | Date | null | undefined;\n\nconst getValueByPath = (item: unknown, path: string): unknown =>\n  path\n    .split('.')\n    .reduce<unknown>(\n      (value, key) => (value !== null && typeof value === 'object' ? (value as Record<string, unknown>)[key] : undefined),\n      item\n    );\n\nconst compareSortValues = (a: SortableValue, b: SortableValue): number => {\n  if (a === null || a === undefined) {\n    return b === null || b === undefined ? 0 : 1;\n  }\n  if (b === null || b === undefined) {\n    return -1;\n  }\n  if (typeof a === 'number' && typeof b === 'number') {\n    return a - b;\n  }\n  if (typeof a === 'boolean' && typeof b === 'boolean') {\n    return Number(a) - Number(b);\n  }\n  if (a instanceof Date && b instanceof Date) {\n    return a.getTime() - b.getTime();\n  }\n  return String(a).localeCompare(String(b), 'nb', { numeric: true, sensitivity: 'base' });\n};\n\nconst sortBy =\n  <TData>(accessor: (item: TData) => SortableValue, direction: SortDirection = SortDirection.asc): SortComparer<TData> =>\n  (a: TData, b: TData): number => {\n    const aValue = accessor(a);\n    const bValue = accessor(b);\n    // null/undefined skal alltid sist, også ved desc\n    if (aValue === null || aValue === undefined || bValue === null || bValue === undefined) {\n      return compareSortValues(aValue, bValue);\n    }\n    const result = compareSortValues(aValue, bValue);\n    return direction === SortDirection.desc ? -result : result;\n  };\n\nconst defaultMatchSortOption = <TData>(\n  option: SortOption<TData>,\n  columnKey: SortKey<TData> | undefined,\n  direction: SortDirection | undefined\n): boolean => option.columnKey === columnKey && (option.direction ?? SortDirection.asc) === (direction ?? SortDirection.asc);\n\n/**\n * Sort state and type-aware sorting for any list (tables, filtered result lists etc.).\n * Strings sort with Norwegian locale and numeric collation, numbers/booleans/Dates sort natively,\n * and null/undefined always sort last. Supports uncontrolled mode (internal state),\n * controlled mode (sortColumnKey/sortDirection props) and server-side sorting (disableInternalSort).\n */\nexport const useSort = <TData>(options: UseSortOptions<TData>): UseSortReturn<TData> => {\n  const {\n    data,\n    initialSortColumnKey,\n    initialSortDirection,\n    sortColumnKey,\n    sortDirection,\n    disableInternalSort,\n    getSortValue,\n    sorters,\n    onSortChange,\n    sortOptions,\n    matchSortOption = defaultMatchSortOption,\n  } = options;\n\n  const [internalSort, setInternalSort] = useState<SortState<TData> | undefined>(() =>\n    initialSortColumnKey ? { columnKey: initialSortColumnKey, direction: initialSortDirection ?? SortDirection.asc } : undefined\n  );\n\n  const isControlled = sortColumnKey !== undefined;\n  const sort: SortState<TData> | undefined = isControlled\n    ? { columnKey: sortColumnKey, direction: sortDirection ?? SortDirection.asc }\n    : internalSort;\n\n  const requestSort = (columnKey: SortKey<TData>): void => {\n    const direction = sort?.columnKey === columnKey && sort.direction === SortDirection.asc ? SortDirection.desc : SortDirection.asc;\n\n    if (!isControlled) {\n      setInternalSort({ columnKey, direction });\n    }\n    onSortChange?.(columnKey, direction);\n  };\n\n  const setSort = (columnKey: SortKey<TData>, direction: SortDirection = SortDirection.asc): void => {\n    if (!isControlled) {\n      setInternalSort({ columnKey, direction });\n    }\n    onSortChange?.(columnKey, direction);\n  };\n\n  const currentSortColumnKey = sort?.columnKey;\n  const currentSortDirection = sort?.direction;\n\n  const sortedData = useMemo(() => {\n    if (!currentSortColumnKey || disableInternalSort) {\n      return data;\n    }\n\n    const customComparer = sorters?.[currentSortColumnKey];\n    const comparer: SortComparer<TData> = customComparer\n      ? (a, b): number => (currentSortDirection === SortDirection.desc ? -customComparer(a, b) : customComparer(a, b))\n      : sortBy(item => (getSortValue ?? getValueByPath)(item, currentSortColumnKey) as SortableValue, currentSortDirection);\n\n    return [...data].sort(comparer);\n  }, [data, currentSortColumnKey, currentSortDirection, disableInternalSort, getSortValue, sorters]);\n\n  const getSortProps = (columnKey: SortKey<TData>): SortableHeadCellProps => ({\n    sortDir: sort?.columnKey === columnKey ? sort.direction : undefined,\n  });\n\n  const sortOptionKey = sortOptions\n    ? Object.entries(sortOptions).find(([, option]) => matchSortOption(option, currentSortColumnKey, currentSortDirection))?.[0]\n    : undefined;\n\n  const setSortOption = (optionKey: string): void => {\n    const option = sortOptions?.[optionKey];\n    if (option) {\n      setSort(option.columnKey, option.direction);\n    }\n  };\n\n  return {\n    sortedData,\n    sortColumnKey: sort?.columnKey,\n    sortDirection: sort?.direction,\n    requestSort,\n    setSort,\n    getSortProps,\n    sortOptionKey,\n    setSortOption,\n  };\n};\n"],"mappings":"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"}