import * as R from "remeda";

declare function getData<TData>(options: {
  select: (raw: { items: Array<{ type: string; name: string }> }) => TData;
}): { data: NoInfer<TData> | undefined };

const { data } = getData({
  select: (raw) => raw.items,
});

// ✅ R.map result works fine on its own — Mapped<T, K> resolves for .find()
const mapped = R.map(data ?? [], (item) => ({ ...item, extra: true }));
mapped.find((r) => r.type === "a"); // OK

// ❌ Passing that same Mapped<T, K> into R.sortBy fails
const sorted = R.sortBy(mapped, (item) => item.name);
sorted.find((r) => r.type === "a"); // Error: This expression is not callable

// ❌ R.pipe + data-last also fails
const piped = R.pipe(
  data ?? [],
  R.map((item) => ({ ...item, extra: true })),
  R.sortBy((item) => item.name),
);
piped.find((r) => r.type === "a"); // Error: This expression is not callable

// ✅ Native .map result (plain Array<K>) works with R.sortBy
const nativeMapped = (data ?? []).map((item) => ({ ...item, extra: true }));
const sorted2 = R.sortBy(nativeMapped, (item) => item.name);
sorted2.find((r) => r.type === "a"); // OK

// ✅ Explicit Array annotation on the intermediate also works
const explicit: Array<{ type: string; name: string; extra: boolean }> =
  R.map(data ?? [], (item) => ({ ...item, extra: true }));
const sorted3 = R.sortBy(explicit, (item) => item.name);
sorted3.find((r) => r.type === "a"); // OK