Fix CI typecheck errors after merge conflict resolution

Agent-Logs-Url: https://github.com/githubnext/tsessebe/sessions/2715e479-20de-4885-bb80-bc9bbae1f654

Co-authored-by: mrjf <180956+mrjf@users.noreply.github.com>

Author: Copilot

src/core/align.ts

@@ -125,7 +125,7 @@ export function alignSeries<L extends Scalar, R extends Scalar>(
   left: Series<L>,
   right: Series<R>,
   options: AlignSeriesOptions = {},
-): [Series<L>, Series<R>] {
+): [Series<Scalar>, Series<Scalar>] {
   const { join = "outer", fillValue = null } = options;
   const targetIdx = resolveIndex(left.index, right.index, join);
 

src/core/base-index.ts

@@ -49,6 +49,11 @@ export class Index<T extends Label = Label> {
     return this._values.length;
   }
 
+  /** Alias for `size` to preserve array-like ergonomics. */
+  get length(): number {
+    return this._values.length;
+  }
+
   /** Shape tuple (always 1-D). */
   get shape(): [number] {
     return [this._values.length];
@@ -65,8 +70,8 @@ export class Index<T extends Label = Label> {
   }
 
   /** Snapshot of the underlying values as a plain array. */
-  get values(): readonly T[] {
-    return this._values;
+  get values(): T[] {
+    return [...this._values];
   }
 
   /** True when every label appears exactly once. */

src/core/frame.ts

@@ -96,16 +96,44 @@ export class DataFrame {
 
   // ─── construction ─────────────────────────────────────────────────────────
 
+  constructor(columns: ReadonlyMap<string, Series<Scalar>>, index: Index<Label>);
+  constructor(columns: Readonly<Record<string, Series<Scalar>>>, options?: DataFrameOptions);
   /**
    * Low-level constructor.  Prefer the static factory methods for typical use.
    *
-   * @param columns - Ordered map of column name → Series (all same length and index).
-   * @param index   - Row index (must match each Series' length).
+   * @param columns - Ordered map of column name → Series (all same length and index),
+   *   or a plain record of column name → Series.
+   * @param indexOrOptions - Row index for map input, or options for record input.
    */
-  constructor(columns: ReadonlyMap<string, Series<Scalar>>, index: Index<Label>) {
-    this._columns = columns;
-    this.index = index;
-    this.columns = new Index<string>([...columns.keys()]);
+  constructor(
+    columns: ReadonlyMap<string, Series<Scalar>> | Readonly<Record<string, Series<Scalar>>>,
+    indexOrOptions?: Index<Label> | DataFrameOptions,
+  ) {
+    if (columns instanceof Map) {
+      if (!(indexOrOptions instanceof Index)) {
+        throw new TypeError("DataFrame constructor requires an Index when columns is a Map");
+      }
+      this._columns = columns;
+      this.index = indexOrOptions;
+      this.columns = new Index<string>([...columns.keys()]);
+      return;
+    }
+
+    const entries = Object.entries(columns);
+    const colMap = new Map<string, Series<Scalar>>();
+    for (const [name, series] of entries) {
+      colMap.set(name, series);
+    }
+    const options = indexOrOptions instanceof Index ? { index: indexOrOptions } : indexOrOptions;
+    const firstSeries = entries[0]?.[1];
+    const inferredRows = firstSeries?.size ?? 0;
+    const rowIndex =
+      options?.index !== undefined
+        ? resolveRowIndex(inferredRows, options.index)
+        : (firstSeries?.index ?? defaultRowIndex(0));
+    this._columns = options?.index !== undefined ? reindexColumns(colMap, rowIndex) : colMap;
+    this.index = rowIndex;
+    this.columns = new Index<string>([...colMap.keys()]);
   }
 
   /**
@@ -254,6 +282,18 @@ export class DataFrame {
     return this._columns.has(name);
   }
 
+  /** Alias for {@link has}. */
+  hasColumn(name: string): boolean {
+    return this.has(name);
+  }
+
+  /** Iterate `(columnName, Series)` pairs in column order. */
+  *[Symbol.iterator](): IterableIterator<[string, Series<Scalar>]> {
+    for (const entry of this._columns) {
+      yield entry;
+    }
+  }
+
   // ─── slicing ──────────────────────────────────────────────────────────────
 
   /** Return the first `n` rows (default 5). */
@@ -848,7 +888,32 @@ function reindexColumns(
 ): Map<string, Series<Scalar>> {
   const result = new Map<string, Series<Scalar>>();
   for (const [name, series] of colMap) {
-    result.set(name, new Series({ data: series.values as Scalar[], index: newIndex }));
+    if (series.size === newIndex.size) {
+      result.set(
+        name,
+        new Series({
+          data: series.values,
+          index: newIndex,
+          dtype: series.dtype,
+          ...(series.name !== null ? { name: series.name } : {}),
+        }),
+      );
+      continue;
+    }
+
+    const resized: Scalar[] = new Array<Scalar>(newIndex.size);
+    for (let i = 0; i < newIndex.size; i++) {
+      resized[i] = series.values[i] ?? null;
+    }
+    result.set(
+      name,
+      new Series({
+        data: resized,
+        index: newIndex,
+        dtype: series.dtype,
+        ...(series.name !== null ? { name: series.name } : {}),
+      }),
+    );
   }
   return result;
 }

src/core/reindex.ts

@@ -198,7 +198,7 @@ function applyNearest(values: Scalar[], present: readonly boolean[]): Scalar[] {
       out[i] = rightVal[i];
     } else if (rd === -1) {
       out[i] = leftVal[i];
-    } else if (rd <= ld) {
+    } else if (rd !== undefined && ld !== undefined && rd <= ld) {
       // prefer right on tie
       out[i] = rightVal[i];
     } else {
@@ -252,7 +252,7 @@ export function reindexSeries<T extends Scalar>(
   series: Series<T>,
   newIndex: readonly Label[] | Index<Label>,
   options: ReindexSeriesOptions = {},
-): Series<T> {
+): Series<Scalar> {
   const { fillValue = null, method, limit } = options;
 
   const newIdx = toIndex(newIndex);
@@ -268,16 +268,19 @@ export function reindexSeries<T extends Scalar>(
     const key = String(newLabels[i]);
     const positions = labelMap.get(key);
     if (positions !== undefined && positions.length > 0) {
-      resultValues[i] = series.values[positions[0]] as Scalar;
-      present[i] = true;
+      const pos = positions[0];
+      if (pos !== undefined) {
+        resultValues[i] = series.values[pos] ?? null;
+        present[i] = true;
+      }
     }
   }
 
   const finalValues =
     method !== undefined ? applyFillMethod(resultValues, present, method, limit) : resultValues;
 
-  return new Series<T>({
-    data: finalValues as T[],
+  return new Series<Scalar>({
+    data: finalValues,
     index: newIdx,
     name: series.name,
   });

src/core/timestamp.ts

@@ -331,7 +331,7 @@ function freqMs(freq: string): number {
   if (upper === "D") return MS_PER_DAY;
   // Try "Nunit" pattern (e.g. "2H", "15T").
   const m = /^(\d+)(.+)$/.exec(freq);
-  if (m !== null) {
+  if (m !== null && m[1] !== undefined && m[2] !== undefined) {
     return Number(m[1]) * freqMs(m[2]);
   }
   throw new Error(`Timestamp.floor/ceil/round: unsupported frequency "${freq}"`);

src/groupby/groupby.ts

@@ -20,6 +20,7 @@ import { Index } from "../core/index.ts";
 import { RangeIndex } from "../core/index.ts";
 import { DataFrame } from "../core/index.ts";
 import { Series } from "../core/index.ts";
+import { NamedAgg, type NamedAggSpec } from "./named_agg.ts";
 import type { Label, Scalar } from "../types.ts";
 
 // ─── types ────────────────────────────────────────────────────────────────────
@@ -304,6 +305,51 @@ export class DataFrameGroupBy {
     return this._runAgg(colSpecs, asIndex);
   }
 
+  /**
+   * Aggregate using pandas-style named aggregation.
+   * Keys in `spec` become output column names.
+   */
+  aggNamed(spec: NamedAggSpec, asIndex = true): DataFrame {
+    const groupKeys = this._groups.map((g) => g.key);
+    const resultCols: Record<string, Scalar[]> = {};
+
+    if (!asIndex) {
+      if (this._by.length === 1) {
+        const byCol = this._by[0];
+        if (byCol !== undefined) {
+          resultCols[byCol] = groupKeys.slice();
+        }
+      } else {
+        for (const by of this._by) {
+          resultCols[by] = [];
+        }
+        for (const g of this._groups) {
+          const parts = String(g.key).split("__SEP__");
+          this._by.forEach((by, idx) => {
+            const byArr = resultCols[by];
+            if (byArr !== undefined) {
+              byArr.push(parts[idx] ?? null);
+            }
+          });
+        }
+      }
+    }
+
+    for (const [outCol, named] of Object.entries(spec)) {
+      if (!(named instanceof NamedAgg)) {
+        throw new TypeError(`aggNamed: "${outCol}" must be a NamedAgg`);
+      }
+      const src = named.column;
+      const fn = resolveAgg(named.aggfunc as AggName | AggFn);
+      const srcSeries = this._df.col(src);
+      const srcVals = srcSeries.values as readonly Scalar[];
+      resultCols[outCol] = this._groups.map((g) => fn(g.positions.map((p) => srcVals[p] as Scalar)));
+    }
+
+    const rowIdx: Index<Label> = asIndex ? new Index<Label>(groupKeys) : defaultIndex(groupKeys.length);
+    return DataFrame.fromColumns(resultCols as Record<string, readonly Scalar[]>, { index: rowIdx });
+  }
+
   /** Shorthand for `agg("sum")` — numeric columns only, like pandas. */
   sum(): DataFrame {
     const cols = this._numericValueCols();

src/groupby/named_agg.ts

@@ -40,9 +40,9 @@ export class NamedAgg {
   /** Source column to read from the DataFrame. */
   readonly column: string;
   /** Aggregation to apply — a built-in name or a custom function. */
-  readonly aggfunc: AggName | AggFn;
+  readonly aggfunc: AggName | AggFn | string;
 
-  constructor(column: string, aggfunc: AggName | AggFn) {
+  constructor(column: string, aggfunc: AggName | AggFn | string) {
     this.column = column;
     this.aggfunc = aggfunc;
   }
@@ -59,7 +59,7 @@ export class NamedAgg {
  * });
  * ```
  */
-export function namedAgg(column: string, aggfunc: AggName | AggFn): NamedAgg {
+export function namedAgg(column: string, aggfunc: AggName | AggFn | string): NamedAgg {
   return new NamedAgg(column, aggfunc);
 }
 

src/io/json_normalize.ts

@@ -310,6 +310,9 @@ export function jsonNormalize(
     let currentRecords: readonly JsonObject[] = records;
     for (let i = 0; i < pathList.length; i++) {
       const path = pathList[i];
+      if (path === undefined) {
+        continue;
+      }
       const isFinal = i === pathList.length - 1;
       if (isFinal) {
         rows = normalizeWithPath(
@@ -343,7 +346,7 @@ export function jsonNormalize(
 
   // ── Build column sets and DataFrame ───────────────────────────────────────
   if (rows.length === 0) {
-    return new DataFrame({});
+    return DataFrame.fromColumns({});
   }
 
   // Union of all column names (preserve first-seen insertion order)
@@ -368,18 +371,14 @@ export function jsonNormalize(
   for (const [col, vals] of Object.entries(colData)) {
     let dtype: Dtype;
     if (vals.every((v) => v === null || typeof v === "number")) {
-      dtype = vals.some((v) => v !== null && !Number.isInteger(v))
-        ? new Dtype("float64")
-        : new Dtype("int64");
+      dtype = vals.some((v) => v !== null && !Number.isInteger(v)) ? Dtype.float64 : Dtype.int64;
     } else if (vals.every((v) => v === null || typeof v === "boolean")) {
-      dtype = new Dtype("bool");
+      dtype = Dtype.bool;
     } else {
-      dtype = new Dtype("object");
+      dtype = Dtype.object;
     }
-    seriesMap[col] = new Series(vals, { name: col, dtype });
+    seriesMap[col] = new Series({ data: vals, name: col, dtype });
   }
 
-  return new DataFrame(seriesMap, {
-    index: new RangeIndex(rows.length),
-  });
+  return new DataFrame(seriesMap, { index: new RangeIndex(rows.length) });
 }

src/stats/clip_with_bounds.ts

@@ -21,7 +21,13 @@ import type { Label, Scalar } from "../types.ts";
 // ─── public types ─────────────────────────────────────────────────────────────
 
 /** A scalar numeric bound, a positional array, or a Series aligned by label. */
-export type BoundArg = number | null | undefined | readonly (number | null)[] | Series<Scalar>;
+export type BoundArg =
+  | number
+  | null
+  | undefined
+  | readonly (number | null)[]
+  | Series<Scalar>
+  | DataFrame;
 
 /** Options for {@link clipSeriesWithBounds}. */
 export interface SeriesClipBoundsOptions {

src/stats/crosstab.ts

@@ -202,7 +202,7 @@ export function crosstab(
   const buckets: Array<Array<number[] | undefined>> | null =
     values !== undefined
       ? Array.from({ length: nRows }, () =>
-          Array.from<number[] | undefined>({ length: nCols }, () => undefined),
+          Array.from({ length: nCols }, () => undefined as number[] | undefined),
         )
       : null;
 
@@ -293,12 +293,12 @@ export function crosstab(
       const name = labelStr(colUniques[ci] as Scalar);
       const col = colData[name];
       if (col !== undefined) {
-        col.push(col.reduce((s, v) => s + (v as number), 0));
+        col.push(col.reduce((s: number, v) => s + (typeof v === "number" ? v : 0), 0));
       }
     }
     // Add an "All" column with row totals (and grand total in the last cell).
     const allCol: Scalar[] = cells.map((row) => row.reduce((s, v) => s + v, 0));
-    allCol.push(allCol.reduce((s, v) => s + (v as number), 0));
+    allCol.push(allCol.reduce((s: number, v) => s + (typeof v === "number" ? v : 0), 0));
     colData[marginsName] = allCol;
     finalRowLabels = [...rowLabels, marginsName as Label];
   }