@primer/react 38.0.0-rc.2 → 38.0.0-rc.3

package/lib/DataTable/Table.module.css.js

@@ -1,7 +0,0 @@
-'use strict';
-
-require('./Table-87f4043f.css');
-
-var classes = {"TableContainer":"prc-DataTable-TableContainer-Gm3sY","TableTitle":"prc-DataTable-TableTitle-Q7qQd","TableSubtitle":"prc-DataTable-TableSubtitle-DEyv-","TableActions":"prc-DataTable-TableActions-IEEii","TableDivider":"prc-DataTable-TableDivider-OsO1X","TableOverflowWrapper":"prc-DataTable-TableOverflowWrapper-PFgsy","Table":"prc-DataTable-Table-qYfrL","TableCell":"prc-DataTable-TableCell-dVc-6","TableHeader":"prc-DataTable-TableHeader-CRPoj","TableSortButton":"prc-DataTable-TableSortButton-LnQla","TableHead":"prc-DataTable-TableHead-eOrJU","TableRow":"prc-DataTable-TableRow-1vLX7","TableBody":"prc-DataTable-TableBody-p56SS","TableCellSkeletonItem":"prc-DataTable-TableCellSkeletonItem-jFqti","TableCellSkeleton":"prc-DataTable-TableCellSkeleton-ge8WK","TableSortIcon":"prc-DataTable-TableSortIcon-2h30n","TableSortIcon--ascending":"prc-DataTable-TableSortIcon--ascending-H9-sb","TableSortIcon--descending":"prc-DataTable-TableSortIcon--descending-7-zjV","TableCellSkeletonItems":"prc-DataTable-TableCellSkeletonItems-XEGdI"};
-
-module.exports = classes;

package/lib/DataTable/__tests__/sorting.test.d.ts

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

package/lib/DataTable/column.d.ts

@@ -1,62 +0,0 @@
-import type { ObjectPaths } from './utils';
-import type { UniqueRow } from './row';
-import type { SortStrategy, CustomSortStrategy } from './sorting';
-export type ColumnWidth = 'grow' | 'growCollapse' | 'auto' | React.CSSProperties['width'];
-export type CellAlignment = 'start' | 'end' | undefined;
-export interface Column<Data extends UniqueRow> {
-    id?: string;
-    /**
-     * The horizontal alignment of the column's content
-     */
-    align?: CellAlignment;
-    /**
-     * Provide the name of the column. This will be rendered as a table header
-     * within the table itself
-     */
-    header: string | (() => React.ReactNode);
-    /**
-     * Optionally provide a field to render for this column. This may be the key
-     * of the object or a string that accesses nested objects through `.`. For
-     * example: `field: a.b.c`
-     *
-     * Alternatively, you may provide a `renderCell` for this column to render the
-     * field in a row
-     */
-    field?: ObjectPaths<Data>;
-    /**
-     * The maximum width the column can grow to
-     */
-    maxWidth?: React.CSSProperties['maxWidth'];
-    /**
-     * The minimum width the column can shrink to
-     */
-    minWidth?: React.CSSProperties['minWidth'];
-    /**
-     * Provide a custom component or render prop to render the data for this
-     * column in a row
-     */
-    renderCell?: (data: Data) => React.ReactNode;
-    /**
-     * Specify if the value of this column for a row should be treated as a row
-     * header
-     */
-    rowHeader?: boolean;
-    /**
-     * Specify if the table should sort by this column and, if applicable, a
-     * specific sort strategy or custom sort strategy
-     */
-    sortBy?: boolean | SortStrategy | CustomSortStrategy<Data>;
-    /**
-     * Controls the width of the column.
-     * - 'grow': Stretch to fill available space, and min width is the width of the widest cell in the column
-     * - 'growCollapse': Stretch to fill available space or shrink to fit in the available space. Allows the column to shrink smaller than the cell content's width.
-     * - 'auto': The column is the width of it’s widest cell. Not intended for use with columns who’s content length varies a lot because a layout shift will occur when the content changes
-     * - explicit width: Will be exactly that width and will not grow or shrink to fill the parent
-     * @default 'grow'
-     */
-    width?: ColumnWidth;
-}
-export declare function createColumnHelper<T extends UniqueRow>(): {
-    column: (column: Column<T>) => Column<T>;
-};
-//# sourceMappingURL=column.d.ts.map

package/lib/DataTable/column.js

@@ -1,16 +0,0 @@
-'use strict';
-
-function createColumnHelper() {
-  function column(column) {
-    var _column$id;
-    return {
-      ...column,
-      id: (_column$id = column.id) !== null && _column$id !== void 0 ? _column$id : column.field
-    };
-  }
-  return {
-    column
-  };
-}
-
-exports.createColumnHelper = createColumnHelper;

package/lib/DataTable/index.d.ts

@@ -1,33 +0,0 @@
-import { DataTable } from './DataTable';
-import { ErrorDialog } from './ErrorDialog';
-import { TableHead, TableBody, TableRow, TableHeader, TableCell, TableCellPlaceholder, TableContainer, TableSubtitle, TableActions, TableDivider, TableSkeleton } from './Table';
-import { Pagination } from './Pagination';
-declare const Table: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>, "ref"> & {
-    'aria-describedby'?: string;
-    'aria-labelledby'?: string;
-    gridTemplateColumns?: React.CSSProperties["gridTemplateColumns"];
-    cellPadding?: "condensed" | "normal" | "spacious";
-} & import("react").RefAttributes<HTMLTableElement>> & {
-    Container: typeof TableContainer;
-    Title: import("react").ForwardRefExoticComponent<Omit<import("./Table").TableTitleProps, "ref"> & import("react").RefAttributes<HTMLElement>>;
-    Subtitle: typeof TableSubtitle;
-    Actions: typeof TableActions;
-    Divider: typeof TableDivider;
-    Skeleton: typeof TableSkeleton;
-    Head: typeof TableHead;
-    Body: typeof TableBody;
-    Header: typeof TableHeader;
-    Row: typeof TableRow;
-    Cell: typeof TableCell;
-    CellPlaceholder: typeof TableCellPlaceholder;
-    Pagination: typeof Pagination;
-    ErrorDialog: typeof ErrorDialog;
-};
-export { DataTable, Table };
-export type { DataTableProps } from './DataTable';
-export type { TableProps, TableHeadProps, TableBodyProps, TableRowProps, TableHeaderProps, TableCellProps, TableContainerProps, TableTitleProps, TableSubtitleProps, TableActionsProps, TableSkeletonProps, } from './Table';
-export { createColumnHelper } from './column';
-export type { Column, CellAlignment, ColumnWidth } from './column';
-export type { UniqueRow } from './row';
-export type { ObjectPaths } from './utils';
-//# sourceMappingURL=index.d.ts.map

package/lib/DataTable/index.js

@@ -1,24 +0,0 @@
-'use strict';
-
-var ErrorDialog = require('./ErrorDialog.js');
-var Table$1 = require('./Table.js');
-var Pagination = require('./Pagination.js');
-
-const Table = Object.assign(Table$1.Table, {
-  Container: Table$1.TableContainer,
-  Title: Table$1.TableTitle,
-  Subtitle: Table$1.TableSubtitle,
-  Actions: Table$1.TableActions,
-  Divider: Table$1.TableDivider,
-  Skeleton: Table$1.TableSkeleton,
-  Head: Table$1.TableHead,
-  Body: Table$1.TableBody,
-  Header: Table$1.TableHeader,
-  Row: Table$1.TableRow,
-  Cell: Table$1.TableCell,
-  CellPlaceholder: Table$1.TableCellPlaceholder,
-  Pagination: Pagination.Pagination,
-  ErrorDialog: ErrorDialog.ErrorDialog
-});
-
-exports.Table = Table;

package/lib/DataTable/row.d.ts

@@ -1,4 +0,0 @@
-export interface UniqueRow {
-    id: string | number;
-}
-//# sourceMappingURL=row.d.ts.map

package/lib/DataTable/sorting.d.ts

@@ -1,32 +0,0 @@
-export type SortDirection = 'ASC' | 'DESC' | 'NONE';
-export declare const SortDirection: {
-    [Key in SortDirection]: `${Key}`;
-};
-export declare const DEFAULT_SORT_DIRECTION: "ASC";
-export declare function transition(direction: Exclude<SortDirection, 'NONE'>): Exclude<SortDirection, 'NONE'>;
-/**
- * A sort strategy for comparing any two values
- */
-export declare function basic<T>(a: T, b: T): 1 | 0 | -1;
-/**
- * A sort strategy for comparing two `Date` values. Also includes support for
- * values from `Date.now()`
- */
-export declare function datetime(a: Date | number, b: Date | number): number;
-/**
- * Compare two numbers using alphanumeric, or natural order, sorting. This
- * sorting function breaks up the inputs into groups of text and numbers and
- * compares the different sub-groups of each to determine the order of a set of
- * strings
- *
- * @see https://en.wikipedia.org/wiki/Natural_sort_order
- */
-export declare function alphanumeric(inputA: string, inputB: string): number;
-export declare const strategies: {
-    alphanumeric: typeof alphanumeric;
-    basic: typeof basic;
-    datetime: typeof datetime;
-};
-export type SortStrategy = keyof typeof strategies;
-export type CustomSortStrategy<T> = (a: T, b: T) => number;
-//# sourceMappingURL=sorting.d.ts.map

package/lib/DataTable/sorting.js

@@ -1,133 +0,0 @@
-'use strict';
-
-// The directions in which a column can be sorted
-// Note: if a table is sorted, one column _must_ have a direction other than
-// NONE
-
-// A mapping of names to SortDirection
-const SortDirection = {
-  ASC: 'ASC',
-  DESC: 'DESC',
-  NONE: 'NONE'
-};
-
-// The default sort direction for a column going from NONE to sorted
-const DEFAULT_SORT_DIRECTION = SortDirection.ASC;
-
-// Transition the given sort direction to the next direction
-// Note: we can only cycle between ASC <-> DESC, NONE is not supported
-function transition(direction) {
-  if (direction === SortDirection.ASC) {
-    return SortDirection.DESC;
-  }
-  return SortDirection.ASC;
-}
-
-// ----------------------------------------------------------------------------
-// Sort strategies
-// ----------------------------------------------------------------------------
-
-/**
- * A sort strategy for comparing any two values
- */
-function basic(a, b) {
-  return a === b ? 0 : a < b ? -1 : 1;
-}
-
-/**
- * A sort strategy for comparing two `Date` values. Also includes support for
- * values from `Date.now()`
- */
-function datetime(a, b) {
-  const timeA = a instanceof Date ? a.getTime() : a;
-  const timeB = b instanceof Date ? b.getTime() : b;
-  return timeA > timeB ? 1 : timeA < timeB ? -1 : 0;
-}
-
-/**
- * Compare two numbers using alphanumeric, or natural order, sorting. This
- * sorting function breaks up the inputs into groups of text and numbers and
- * compares the different sub-groups of each to determine the order of a set of
- * strings
- *
- * @see https://en.wikipedia.org/wiki/Natural_sort_order
- */
-function alphanumeric(inputA, inputB) {
-  const groupsA = getAlphaNumericGroups(inputA);
-  const groupsB = getAlphaNumericGroups(inputB);
-  while (groupsA.length !== 0 && groupsB.length !== 0) {
-    const a = groupsA.shift();
-    const b = groupsB.shift();
-
-    // If the two groups are equal, move on to the next set of groups
-    if (a === b) {
-      continue;
-    } else if (typeof a === 'string' && typeof b === 'string') {
-      // If both groups are strings, compare them using the current locale
-      return a.localeCompare(b);
-    } else if (typeof a === 'number' && typeof b === 'number') {
-      // If both groups are numbers, compare them numerically
-      return a > b ? 1 : -1;
-    } else if (typeof a === 'number' && typeof b === 'string') {
-      // Sort numbers before strings
-      return -1;
-    } else if (typeof a === 'string' && typeof b === 'number') {
-      // Sort numbers before strings
-      return 1;
-    } else if (a === undefined || b === undefined) {
-      // If either group is undefined, break out of the loop. The input with the
-      // fewest number of groups will be ordered first
-      break;
-    }
-  }
-
-  // If all else is equal, the string with the fewest number of "groups" is
-  // ordered before the other string
-  return groupsA.length > groupsB.length ? 1 : -1;
-}
-
-/**
- * Break up the given input string into groups of text and numbers
- */
-function getAlphaNumericGroups(input) {
-  const groups = [];
-  let i = 0;
-  while (i < input.length) {
-    let group = input[i];
-    if (isNumeric(group)) {
-      while (i + 1 < input.length && isNumeric(input[i + 1])) {
-        group = group + input[i + 1];
-        i++;
-      }
-      groups.push(parseInt(group, 10));
-    } else {
-      while (i + 1 < input.length && !isNumeric(input[i + 1])) {
-        group = group + input[i + 1];
-        i++;
-      }
-      groups.push(group);
-    }
-    i++;
-  }
-  return groups;
-}
-
-/**
- * Determine if the given value is a number
- */
-function isNumeric(value) {
-  return !Number.isNaN(parseInt(value, 10));
-}
-const strategies = {
-  alphanumeric,
-  basic,
-  datetime
-};
-
-exports.DEFAULT_SORT_DIRECTION = DEFAULT_SORT_DIRECTION;
-exports.SortDirection = SortDirection;
-exports.alphanumeric = alphanumeric;
-exports.basic = basic;
-exports.datetime = datetime;
-exports.strategies = strategies;
-exports.transition = transition;

package/lib/DataTable/storyHelpers.d.ts

@@ -1,4 +0,0 @@
-import type { InputType } from 'storybook/internal/csf';
-export type ColWidthArgTypes = Record<string, string>;
-export declare const getColumnWidthArgTypes: (colCount: number) => InputType;
-//# sourceMappingURL=storyHelpers.d.ts.map

package/lib/DataTable/storybook/data.d.ts

@@ -1,41 +0,0 @@
-interface Repo {
-    id: number;
-    name: string;
-    type: 'public' | 'internal';
-    updatedAt: number;
-    securityFeatures: {
-        dependabot: Array<string>;
-        codeScanning: Array<string>;
-    };
-}
-export declare const repos: Array<Repo>;
-type SortOptions = {
-    sort: 'name' | 'updatedAt';
-    direction: 'asc' | 'desc';
-};
-type PaginationOptions = {
-    page: number;
-    perPage: number;
-};
-type ListRepoOptions = Partial<SortOptions> & Partial<PaginationOptions>;
-export declare function fetchRepos({ sort, direction, page, perPage }?: ListRepoOptions): Promise<Array<Repo>>;
-export declare function fetchRepoPageInfo(perPage: number): Promise<{
-    totalCount: number;
-    totalPages: number;
-}>;
-type Result<T> = {
-    loading: boolean;
-    error: Error | null;
-    data: T | null;
-};
-export declare function useQuery<T>(queryKey: string | Array<string | number>, queryFn: ({ signal }: {
-    signal: AbortSignal;
-}) => Promise<T>): Result<T>;
-export declare function useFlakeyQuery<T>({ queryKey, queryFn, }: {
-    queryKey: string | Array<string | number>;
-    queryFn: ({ signal }: {
-        signal: AbortSignal;
-    }) => Promise<T>;
-}): Result<T>;
-export {};
-//# sourceMappingURL=data.d.ts.map

package/lib/DataTable/useTable.d.ts

@@ -1,42 +0,0 @@
-import type { Column } from './column';
-import type { UniqueRow } from './row';
-import { SortDirection } from './sorting';
-interface TableConfig<Data extends UniqueRow> {
-    columns: Array<Column<Data>>;
-    data: Array<Data>;
-    initialSortColumn?: string | number;
-    initialSortDirection?: Exclude<SortDirection, 'NONE'>;
-    getRowId: (rowData: Data) => string | number;
-}
-interface Table<Data extends UniqueRow> {
-    headers: Array<Header<Data>>;
-    rows: Array<Row<Data>>;
-    actions: {
-        sortBy: (header: Header<Data>) => void;
-    };
-    gridTemplateColumns: React.CSSProperties['gridTemplateColumns'];
-}
-interface Header<Data extends UniqueRow> {
-    id: string;
-    column: Column<Data>;
-    isSortable: () => boolean;
-    getSortDirection: () => SortDirection | Exclude<SortDirection, 'NONE'>;
-}
-interface Row<Data extends UniqueRow> {
-    id: string | number;
-    getCells: () => Array<Cell<Data>>;
-    getValue: () => Data;
-}
-interface Cell<Data extends UniqueRow> {
-    id: string;
-    column: Column<Data>;
-    getValue: () => Data[keyof Data];
-    rowHeader: boolean;
-}
-export declare function useTable<Data extends UniqueRow>({ columns, data, initialSortColumn, initialSortDirection, getRowId, }: TableConfig<Data>): Table<Data>;
-export declare function useTableLayout<Data extends UniqueRow>(columns: Array<Column<Data>>): {
-    gridTemplateColumns: string;
-};
-export declare function getGridTemplateFromColumns<Data extends UniqueRow>(columns: Array<Column<Data>>): string[];
-export {};
-//# sourceMappingURL=useTable.d.ts.map