@gridkitjs/core 0.0.1 → 0.2.0

package/dist/index.d.ts

@@ -23,11 +23,30 @@ type FieldPath<Row> = {
 type ColumnType = "dateTime" | "date" | "time" | "number" | "string" | "boolean" | "decimal" | "currency" | "percent";
 type ColumnAlignment = "left" | "center" | "right";
 /**
- * @typeParam Header - What a header renders to. This package is
+ * What `cellTemplate` receives. An object rather than positional arguments so
+ * that a later addition — a sort state, whether the row is selected — is not a
+ * breaking change to every template already written.
+ */
+interface CellTemplateContext<Row> {
+    /**
+     * This cell's value, read off the column's field path. `unknown` because a
+     * dotted path's type cannot be recovered here; a template narrows it.
+     */
+    value: unknown;
+    /** The whole row, for a template that needs a sibling field. */
+    row: Row;
+    /**
+     * Position among the rows as rendered. Once paging exists this is the index
+     * within the page; an index into the whole dataset would be a second field.
+     */
+    rowIndex: number;
+}
+/**
+ * @typeParam Node - What a header or cell renders to. This package is
  * framework-agnostic so it defaults to `string`; `@gridkitjs/react` binds it to
- * `ReactNode` so a header callback can return JSX.
+ * `ReactNode` so a template can return JSX.
  */
-interface ColumnDefinition<Row, Header = string> {
+interface ColumnDefinition<Row, Node = string> {
     /**
      * Path to this cell's value: a key of `Row`, or `"Parent.Child"` for a leaf
      * one level inside a nested object. Any string still compiles — the union
@@ -41,7 +60,13 @@ interface ColumnDefinition<Row, Header = string> {
      */
     id?: string;
     /** Header content, or a function returning it at render time. */
-    header?: Header | (() => Header) | undefined;
+    headerTemplate?: Node | (() => Node) | undefined;
+    /**
+     * Renders this column's cells in place of the raw value at `field`. The
+     * value is still resolved and handed over, so a template that only formats
+     * it never repeats the field path.
+     */
+    cellTemplate?: ((context: CellTemplateContext<Row>) => Node) | undefined;
     /**
      * The value type of this column's cells. This package is framework-agnostic so it
      * defaults to `string`;
@@ -63,6 +88,11 @@ interface ColumnDefinition<Row, Header = string> {
     maxWidth?: number;
     /** Whether this column can be resized, overriding the grid-level default. */
     resizable?: boolean;
+    /**
+     * Whether this column can be dragged to a new position, overriding the
+     * grid-level default. A column that cannot move can still be moved past.
+     */
+    reorderable?: boolean;
 }
 /**
  * Widths the user has changed, keyed by column id. Holding only what changed —
@@ -89,14 +119,16 @@ interface ColumnResolveOptions {
     sizes?: Partial<ColumnSizeDefaults> | undefined;
     /** Whether columns are resizable, unless a column says otherwise. */
     resizable?: boolean | undefined;
+    /** Whether columns are reorderable, unless a column says otherwise. */
+    reorderable?: boolean | undefined;
 }
 /**
  * A column paired with everything it takes to render it. Each field is a
  * decision made once here rather than in each adapter, so a second framework
  * binding renders identically without repeating the logic.
  */
-interface ResolvedColumn<Row, Header = string> {
-    column: ColumnDefinition<Row, Header>;
+interface ResolvedColumn<Row, Node = string> {
+    column: ColumnDefinition<Row, Node>;
     id: string;
     width: number;
     /**
@@ -106,13 +138,15 @@ interface ResolvedColumn<Row, Header = string> {
      */
     sized: boolean;
     /**
-     * What the header shows: the column's own `header`, or a label read off the
-     * field path. `string` is in the union because that fallback is text
-     * whatever `Header` is bound to.
+     * What the header shows: the column's own `headerTemplate`, or a label read
+     * off the field path. `string` is in the union because that fallback is text
+     * whatever `Node` is bound to.
      */
-    label: Header | string;
+    label: Node | string;
     /** Whether this column can be resized, after the grid-level default. */
     resizable: boolean;
+    /** Whether this column can be dragged, after the grid-level default. */
+    reorderable: boolean;
     /** How this column's cells align, after falling back to its type. */
     alignment: ColumnAlignment;
 }
@@ -136,6 +170,25 @@ interface ColumnResizeEvent {
     readonly sizing: ColumnSizingState;
     readonly phase: "move" | "end";
 }
+/**
+ * Column ids in the order they render. It need not list every column: one
+ * absent from it keeps its position among the definitions and follows those
+ * that are listed.
+ */
+type ColumnOrderState = readonly string[];
+/**
+ * Which side of a column a drop lands on, normalised away by
+ * `resolveDropBefore` so it reaches no state.
+ */
+type DropSide = "before" | "after";
+/**
+ * Reports a user reorder. Unlike a resize there is no `"move"` phase — the
+ * order does not change until the drop.
+ */
+interface ColumnOrderEvent {
+    readonly columnId: string;
+    readonly order: ColumnOrderState;
+}
 
 /**
  * How a column of `type` aligns by default. Numeric types align right so that
@@ -159,11 +212,11 @@ declare function defineColumnsFromRows<Row>(rows: readonly Row[]): readonly Colu
  */
 declare function getColumnId<Row>(column: ColumnDefinition<Row, unknown>): string;
 /**
- * What a column's header shows: its own `header`, called first if it is a
- * function, or else a label read off the field path — `"Application.Id"`
+ * What a column's header shows: its own `headerTemplate`, called first if it is
+ * a function, or else a label read off the field path — `"Application.Id"`
  * reading as `"Application Id"`.
  */
-declare function resolveColumnLabel<Row, Header>(column: ColumnDefinition<Row, Header>): Header | string;
+declare function resolveColumnLabel<Row, Node>(column: ColumnDefinition<Row, Node>): Node | string;
 /**
  * Accesses a value at a dotted path, e.g. `foo.bar.baz`.
  *
@@ -173,6 +226,40 @@ declare function resolveColumnLabel<Row, Header>(column: ColumnDefinition<Row, H
  */
 declare function accessDotted(obj: unknown, path: string): unknown;
 
+/**
+ * Puts `columns` in the order `order` gives. Ids it lists come first, in that
+ * order; columns it omits keep their position among the definitions and
+ * follow. Ids naming no column are ignored.
+ *
+ * Tolerating both gaps is what lets a stored order outlive the column list it
+ * was made against.
+ */
+declare function applyColumnOrder<Row, Node>(columns: readonly ColumnDefinition<Row, Node>[], order: ColumnOrderState): readonly ColumnDefinition<Row, Node>[];
+/**
+ * The order with `movedId` lifted out and put back in front of `beforeId`, or
+ * at the end when that is `null`.
+ *
+ * Returns `orderedIds` itself when the move changes nothing, so callers can
+ * treat an unchanged reference as "no move happened".
+ */
+declare function moveColumnBefore(orderedIds: ColumnOrderState, movedId: string, beforeId: string | null): ColumnOrderState;
+/**
+ * Whether moving `movedId` in front of `beforeId` would rearrange anything, so
+ * that a drop indicator promises exactly the moves that happen.
+ *
+ * Defined against `moveColumnBefore` rather than restating its conditions, so
+ * the two cannot disagree about what a no-op is.
+ */
+declare function movesColumn(orderedIds: ColumnOrderState, movedId: string, beforeId: string | null): boolean;
+/**
+ * The id a drop on `side` of `targetId` lands in front of, which is `null`
+ * past the last column.
+ *
+ * "After C" and "before D" name the same gap, so collapsing both to one id
+ * keeps a drop target a single nullable string.
+ */
+declare function resolveDropBefore(orderedIds: ColumnOrderState, targetId: string, side: DropSide): string | null;
+
 /**
  * Applied to any column that does not size itself. The minimum is a width a
  * header stays legible at rather than a measured value — a column dragged
@@ -197,8 +284,8 @@ declare function clampColumnWidth(width: number, constraints: ColumnConstraints)
  * The sizing state winning means a user's drag outlives a re-render; a column
  * absent from it still tracks a `width` edited in the definition.
  */
-declare function resolveColumnWidths<Row, Header>(columns: readonly ColumnDefinition<Row, Header>[], sizing: ColumnSizingState, options?: ColumnResolveOptions): readonly ResolvedColumn<Row, Header>[];
-declare function totalColumnWidth<Row, Header>(resolved: readonly ResolvedColumn<Row, Header>[]): number;
+declare function resolveColumnWidths<Row, Node>(columns: readonly ColumnDefinition<Row, Node>[], sizing: ColumnSizingState, options?: ColumnResolveOptions): readonly ResolvedColumn<Row, Node>[];
+declare function totalColumnWidth<Row, Node>(resolved: readonly ResolvedColumn<Row, Node>[]): number;
 /**
  * Opens a resize. The session captures its constraints and starting point up
  * front, so applying a pointer position later is arithmetic on numbers alone —
@@ -220,7 +307,7 @@ declare function applyColumnResize(session: ColumnResizeSession, position: numbe
  * them. Columns the user has sized are left at that width and the rest share
  * what is left, so dragging one column does not rubber-band it back.
  */
-declare function fitColumnsToWidth<Row, Header>(resolved: readonly ResolvedColumn<Row, Header>[], availableWidth: number, defaults?: Partial<ColumnSizeDefaults>): readonly ResolvedColumn<Row, Header>[];
+declare function fitColumnsToWidth<Row, Node>(resolved: readonly ResolvedColumn<Row, Node>[], availableWidth: number, defaults?: Partial<ColumnSizeDefaults>): readonly ResolvedColumn<Row, Node>[];
 /**
  * The width a column needs to show `measuredWidth` of content.
  *
@@ -229,4 +316,4 @@ declare function fitColumnsToWidth<Row, Header>(resolved: readonly ResolvedColum
  */
 declare function sizeColumnToContent(measuredWidth: number, constraints: ColumnConstraints, padding?: number): number;
 
-export { type ColumnAlignment, type ColumnConstraints, type ColumnDefinition, type ColumnResizeEvent, type ColumnResizeSession, type ColumnResolveOptions, type ColumnSizeDefaults, type ColumnSizingState, type ColumnType, DEFAULT_COLUMN_SIZES, type FieldPath, KEYBOARD_STEP, type ResolvedColumn, accessDotted, alignmentForType, applyColumnResize, beginColumnResize, clampColumnWidth, defineColumnsFromRows, fitColumnsToWidth, getColumnId, resolveColumnConstraints, resolveColumnLabel, resolveColumnWidths, sizeColumnToContent, totalColumnWidth };
+export { type CellTemplateContext, type ColumnAlignment, type ColumnConstraints, type ColumnDefinition, type ColumnOrderEvent, type ColumnOrderState, type ColumnResizeEvent, type ColumnResizeSession, type ColumnResolveOptions, type ColumnSizeDefaults, type ColumnSizingState, type ColumnType, DEFAULT_COLUMN_SIZES, type DropSide, type FieldPath, KEYBOARD_STEP, type ResolvedColumn, accessDotted, alignmentForType, applyColumnOrder, applyColumnResize, beginColumnResize, clampColumnWidth, defineColumnsFromRows, fitColumnsToWidth, getColumnId, moveColumnBefore, movesColumn, resolveColumnConstraints, resolveColumnLabel, resolveColumnWidths, resolveDropBefore, sizeColumnToContent, totalColumnWidth };

package/dist/index.js

@@ -61,16 +61,53 @@ function getColumnId(column) {
   return column.id ?? column.field;
 }
 function resolveColumnLabel(column) {
-  const { header } = column;
-  if (header === void 0) {
+  const { headerTemplate } = column;
+  if (headerTemplate === void 0) {
     return column.field.split(".").join(" ");
   }
-  return typeof header === "function" ? header() : header;
+  return typeof headerTemplate === "function" ? headerTemplate() : headerTemplate;
 }
 function accessDotted(obj, path) {
   return path.split(".").reduce((value, key) => isNested(value) ? value[key] : void 0, obj);
 }
 
+// src/util/ordering.ts
+function applyColumnOrder(columns, order) {
+  if (order.length === 0) {
+    return columns;
+  }
+  const byId = new Map(columns.map((column) => [getColumnId(column), column]));
+  const listed = order.map((id) => byId.get(id)).filter((column) => column !== void 0);
+  const taken = new Set(listed.map((column) => getColumnId(column)));
+  return [
+    ...listed,
+    ...columns.filter((column) => !taken.has(getColumnId(column)))
+  ];
+}
+function moveColumnBefore(orderedIds, movedId, beforeId) {
+  if (movedId === beforeId || !orderedIds.includes(movedId)) {
+    return orderedIds;
+  }
+  const without = orderedIds.filter((id) => id !== movedId);
+  const target = beforeId === null ? without.length : without.indexOf(beforeId);
+  if (target === -1) {
+    return orderedIds;
+  }
+  const next = [...without];
+  next.splice(target, 0, movedId);
+  return next.every((id, index) => id === orderedIds[index]) ? orderedIds : next;
+}
+function movesColumn(orderedIds, movedId, beforeId) {
+  return moveColumnBefore(orderedIds, movedId, beforeId) !== orderedIds;
+}
+function resolveDropBefore(orderedIds, targetId, side) {
+  if (side === "before") {
+    return targetId;
+  }
+  const index = orderedIds.indexOf(targetId);
+  return index === -1 ? null : orderedIds[index + 1] ?? null;
+}
+
 // src/util/sizing.ts
 var DEFAULT_COLUMN_SIZES = {
   width: 150,
@@ -106,6 +143,7 @@ function resolveColumnWidths(columns, sizing, options) {
       ),
       label: resolveColumnLabel(column),
       resizable: column.resizable ?? options?.resizable ?? false,
+      reorderable: column.reorderable ?? options?.reorderable ?? false,
       alignment: column.alignment ?? alignmentForType(column.type ?? "string")
     };
   });
@@ -180,15 +218,19 @@ export {
   KEYBOARD_STEP,
   accessDotted,
   alignmentForType,
+  applyColumnOrder,
   applyColumnResize,
   beginColumnResize,
   clampColumnWidth,
   defineColumnsFromRows,
   fitColumnsToWidth,
   getColumnId,
+  moveColumnBefore,
+  movesColumn,
   resolveColumnConstraints,
   resolveColumnLabel,
   resolveColumnWidths,
+  resolveDropBefore,
   sizeColumnToContent,
   totalColumnWidth
 };

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/util/grid.ts","../src/util/sizing.ts"],"sourcesContent":["import type { ColumnAlignment, ColumnDefinition, ColumnType } from \"../types\";\n\n/**\n * Narrows to a value worth drilling into. Mirrors the `LeafValue` union in\n * `../types`: arrays and `Date`s are cell values rather than groups of\n * columns, and `null` cannot be introspected. Keep the two in sync.\n */\nfunction isNested(value: unknown): value is Record<string, unknown> {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    !Array.isArray(value) &&\n    !(value instanceof Date)\n  );\n}\n\nfunction getType(value: unknown): ColumnType {\n  if (value instanceof Date) return \"dateTime\";\n  if (typeof value === \"string\") return \"string\";\n  if (typeof value === \"number\") return \"number\";\n  if (typeof value === \"boolean\") return \"boolean\";\n  if (typeof value === \"bigint\") return \"number\";\n  if (typeof value === \"symbol\") return \"string\";\n  return \"string\";\n}\n\n/**\n * How a column of `type` aligns by default. Numeric types align right so that\n * their digits line up by place value; everything else reads from the left.\n */\nexport function alignmentForType(type: ColumnType): ColumnAlignment {\n  switch (type) {\n    case \"number\":\n    case \"decimal\":\n    case \"currency\":\n    case \"percent\":\n      return \"right\";\n    default:\n      return \"left\";\n  }\n}\n\nfunction getAlignment(value: unknown): ColumnAlignment {\n  return alignmentForType(getType(value));\n}\n\n/**\n * Derives one column per field across `rows`, in the order each field is first\n * seen — so a key that only appears in a later row still gets a column,\n * appended at the end. Nested objects contribute their non-object properties\n * as `\"Parent.Child\"`; anything deeper is skipped, as is the nested object\n * itself.\n *\n * Order follows `Object.entries`, which lists integer-like keys first\n * regardless of the order they were written in.\n */\nexport function defineColumnsFromRows<Row>(\n  rows: readonly Row[],\n): readonly ColumnDefinition<Row>[] {\n  const columns: ColumnDefinition<Row>[] = [];\n  const seen = new Set<string>();\n\n  function add(field: string, value: unknown): void {\n    if (seen.has(field)) {\n      return;\n    }\n    seen.add(field);\n    columns.push({\n      field,\n      type: getType(value),\n      alignment: getAlignment(value),\n    });\n  }\n\n  for (const row of rows) {\n    if (!isNested(row)) {\n      continue;\n    }\n    for (const [key, value] of Object.entries(row)) {\n      if (!isNested(value)) {\n        add(key, value);\n        continue;\n      }\n      for (const [nestedKey, nestedValue] of Object.entries(value)) {\n        if (!isNested(nestedValue)) {\n          add(`${key}.${nestedKey}`, nestedValue);\n        }\n      }\n    }\n  }\n\n  return columns;\n}\n\n/**\n * The key state about a column is stored under, and the key it renders with.\n * Every such lookup goes through here so the two can never disagree.\n */\nexport function getColumnId<Row>(\n  column: ColumnDefinition<Row, unknown>,\n): string {\n  return column.id ?? column.field;\n}\n\n/**\n * What a column's header shows: its own `header`, called first if it is a\n * function, or else a label read off the field path — `\"Application.Id\"`\n * reading as `\"Application Id\"`.\n */\nexport function resolveColumnLabel<Row, Header>(\n  column: ColumnDefinition<Row, Header>,\n): Header | string {\n  const { header } = column;\n  if (header === undefined) {\n    return column.field.split(\".\").join(\" \");\n  }\n  // `Header` is open, so it could itself be a function type and the `typeof`\n  // check cannot narrow on its own. A header that is callable is the lazy\n  // form by definition — no adapter binds `Header` to a function.\n  return typeof header === \"function\" ? (header as () => Header)() : header;\n}\n\n/**\n * Accesses a value at a dotted path, e.g. `foo.bar.baz`.\n *\n * @param obj The object to access\n * @param path Path to the value, e.g. `\"foo.bar\"`\n * @returns The value at `path`, or `undefined` if it doesn't exist\n */\nexport function accessDotted(obj: unknown, path: string): unknown {\n  return path\n    .split(\".\")\n    .reduce((value, key) => (isNested(value) ? value[key] : undefined), obj);\n}\n","import type {\n  ColumnConstraints,\n  ColumnDefinition,\n  ColumnResizeSession,\n  ColumnResolveOptions,\n  ColumnSizeDefaults,\n  ColumnSizingState,\n  ResolvedColumn,\n} from \"../types\";\nimport { alignmentForType, getColumnId, resolveColumnLabel } from \"./grid\";\n\n/**\n * Applied to any column that does not size itself. The minimum is a width a\n * header stays legible at rather than a measured value — a column dragged\n * narrower than this reads as a rendering fault.\n */\nexport const DEFAULT_COLUMN_SIZES: ColumnSizeDefaults = {\n  width: 150,\n  minWidth: 40,\n  maxWidth: Number.POSITIVE_INFINITY,\n};\n\n/** How far one arrow key press moves a column edge. */\nexport const KEYBOARD_STEP = 10;\n\nfunction withDefaults(\n  defaults?: Partial<ColumnSizeDefaults>,\n): ColumnSizeDefaults {\n  return { ...DEFAULT_COLUMN_SIZES, ...defaults };\n}\n\n/**\n * The bounds `column` may be sized between. Resolved in one place so that a\n * drag, a clamp and an auto-fit cannot disagree about a column's limits.\n */\nexport function resolveColumnConstraints<Row>(\n  column: ColumnDefinition<Row, unknown>,\n  defaults?: Partial<ColumnSizeDefaults>,\n): ColumnConstraints {\n  const resolved = withDefaults(defaults);\n  return {\n    minWidth: column.minWidth ?? resolved.minWidth,\n    maxWidth: column.maxWidth ?? resolved.maxWidth,\n  };\n}\n\n/** Holds `width` within `constraints`. */\nexport function clampColumnWidth(\n  width: number,\n  constraints: ColumnConstraints,\n): number {\n  return Math.min(Math.max(width, constraints.minWidth), constraints.maxWidth);\n}\n\n/**\n * Pairs each column with everything needed to render it — the width it sits\n * at, the label its header shows, whether it may be resized and how its cells\n * align. Widths take the first of the sizing state, the column's own `width`,\n * and the default, then clamp.\n *\n * The sizing state winning means a user's drag outlives a re-render; a column\n * absent from it still tracks a `width` edited in the definition.\n */\nexport function resolveColumnWidths<Row, Header>(\n  columns: readonly ColumnDefinition<Row, Header>[],\n  sizing: ColumnSizingState,\n  options?: ColumnResolveOptions,\n): readonly ResolvedColumn<Row, Header>[] {\n  const resolved = withDefaults(options?.sizes);\n\n  return columns.map((column) => {\n    const id = getColumnId(column);\n    const stored = sizing[id];\n\n    return {\n      column,\n      id,\n      sized: stored !== undefined,\n      width: clampColumnWidth(\n        stored ?? column.width ?? resolved.width,\n        resolveColumnConstraints(column, resolved),\n      ),\n      label: resolveColumnLabel(column),\n      resizable: column.resizable ?? options?.resizable ?? false,\n      alignment: column.alignment ?? alignmentForType(column.type ?? \"string\"),\n    };\n  });\n}\n\nexport function totalColumnWidth<Row, Header>(\n  resolved: readonly ResolvedColumn<Row, Header>[],\n): number {\n  return resolved.reduce((total, entry) => total + entry.width, 0);\n}\n\n/**\n * Opens a resize. The session captures its constraints and starting point up\n * front, so applying a pointer position later is arithmetic on numbers alone —\n * which is what keeps the drag testable without a DOM.\n *\n * @param startPosition Where the pointer went down, on the axis being dragged.\n */\nexport function beginColumnResize<Row>(\n  column: ColumnDefinition<Row, unknown>,\n  startWidth: number,\n  startPosition: number,\n  defaults?: Partial<ColumnSizeDefaults>,\n): ColumnResizeSession {\n  return {\n    columnId: getColumnId(column),\n    startWidth,\n    startPosition,\n    constraints: resolveColumnConstraints(column, defaults),\n  };\n}\n\n/**\n * The width the dragged column takes with the pointer at `position`. The delta\n * is signed, so a right-to-left adapter negates it and nothing else changes.\n */\nexport function applyColumnResize(\n  session: ColumnResizeSession,\n  position: number,\n): number {\n  return clampColumnWidth(\n    session.startWidth + (position - session.startPosition),\n    session.constraints,\n  );\n}\n\n/**\n * Grows columns proportionally until they fill `availableWidth`.\n *\n * Growth only: columns that already meet or exceed the width are returned\n * untouched, so a container too narrow for them scrolls rather than crushing\n * them. Columns the user has sized are left at that width and the rest share\n * what is left, so dragging one column does not rubber-band it back.\n */\nexport function fitColumnsToWidth<Row, Header>(\n  resolved: readonly ResolvedColumn<Row, Header>[],\n  availableWidth: number,\n  defaults?: Partial<ColumnSizeDefaults>,\n): readonly ResolvedColumn<Row, Header>[] {\n  const target = Math.floor(availableWidth);\n  if (resolved.length === 0 || totalColumnWidth(resolved) >= target) {\n    return resolved;\n  }\n\n  const entries = resolved.map((entry) => ({\n    entry,\n    width: entry.width,\n    maxWidth: resolveColumnConstraints(entry.column, defaults).maxWidth,\n    growable: !entry.sized,\n  }));\n  const sum = () => entries.reduce((total, item) => total + item.width, 0);\n\n  // Clamping a column at its maximum frees surplus the others have to absorb,\n  // so a pass that clamped anything is followed by another.\n  for (;;) {\n    const growing = entries.filter(\n      (item) => item.growable && item.width < item.maxWidth,\n    );\n    const surplus = target - sum();\n    if (surplus <= 0 || growing.length === 0) {\n      break;\n    }\n\n    const base = growing.reduce((total, item) => total + item.width, 0);\n    let clamped = false;\n\n    for (const item of growing) {\n      const share =\n        base === 0 ? surplus / growing.length : (surplus * item.width) / base;\n\n      if (item.width + share >= item.maxWidth) {\n        item.width = item.maxWidth;\n        clamped = true;\n      } else {\n        item.width += share;\n      }\n    }\n\n    if (!clamped) {\n      break;\n    }\n  }\n\n  // Fractional widths would leave the table a sub-pixel short of its container\n  // and show a scrollbar that never goes away, so floor every column and hand\n  // the lost pixels back out one at a time.\n  let remainder = target - entries.reduce((t, i) => t + Math.floor(i.width), 0);\n\n  return entries.map((item) => {\n    let width = Math.floor(item.width);\n    if (remainder > 0 && item.growable && width < item.maxWidth) {\n      width += 1;\n      remainder -= 1;\n    }\n    return { ...item.entry, width };\n  });\n}\n\n/**\n * The width a column needs to show `measuredWidth` of content.\n *\n * `padding` is an allowance on top of the measurement, since a column sized to\n * exactly its content can still round down into an ellipsis.\n */\nexport function sizeColumnToContent(\n  measuredWidth: number,\n  constraints: ColumnConstraints,\n  padding = 2,\n): number {\n  return clampColumnWidth(Math.ceil(measuredWidth + padding), constraints);\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/util/grid.ts","../src/util/ordering.ts","../src/util/sizing.ts"],"sourcesContent":["import type { ColumnAlignment, ColumnDefinition, ColumnType } from \"../types\";\n\n/**\n * Narrows to a value worth drilling into. Mirrors the `LeafValue` union in\n * `../types`: arrays and `Date`s are cell values rather than groups of\n * columns, and `null` cannot be introspected. Keep the two in sync.\n */\nfunction isNested(value: unknown): value is Record<string, unknown> {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    !Array.isArray(value) &&\n    !(value instanceof Date)\n  );\n}\n\nfunction getType(value: unknown): ColumnType {\n  if (value instanceof Date) return \"dateTime\";\n  if (typeof value === \"string\") return \"string\";\n  if (typeof value === \"number\") return \"number\";\n  if (typeof value === \"boolean\") return \"boolean\";\n  if (typeof value === \"bigint\") return \"number\";\n  if (typeof value === \"symbol\") return \"string\";\n  return \"string\";\n}\n\n/**\n * How a column of `type` aligns by default. Numeric types align right so that\n * their digits line up by place value; everything else reads from the left.\n */\nexport function alignmentForType(type: ColumnType): ColumnAlignment {\n  switch (type) {\n    case \"number\":\n    case \"decimal\":\n    case \"currency\":\n    case \"percent\":\n      return \"right\";\n    default:\n      return \"left\";\n  }\n}\n\nfunction getAlignment(value: unknown): ColumnAlignment {\n  return alignmentForType(getType(value));\n}\n\n/**\n * Derives one column per field across `rows`, in the order each field is first\n * seen — so a key that only appears in a later row still gets a column,\n * appended at the end. Nested objects contribute their non-object properties\n * as `\"Parent.Child\"`; anything deeper is skipped, as is the nested object\n * itself.\n *\n * Order follows `Object.entries`, which lists integer-like keys first\n * regardless of the order they were written in.\n */\nexport function defineColumnsFromRows<Row>(\n  rows: readonly Row[],\n): readonly ColumnDefinition<Row>[] {\n  const columns: ColumnDefinition<Row>[] = [];\n  const seen = new Set<string>();\n\n  function add(field: string, value: unknown): void {\n    if (seen.has(field)) {\n      return;\n    }\n    seen.add(field);\n    columns.push({\n      field,\n      type: getType(value),\n      alignment: getAlignment(value),\n    });\n  }\n\n  for (const row of rows) {\n    if (!isNested(row)) {\n      continue;\n    }\n    for (const [key, value] of Object.entries(row)) {\n      if (!isNested(value)) {\n        add(key, value);\n        continue;\n      }\n      for (const [nestedKey, nestedValue] of Object.entries(value)) {\n        if (!isNested(nestedValue)) {\n          add(`${key}.${nestedKey}`, nestedValue);\n        }\n      }\n    }\n  }\n\n  return columns;\n}\n\n/**\n * The key state about a column is stored under, and the key it renders with.\n * Every such lookup goes through here so the two can never disagree.\n */\nexport function getColumnId<Row>(\n  column: ColumnDefinition<Row, unknown>,\n): string {\n  return column.id ?? column.field;\n}\n\n/**\n * What a column's header shows: its own `headerTemplate`, called first if it is\n * a function, or else a label read off the field path — `\"Application.Id\"`\n * reading as `\"Application Id\"`.\n */\nexport function resolveColumnLabel<Row, Node>(\n  column: ColumnDefinition<Row, Node>,\n): Node | string {\n  const { headerTemplate } = column;\n  if (headerTemplate === undefined) {\n    return column.field.split(\".\").join(\" \");\n  }\n  // `Node` is open, so it could itself be a function type and the `typeof`\n  // check cannot narrow on its own. A header that is callable is the lazy\n  // form by definition — no adapter binds `Node` to a function.\n  return typeof headerTemplate === \"function\"\n    ? (headerTemplate as () => Node)()\n    : headerTemplate;\n}\n\n/**\n * Accesses a value at a dotted path, e.g. `foo.bar.baz`.\n *\n * @param obj The object to access\n * @param path Path to the value, e.g. `\"foo.bar\"`\n * @returns The value at `path`, or `undefined` if it doesn't exist\n */\nexport function accessDotted(obj: unknown, path: string): unknown {\n  return path\n    .split(\".\")\n    .reduce((value, key) => (isNested(value) ? value[key] : undefined), obj);\n}\n","import type { ColumnDefinition, ColumnOrderState, DropSide } from \"../types\";\nimport { getColumnId } from \"./grid\";\n\n/**\n * Puts `columns` in the order `order` gives. Ids it lists come first, in that\n * order; columns it omits keep their position among the definitions and\n * follow. Ids naming no column are ignored.\n *\n * Tolerating both gaps is what lets a stored order outlive the column list it\n * was made against.\n */\nexport function applyColumnOrder<Row, Node>(\n  columns: readonly ColumnDefinition<Row, Node>[],\n  order: ColumnOrderState,\n): readonly ColumnDefinition<Row, Node>[] {\n  if (order.length === 0) {\n    return columns;\n  }\n\n  const byId = new Map(columns.map((column) => [getColumnId(column), column]));\n  const listed = order\n    .map((id) => byId.get(id))\n    .filter((column) => column !== undefined);\n  const taken = new Set(listed.map((column) => getColumnId(column)));\n\n  return [\n    ...listed,\n    ...columns.filter((column) => !taken.has(getColumnId(column))),\n  ];\n}\n\n/**\n * The order with `movedId` lifted out and put back in front of `beforeId`, or\n * at the end when that is `null`.\n *\n * Returns `orderedIds` itself when the move changes nothing, so callers can\n * treat an unchanged reference as \"no move happened\".\n */\nexport function moveColumnBefore(\n  orderedIds: ColumnOrderState,\n  movedId: string,\n  beforeId: string | null,\n): ColumnOrderState {\n  if (movedId === beforeId || !orderedIds.includes(movedId)) {\n    return orderedIds;\n  }\n\n  const without = orderedIds.filter((id) => id !== movedId);\n  // Taken after the removal: an index read before it would be one too far\n  // right for every move that travels rightwards.\n  const target = beforeId === null ? without.length : without.indexOf(beforeId);\n  if (target === -1) {\n    return orderedIds;\n  }\n\n  const next = [...without];\n  next.splice(target, 0, movedId);\n  return next.every((id, index) => id === orderedIds[index])\n    ? orderedIds\n    : next;\n}\n\n/**\n * Whether moving `movedId` in front of `beforeId` would rearrange anything, so\n * that a drop indicator promises exactly the moves that happen.\n *\n * Defined against `moveColumnBefore` rather than restating its conditions, so\n * the two cannot disagree about what a no-op is.\n */\nexport function movesColumn(\n  orderedIds: ColumnOrderState,\n  movedId: string,\n  beforeId: string | null,\n): boolean {\n  return moveColumnBefore(orderedIds, movedId, beforeId) !== orderedIds;\n}\n\n/**\n * The id a drop on `side` of `targetId` lands in front of, which is `null`\n * past the last column.\n *\n * \"After C\" and \"before D\" name the same gap, so collapsing both to one id\n * keeps a drop target a single nullable string.\n */\nexport function resolveDropBefore(\n  orderedIds: ColumnOrderState,\n  targetId: string,\n  side: DropSide,\n): string | null {\n  if (side === \"before\") {\n    return targetId;\n  }\n  const index = orderedIds.indexOf(targetId);\n  return index === -1 ? null : (orderedIds[index + 1] ?? null);\n}\n","import type {\n  ColumnConstraints,\n  ColumnDefinition,\n  ColumnResizeSession,\n  ColumnResolveOptions,\n  ColumnSizeDefaults,\n  ColumnSizingState,\n  ResolvedColumn,\n} from \"../types\";\nimport { alignmentForType, getColumnId, resolveColumnLabel } from \"./grid\";\n\n/**\n * Applied to any column that does not size itself. The minimum is a width a\n * header stays legible at rather than a measured value — a column dragged\n * narrower than this reads as a rendering fault.\n */\nexport const DEFAULT_COLUMN_SIZES: ColumnSizeDefaults = {\n  width: 150,\n  minWidth: 40,\n  maxWidth: Number.POSITIVE_INFINITY,\n};\n\n/** How far one arrow key press moves a column edge. */\nexport const KEYBOARD_STEP = 10;\n\nfunction withDefaults(\n  defaults?: Partial<ColumnSizeDefaults>,\n): ColumnSizeDefaults {\n  return { ...DEFAULT_COLUMN_SIZES, ...defaults };\n}\n\n/**\n * The bounds `column` may be sized between. Resolved in one place so that a\n * drag, a clamp and an auto-fit cannot disagree about a column's limits.\n */\nexport function resolveColumnConstraints<Row>(\n  column: ColumnDefinition<Row, unknown>,\n  defaults?: Partial<ColumnSizeDefaults>,\n): ColumnConstraints {\n  const resolved = withDefaults(defaults);\n  return {\n    minWidth: column.minWidth ?? resolved.minWidth,\n    maxWidth: column.maxWidth ?? resolved.maxWidth,\n  };\n}\n\n/** Holds `width` within `constraints`. */\nexport function clampColumnWidth(\n  width: number,\n  constraints: ColumnConstraints,\n): number {\n  return Math.min(Math.max(width, constraints.minWidth), constraints.maxWidth);\n}\n\n/**\n * Pairs each column with everything needed to render it — the width it sits\n * at, the label its header shows, whether it may be resized and how its cells\n * align. Widths take the first of the sizing state, the column's own `width`,\n * and the default, then clamp.\n *\n * The sizing state winning means a user's drag outlives a re-render; a column\n * absent from it still tracks a `width` edited in the definition.\n */\nexport function resolveColumnWidths<Row, Node>(\n  columns: readonly ColumnDefinition<Row, Node>[],\n  sizing: ColumnSizingState,\n  options?: ColumnResolveOptions,\n): readonly ResolvedColumn<Row, Node>[] {\n  const resolved = withDefaults(options?.sizes);\n\n  return columns.map((column) => {\n    const id = getColumnId(column);\n    const stored = sizing[id];\n\n    return {\n      column,\n      id,\n      sized: stored !== undefined,\n      width: clampColumnWidth(\n        stored ?? column.width ?? resolved.width,\n        resolveColumnConstraints(column, resolved),\n      ),\n      label: resolveColumnLabel(column),\n      resizable: column.resizable ?? options?.resizable ?? false,\n      reorderable: column.reorderable ?? options?.reorderable ?? false,\n      alignment: column.alignment ?? alignmentForType(column.type ?? \"string\"),\n    };\n  });\n}\n\nexport function totalColumnWidth<Row, Node>(\n  resolved: readonly ResolvedColumn<Row, Node>[],\n): number {\n  return resolved.reduce((total, entry) => total + entry.width, 0);\n}\n\n/**\n * Opens a resize. The session captures its constraints and starting point up\n * front, so applying a pointer position later is arithmetic on numbers alone —\n * which is what keeps the drag testable without a DOM.\n *\n * @param startPosition Where the pointer went down, on the axis being dragged.\n */\nexport function beginColumnResize<Row>(\n  column: ColumnDefinition<Row, unknown>,\n  startWidth: number,\n  startPosition: number,\n  defaults?: Partial<ColumnSizeDefaults>,\n): ColumnResizeSession {\n  return {\n    columnId: getColumnId(column),\n    startWidth,\n    startPosition,\n    constraints: resolveColumnConstraints(column, defaults),\n  };\n}\n\n/**\n * The width the dragged column takes with the pointer at `position`. The delta\n * is signed, so a right-to-left adapter negates it and nothing else changes.\n */\nexport function applyColumnResize(\n  session: ColumnResizeSession,\n  position: number,\n): number {\n  return clampColumnWidth(\n    session.startWidth + (position - session.startPosition),\n    session.constraints,\n  );\n}\n\n/**\n * Grows columns proportionally until they fill `availableWidth`.\n *\n * Growth only: columns that already meet or exceed the width are returned\n * untouched, so a container too narrow for them scrolls rather than crushing\n * them. Columns the user has sized are left at that width and the rest share\n * what is left, so dragging one column does not rubber-band it back.\n */\nexport function fitColumnsToWidth<Row, Node>(\n  resolved: readonly ResolvedColumn<Row, Node>[],\n  availableWidth: number,\n  defaults?: Partial<ColumnSizeDefaults>,\n): readonly ResolvedColumn<Row, Node>[] {\n  const target = Math.floor(availableWidth);\n  if (resolved.length === 0 || totalColumnWidth(resolved) >= target) {\n    return resolved;\n  }\n\n  const entries = resolved.map((entry) => ({\n    entry,\n    width: entry.width,\n    maxWidth: resolveColumnConstraints(entry.column, defaults).maxWidth,\n    growable: !entry.sized,\n  }));\n  const sum = () => entries.reduce((total, item) => total + item.width, 0);\n\n  // Clamping a column at its maximum frees surplus the others have to absorb,\n  // so a pass that clamped anything is followed by another.\n  for (;;) {\n    const growing = entries.filter(\n      (item) => item.growable && item.width < item.maxWidth,\n    );\n    const surplus = target - sum();\n    if (surplus <= 0 || growing.length === 0) {\n      break;\n    }\n\n    const base = growing.reduce((total, item) => total + item.width, 0);\n    let clamped = false;\n\n    for (const item of growing) {\n      const share =\n        base === 0 ? surplus / growing.length : (surplus * item.width) / base;\n\n      if (item.width + share >= item.maxWidth) {\n        item.width = item.maxWidth;\n        clamped = true;\n      } else {\n        item.width += share;\n      }\n    }\n\n    if (!clamped) {\n      break;\n    }\n  }\n\n  // Fractional widths would leave the table a sub-pixel short of its container\n  // and show a scrollbar that never goes away, so floor every column and hand\n  // the lost pixels back out one at a time.\n  let remainder = target - entries.reduce((t, i) => t + Math.floor(i.width), 0);\n\n  return entries.map((item) => {\n    let width = Math.floor(item.width);\n    if (remainder > 0 && item.growable && width < item.maxWidth) {\n      width += 1;\n      remainder -= 1;\n    }\n    return { ...item.entry, width };\n  });\n}\n\n/**\n * The width a column needs to show `measuredWidth` of content.\n *\n * `padding` is an allowance on top of the measurement, since a column sized to\n * exactly its content can still round down into an ellipsis.\n */\nexport function sizeColumnToContent(\n  measuredWidth: number,\n  constraints: ColumnConstraints,\n  padding = 2,\n): number {\n  return clampColumnWidth(Math.ceil(measuredWidth + padding), constraints);\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gridkitjs/core",
-  "version": "0.0.1",
+  "version": "0.2.0",
   "description": "Framework-agnostic data-grid logic: column resolution, alignment and sizing.",
   "license": "MIT",
   "author": "Blagoja Blazhevski",
@@ -22,19 +22,12 @@
   "engines": {
     "node": ">=22"
   },
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./src/index.ts"
-  },
-  "publishConfig": {
-    "main": "./dist/index.js",
-    "types": "./dist/index.d.ts",
-    "exports": {
-      ".": {
-        "types": "./dist/index.d.ts",
-        "import": "./dist/index.js"
-      }
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     }
   },
   "files": [
@@ -42,15 +35,15 @@
     "LICENSE",
     "README.md"
   ],
+  "devDependencies": {
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.10"
+  },
   "scripts": {
     "build": "tsup",
     "typecheck": "tsc --noEmit",
     "lint": "eslint src",
     "test": "vitest run"
-  },
-  "devDependencies": {
-    "tsup": "^8.5.1",
-    "typescript": "^6.0.3",
-    "vitest": "^4.1.10"
   }
-}
+}