foldkit-primitives 0.15.4 → 0.16.0

package/dist/state/pagination.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.js","names":[],"sources":["../../src/state/pagination.ts"],"sourcesContent":["import { Schema } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport { Bundle } from 'foldkit-bundle'\nimport { unlessSame } from '../internal.js'\n\nexport const PaginationModel = Schema.Struct({\n  page: Schema.Number,\n  perPage: Schema.Number,\n  total: Schema.NullOr(Schema.Number),\n})\nexport type PaginationModel = typeof PaginationModel.Type\n\nexport const PaginationMessage = defineMessageUnion({\n  GoToPage: { page: Schema.Number },\n  NextPage: {},\n  PrevPage: {},\n  SetPerPage: { perPage: Schema.Number },\n  SetTotal: { total: Schema.NullOr(Schema.Number) },\n})\nexport type PaginationMessage = typeof PaginationMessage.Type\n\nconst clampPage = (page: number, perPage: number, total: number | null): number => {\n  if (!Number.isInteger(page)) return 1\n  if (page < 1) return 1\n  if (total === null) return page\n  return Math.min(page, Math.max(1, Math.ceil(total / perPage)))\n}\n\n/** The number of pages, or null while the total is unknown. */\nexport const pageCount = (model: PaginationModel): number | null =>\n  model.total === null ? null : Math.max(1, Math.ceil(model.total / model.perPage))\n\n/** The offset of the first item on the page, for a slice or a query. */\nexport const offset = (model: PaginationModel): number => (model.page - 1) * model.perPage\n\n/**\n * Pagination as a bundle: the page, page size, and total live in the Model,\n * so page changes replay and every transition clamps into range. Pure logic,\n * no streams: data loading stays the application's job.\n */\nexport const Pagination = Bundle.make('Pagination', {\n  Model: PaginationModel,\n  Message: PaginationMessage,\n  args: Schema.Struct({\n    perPage: Schema.Number.pipe(\n      Schema.check(Schema.isGreaterThan(0)),\n      Schema.check(Schema.isFinite()),\n    ),\n    total: Schema.optional(Schema.NullOr(Schema.Number.pipe(Schema.check(Schema.isFinite())))),\n  }),\n  init: args => ({\n    model: { page: 1, perPage: args.perPage, total: args.total ?? null },\n  }),\n  update: (model, message) =>\n    PaginationMessage.match(message, {\n      GoToPage: ({ page }) => ({\n        model: unlessSame(model, { ...model, page: clampPage(page, model.perPage, model.total) }),\n      }),\n      NextPage: () => ({\n        model: unlessSame(model, {\n          ...model,\n          page: clampPage(model.page + 1, model.perPage, model.total),\n        }),\n      }),\n      PrevPage: () => ({\n        model: unlessSame(model, {\n          ...model,\n          page: clampPage(model.page - 1, model.perPage, model.total),\n        }),\n      }),\n      SetPerPage: ({ perPage }) =>\n        perPage > 0\n          ? {\n              model: unlessSame(model, {\n                ...model,\n                perPage,\n                page: clampPage(model.page, perPage, model.total),\n              }),\n            }\n          : { model },\n      // Sent again on every refetch, usually with the total already held.\n      SetTotal: ({ total }) =>\n        total === null || total >= 0\n          ? {\n              model: unlessSame(model, {\n                ...model,\n                total,\n                page: clampPage(model.page, model.perPage, total),\n              }),\n            }\n          : { model },\n    }),\n})\n"],"mappings":";;;;;AAKA,MAAa,kBAAkB,OAAO,OAAO;CAC3C,MAAM,OAAO;CACb,SAAS,OAAO;CAChB,OAAO,OAAO,OAAO,OAAO,MAAM;AACpC,CAAC;AAGD,MAAa,oBAAoB,mBAAmB;CAClD,UAAU,EAAE,MAAM,OAAO,OAAO;CAChC,UAAU,CAAC;CACX,UAAU,CAAC;CACX,YAAY,EAAE,SAAS,OAAO,OAAO;CACrC,UAAU,EAAE,OAAO,OAAO,OAAO,OAAO,MAAM,EAAE;AAClD,CAAC;AAGD,MAAM,aAAa,MAAc,SAAiB,UAAiC;CACjF,IAAI,CAAC,OAAO,UAAU,IAAI,GAAG,OAAO;CACpC,IAAI,OAAO,GAAG,OAAO;CACrB,IAAI,UAAU,MAAM,OAAO;CAC3B,OAAO,KAAK,IAAI,MAAM,KAAK,IAAI,GAAG,KAAK,KAAK,QAAQ,OAAO,CAAC,CAAC;AAC/D;;AAGA,MAAa,aAAa,UACxB,MAAM,UAAU,OAAO,OAAO,KAAK,IAAI,GAAG,KAAK,KAAK,MAAM,QAAQ,MAAM,OAAO,CAAC;;AAGlF,MAAa,UAAU,WAAoC,MAAM,OAAO,KAAK,MAAM;;;;;;AAOnF,MAAa,aAAa,OAAO,KAAK,cAAc;CAClD,OAAO;CACP,SAAS;CACT,MAAM,OAAO,OAAO;EAClB,SAAS,OAAO,OAAO,KACrB,OAAO,MAAM,OAAO,cAAc,CAAC,CAAC,GACpC,OAAO,MAAM,OAAO,SAAS,CAAC,CAChC;EACA,OAAO,OAAO,SAAS,OAAO,OAAO,OAAO,OAAO,KAAK,OAAO,MAAM,OAAO,SAAS,CAAC,CAAC,CAAC,CAAC;CAC3F,CAAC;CACD,OAAM,UAAS,EACb,OAAO;EAAE,MAAM;EAAG,SAAS,KAAK;EAAS,OAAO,KAAK,SAAS;CAAK,EACrE;CACA,SAAS,OAAO,YACd,kBAAkB,MAAM,SAAS;EAC/B,WAAW,EAAE,YAAY,EACvB,OAAO,WAAW,OAAO;GAAE,GAAG;GAAO,MAAM,UAAU,MAAM,MAAM,SAAS,MAAM,KAAK;EAAE,CAAC,EAC1F;EACA,iBAAiB,EACf,OAAO,WAAW,OAAO;GACvB,GAAG;GACH,MAAM,UAAU,MAAM,OAAO,GAAG,MAAM,SAAS,MAAM,KAAK;EAC5D,CAAC,EACH;EACA,iBAAiB,EACf,OAAO,WAAW,OAAO;GACvB,GAAG;GACH,MAAM,UAAU,MAAM,OAAO,GAAG,MAAM,SAAS,MAAM,KAAK;EAC5D,CAAC,EACH;EACA,aAAa,EAAE,cACb,UAAU,IACN,EACE,OAAO,WAAW,OAAO;GACvB,GAAG;GACH;GACA,MAAM,UAAU,MAAM,MAAM,SAAS,MAAM,KAAK;EAClD,CAAC,EACH,IACA,EAAE,MAAM;EAEd,WAAW,EAAE,YACX,UAAU,QAAQ,SAAS,IACvB,EACE,OAAO,WAAW,OAAO;GACvB,GAAG;GACH;GACA,MAAM,UAAU,MAAM,MAAM,MAAM,SAAS,KAAK;EAClD,CAAC,EACH,IACA,EAAE,MAAM;CAChB,CAAC;AACL,CAAC"}

package/dist/state/range.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A numeric range as an array: `range(1, 4)` is `[1, 2, 3]`, inclusive of
+ * the start and exclusive of the end, like `Array.from` length math. The
+ * pagination companion: `range(1, (pageCount(model) ?? 0) + 1)` is the page
+ * list. A zero or non-finite step would loop forever, so it throws, naming
+ * the caller — like History's capacity check.
+ */
+export declare const range: (start: number, end: number, step?: number) => ReadonlyArray<number>;
+//# sourceMappingURL=range.d.ts.map

package/dist/state/range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"range.d.ts","names":[],"sources":["../../src/state/range.ts"],"mappings":";;;;;;;qBAOa,QAAK,eAAiB,aAAa,kBAAa"}

package/dist/state/range.js

@@ -0,0 +1,18 @@
+// src/state/range.ts
+/**
+* A numeric range as an array: `range(1, 4)` is `[1, 2, 3]`, inclusive of
+* the start and exclusive of the end, like `Array.from` length math. The
+* pagination companion: `range(1, (pageCount(model) ?? 0) + 1)` is the page
+* list. A zero or non-finite step would loop forever, so it throws, naming
+* the caller — like History's capacity check.
+*/
+const range = (start, end, step = 1) => {
+	if (!Number.isFinite(step) || step === 0) throw new Error(`range: step must be a non-zero finite number, got ${step}`);
+	const values = [];
+	if (step > 0) for (let value = start; value < end; value += step) values.push(value);
+	else for (let value = start; value > end; value += step) values.push(value);
+	return values;
+};
+export { range };
+
+//# sourceMappingURL=range.js.map

package/dist/state/range.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"range.js","names":[],"sources":["../../src/state/range.ts"],"sourcesContent":["/**\n * A numeric range as an array: `range(1, 4)` is `[1, 2, 3]`, inclusive of\n * the start and exclusive of the end, like `Array.from` length math. The\n * pagination companion: `range(1, (pageCount(model) ?? 0) + 1)` is the page\n * list. A zero or non-finite step would loop forever, so it throws, naming\n * the caller — like History's capacity check.\n */\nexport const range = (start: number, end: number, step = 1): ReadonlyArray<number> => {\n  if (!Number.isFinite(step) || step === 0) {\n    throw new Error(`range: step must be a non-zero finite number, got ${step}`)\n  }\n  const values: Array<number> = []\n  if (step > 0) {\n    for (let value = start; value < end; value += step) {\n      values.push(value)\n    }\n  } else {\n    for (let value = start; value > end; value += step) {\n      values.push(value)\n    }\n  }\n  return values\n}\n"],"mappings":";;;;;;;;AAOA,MAAa,SAAS,OAAe,KAAa,OAAO,MAA6B;CACpF,IAAI,CAAC,OAAO,SAAS,IAAI,KAAK,SAAS,GACrC,MAAM,IAAI,MAAM,qDAAqD,MAAM;CAE7E,MAAM,SAAwB,CAAC;CAC/B,IAAI,OAAO,GACT,KAAK,IAAI,QAAQ,OAAO,QAAQ,KAAK,SAAS,MAC5C,OAAO,KAAK,KAAK;MAGnB,KAAK,IAAI,QAAQ,OAAO,QAAQ,KAAK,SAAS,MAC5C,OAAO,KAAK,KAAK;CAGrB,OAAO;AACT"}

package/dist/state/selection.d.ts

@@ -0,0 +1,47 @@
+import { Schema } from "effect";
+import { Bundle } from "foldkit-bundle";
+export declare const SelectionSetModel: Schema.Struct<{
+  readonly selected: Schema.$Array<Schema.String>;
+}>;
+export type SelectionSetModel = typeof SelectionSetModel.Type;
+export declare const SelectionSetMessage: import("foldkit/message").MessageUnion<{
+  readonly Select: {
+    id: Schema.String;
+  };
+  readonly Deselect: {
+    id: Schema.String;
+  };
+  readonly Toggle: {
+    id: Schema.String;
+  };
+  readonly ReplaceAll: {
+    ids: Schema.$Array<Schema.String>;
+  };
+  readonly Clear: {};
+}>;
+export type SelectionSetMessage = typeof SelectionSetMessage.Type;
+/** Whether the id is currently selected. */
+export declare const isSelected: (model: SelectionSetModel, id: string) => boolean;
+/**
+ * A selection set as a bundle: the selected ids in the Model, changed one at
+ * a time or replaced whole. Order follows first selection; toggling moves a
+ * reselected id to the end. Pure logic, no streams.
+ */
+export declare const SelectionSet: Bundle.Bundle<"SelectionSet", void, {
+  readonly selected: readonly string[];
+}, {
+  readonly _tag: "Clear";
+} | {
+  readonly _tag: "Deselect";
+  readonly id: string;
+} | {
+  readonly _tag: "ReplaceAll";
+  readonly ids: readonly string[];
+} | {
+  readonly _tag: "Select";
+  readonly id: string;
+} | {
+  readonly _tag: "Toggle";
+  readonly id: string;
+}, never, never, never, void, {}, {}>;
+//# sourceMappingURL=selection.d.ts.map

package/dist/state/selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection.d.ts","names":[],"sources":["../../src/state/selection.ts"],"mappings":";;qBAKa,mBAAiB,OAAA;;;YAClB,2BAA2B,kBAAkB;qBAE5C,+CAAmB;;IACpB,IAAE,OAAA;;;IACA,IAAE,OAAA;;;IACJ,IAAE,OAAA;;;IACE,KAAG,OAAA,OAAA,OAAA;;;;YAGP,6BAA6B,oBAAoB;;qBAMhD,aAAU,OAAW,mBAAiB;;;;;;qBAQtC,cAAY,OAAA"}

package/dist/state/selection.js

@@ -0,0 +1,39 @@
+import { Schema } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+import { Bundle } from "foldkit-bundle";
+import { sameIds } from "../internal.js";
+// src/state/selection.ts
+const SelectionSetModel = Schema.Struct({ selected: Schema.Array(Schema.String) });
+const SelectionSetMessage = defineMessageUnion({
+	Select: { id: Schema.String },
+	Deselect: { id: Schema.String },
+	Toggle: { id: Schema.String },
+	ReplaceAll: { ids: Schema.Array(Schema.String) },
+	Clear: {}
+});
+const without = (selected, id) => selected.filter((other) => other !== id);
+/** Whether the id is currently selected. */
+const isSelected = (model, id) => model.selected.includes(id);
+/**
+* A selection set as a bundle: the selected ids in the Model, changed one at
+* a time or replaced whole. Order follows first selection; toggling moves a
+* reselected id to the end. Pure logic, no streams.
+*/
+const SelectionSet = Bundle.make("SelectionSet", {
+	Model: SelectionSetModel,
+	Message: SelectionSetMessage,
+	init: () => ({ model: { selected: [] } }),
+	update: (model, message) => SelectionSetMessage.match(message, {
+		Select: ({ id }) => isSelected(model, id) ? { model } : { model: { selected: [...model.selected, id] } },
+		Deselect: ({ id }) => isSelected(model, id) ? { model: { selected: without(model.selected, id) } } : { model },
+		Toggle: ({ id }) => isSelected(model, id) ? { model: { selected: without(model.selected, id) } } : { model: { selected: [...model.selected, id] } },
+		ReplaceAll: ({ ids }) => {
+			const selected = [...new Set(ids)];
+			return sameIds(selected, model.selected) ? { model } : { model: { selected } };
+		},
+		Clear: () => model.selected.length === 0 ? { model } : { model: { selected: [] } }
+	})
+});
+export { SelectionSet, SelectionSetMessage, SelectionSetModel, isSelected };
+
+//# sourceMappingURL=selection.js.map

package/dist/state/selection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection.js","names":[],"sources":["../../src/state/selection.ts"],"sourcesContent":["import { Schema } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport { Bundle } from 'foldkit-bundle'\nimport { sameIds } from '../internal.js'\n\nexport const SelectionSetModel = Schema.Struct({ selected: Schema.Array(Schema.String) })\nexport type SelectionSetModel = typeof SelectionSetModel.Type\n\nexport const SelectionSetMessage = defineMessageUnion({\n  Select: { id: Schema.String },\n  Deselect: { id: Schema.String },\n  Toggle: { id: Schema.String },\n  ReplaceAll: { ids: Schema.Array(Schema.String) },\n  Clear: {},\n})\nexport type SelectionSetMessage = typeof SelectionSetMessage.Type\n\nconst without = (selected: ReadonlyArray<string>, id: string): ReadonlyArray<string> =>\n  selected.filter(other => other !== id)\n\n/** Whether the id is currently selected. */\nexport const isSelected = (model: SelectionSetModel, id: string): boolean =>\n  model.selected.includes(id)\n\n/**\n * A selection set as a bundle: the selected ids in the Model, changed one at\n * a time or replaced whole. Order follows first selection; toggling moves a\n * reselected id to the end. Pure logic, no streams.\n */\nexport const SelectionSet = Bundle.make('SelectionSet', {\n  Model: SelectionSetModel,\n  Message: SelectionSetMessage,\n  init: () => ({ model: { selected: [] } }),\n  update: (model, message) =>\n    SelectionSetMessage.match(message, {\n      Select: ({ id }) =>\n        isSelected(model, id) ? { model } : { model: { selected: [...model.selected, id] } },\n      Deselect: ({ id }) =>\n        isSelected(model, id) ? { model: { selected: without(model.selected, id) } } : { model },\n      Toggle: ({ id }) =>\n        isSelected(model, id)\n          ? { model: { selected: without(model.selected, id) } }\n          : { model: { selected: [...model.selected, id] } },\n      ReplaceAll: ({ ids }) => {\n        const selected = [...new Set(ids)]\n        return sameIds(selected, model.selected) ? { model } : { model: { selected } }\n      },\n      Clear: () => (model.selected.length === 0 ? { model } : { model: { selected: [] } }),\n    }),\n})\n"],"mappings":";;;;;AAKA,MAAa,oBAAoB,OAAO,OAAO,EAAE,UAAU,OAAO,MAAM,OAAO,MAAM,EAAE,CAAC;AAGxF,MAAa,sBAAsB,mBAAmB;CACpD,QAAQ,EAAE,IAAI,OAAO,OAAO;CAC5B,UAAU,EAAE,IAAI,OAAO,OAAO;CAC9B,QAAQ,EAAE,IAAI,OAAO,OAAO;CAC5B,YAAY,EAAE,KAAK,OAAO,MAAM,OAAO,MAAM,EAAE;CAC/C,OAAO,CAAC;AACV,CAAC;AAGD,MAAM,WAAW,UAAiC,OAChD,SAAS,QAAO,UAAS,UAAU,EAAE;;AAGvC,MAAa,cAAc,OAA0B,OACnD,MAAM,SAAS,SAAS,EAAE;;;;;;AAO5B,MAAa,eAAe,OAAO,KAAK,gBAAgB;CACtD,OAAO;CACP,SAAS;CACT,aAAa,EAAE,OAAO,EAAE,UAAU,CAAC,EAAE,EAAE;CACvC,SAAS,OAAO,YACd,oBAAoB,MAAM,SAAS;EACjC,SAAS,EAAE,SACT,WAAW,OAAO,EAAE,IAAI,EAAE,MAAM,IAAI,EAAE,OAAO,EAAE,UAAU,CAAC,GAAG,MAAM,UAAU,EAAE,EAAE,EAAE;EACrF,WAAW,EAAE,SACX,WAAW,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,UAAU,QAAQ,MAAM,UAAU,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM;EACzF,SAAS,EAAE,SACT,WAAW,OAAO,EAAE,IAChB,EAAE,OAAO,EAAE,UAAU,QAAQ,MAAM,UAAU,EAAE,EAAE,EAAE,IACnD,EAAE,OAAO,EAAE,UAAU,CAAC,GAAG,MAAM,UAAU,EAAE,EAAE,EAAE;EACrD,aAAa,EAAE,UAAU;GACvB,MAAM,WAAW,CAAC,GAAG,IAAI,IAAI,GAAG,CAAC;GACjC,OAAO,QAAQ,UAAU,MAAM,QAAQ,IAAI,EAAE,MAAM,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE;EAC/E;EACA,aAAc,MAAM,SAAS,WAAW,IAAI,EAAE,MAAM,IAAI,EAAE,OAAO,EAAE,UAAU,CAAC,EAAE,EAAE;CACpF,CAAC;AACL,CAAC"}

package/dist/state/virtual.d.ts

@@ -0,0 +1,201 @@
+import { Schema } from "effect";
+import { Bundle } from "foldkit-bundle";
+import * as Mount from "foldkit/mount";
+/** The rows to draw: a half-open range of indexes. */
+export interface VirtualWindow {
+  /** First visible row index, inclusive. */
+  readonly start: number;
+  /** End row index, exclusive. */
+  readonly end: number;
+}
+/** Layout constants: per-row estimate, inter-row gap, and end padding. */
+export interface VirtualLayout {
+  readonly estimatedHeight: number;
+  readonly gap: number;
+  readonly paddingStart: number;
+  readonly paddingEnd: number;
+}
+/** Total scrollable height: padding, measured rows, estimates, and gaps. */
+export declare const totalHeight: (keys: ReadonlyArray<string>, heights: Readonly<Record<string, number>>, layout: VirtualLayout) => number;
+/** Pixel offset of a row's top edge: padding plus the prefix before it. */
+export declare const offsetFor: (index: number, keys: ReadonlyArray<string>, heights: Readonly<Record<string, number>>, layout: VirtualLayout) => number;
+/**
+ * Which rows to render for a scroll position: the rows intersecting
+ * `[scrollTop, scrollTop + viewportHeight)`, widened by `overscan` on both
+ * sides and clamped to `[0, count]`. Gaps and padding are dead space — no
+ * row — so boxes are tested, not cumulative coverage. An overscan of zero
+ * renders exactly the visible rows.
+ */
+export declare const visibleRange: (keys: ReadonlyArray<string>, heights: Readonly<Record<string, number>>, layout: VirtualLayout, scrollTop: number, viewportHeight: number, overscan: number) => VirtualWindow;
+export declare const VirtualModel: Schema.Struct<{
+  readonly scrollTop: Schema.Number;
+  readonly heights: Schema.$Record<Schema.String, Schema.Number>;
+  readonly scrolling: Schema.Boolean;
+  readonly generation: Schema.Number;
+  readonly estimatedHeight: Schema.Number;
+  readonly overscan: Schema.Number;
+  readonly gap: Schema.Number;
+  readonly paddingStart: Schema.Number;
+  readonly paddingEnd: Schema.Number;
+}>;
+export type VirtualModel = typeof VirtualModel.Type;
+export declare const VirtualMessage: import("foldkit/message").MessageUnion<{
+  readonly Scrolled: {
+    top: Schema.Number;
+  };
+  readonly Measured: {
+    key: Schema.String;
+    height: Schema.Number;
+  };
+  /** Drops heights for keys no longer listed: the bundle never sees the key
+      order, so the application tells it what left. */
+  readonly Prune: {
+    keys: Schema.$Array<Schema.String>;
+  };
+  /** Fires when scrolling has been silent for `settleMs`: only the latest
+      generation counts, so a fling's intermediate timers emit nothing. */
+  readonly Settled: {
+    generation: Schema.Number;
+  };
+}>;
+export type VirtualMessage = typeof VirtualMessage.Type;
+/**
+ * The rows to render plus the spacer height, from the Model, the key order,
+ * and the viewport height. Layout and overscan come from the Model, so the
+ * call cannot disagree with the placement. Keys stay the application's:
+ * render each row keyed, and per-row placements keep identity.
+ */
+export declare const windowFor: (model: VirtualModel, keys: ReadonlyArray<string>, viewportHeight: number) => VirtualWindow & {
+  readonly totalHeight: number;
+};
+/**
+ * Pixels from the viewport's bottom edge to the content's end: negative
+ * past it, zero exactly there. Prefetch thresholds want this number ("load
+ * when within 500px"), not just the boolean below.
+ */
+export declare const distanceToEnd: (model: VirtualModel, keys: ReadonlyArray<string>, viewportHeight: number) => number;
+/**
+ * Whether the viewport rests at (or past) the end, within `threshold`
+ * pixels: the infinite-scroll check. An empty list counts as ended — there
+ * is nothing to scroll, so more should load. Thresholds below zero clamp
+ * to zero.
+ */
+export declare const isAtEnd: (model: VirtualModel, keys: ReadonlyArray<string>, viewportHeight: number, threshold?: number) => boolean;
+/**
+ * Windowing math for virtualized lists as pure functions: which rows to
+ * render, how tall the scrollable area is, and where each row starts. Row
+ * heights come from measured values with a per-row estimate fallback, so
+ * unmeasured rows still occupy space and measuring later only corrects.
+ * Keys are strings; heights are non-negative, and non-finite measurements
+ * fall back to the estimate instead of poisoning the sums.
+ *
+ * The `Virtual` bundle below owns the scroll position and the measured
+ * heights; `Viewport` reports container scrolls and `MeasureRow` reports
+ * row heights, both as Mounts on the elements they observe. The application
+ * renders `windowFor(...)` rows with its own views (keyed, so `each`
+ * placements keep identity) inside a spacer of `totalHeight(...)`.
+ */
+export declare const Virtual: Bundle.Bundle<"Virtual", {
+  readonly estimatedHeight: number;
+  readonly overscan: number;
+  readonly gap: number;
+  readonly paddingStart: number;
+  readonly paddingEnd: number;
+  readonly settleMs?: number | undefined;
+  readonly initialScrollTop?: number | undefined;
+  readonly initialHeights?: {
+    readonly [x: string]: number;
+  } | undefined;
+}, {
+  readonly scrollTop: number;
+  readonly heights: {
+    readonly [x: string]: number;
+  };
+  readonly scrolling: boolean;
+  readonly generation: number;
+  readonly estimatedHeight: number;
+  readonly overscan: number;
+  readonly gap: number;
+  readonly paddingStart: number;
+  readonly paddingEnd: number;
+}, {
+  readonly _tag: "Measured";
+  readonly key: string;
+  readonly height: number;
+} | {
+  readonly _tag: "Prune";
+  readonly keys: readonly string[];
+} | {
+  readonly _tag: "Scrolled";
+  readonly top: number;
+} | {
+  readonly _tag: "Settled";
+  readonly generation: number;
+}, never, never, never, void, {}, {}>;
+export declare const ViewportScrolled: Schema.TaggedStruct<"ViewportScrolled", {
+  readonly top: Schema.Number;
+}>;
+export type ViewportScrolled = typeof ViewportScrolled.Type;
+/**
+ * The scroll container's position, reported on its own scrolls starting
+ * with the current one. Attach to the scrolling element — viewport scrolls
+ * arrive through the window-level scroll entry instead.
+ */
+export declare const Viewport: Mount.MountDefinitionNoArgs<"Viewport", {
+  readonly _tag: "ViewportScrolled";
+  readonly top: number;
+}>;
+export declare const RowMeasured: Schema.TaggedStruct<"RowMeasured", {
+  readonly key: Schema.String;
+  readonly height: Schema.Number;
+}>;
+export type RowMeasured = typeof RowMeasured.Type;
+/**
+ * One row's height, reported on every resize starting with the current
+ * one. The key is the application's row identity, echoed back so the
+ * parent files the height without tracking which Mount sent what.
+ */
+export declare const MeasureRow: Mount.MountDefinitionWithArgs<"MeasureRow", {
+  key: Schema.String;
+}, {
+  readonly _tag: "RowMeasured";
+  readonly key: string;
+  readonly height: number;
+}>;
+/**
+ * Which section header sticks for a window: the last section starting at
+ * or before the first rendered row, or null above the first section. Order
+ * independent — the scan takes the maximum, so unsorted input still
+ * answers. CSS `position: sticky` does the sticking; this answers *what*
+ * sticks, for styling and callbacks.
+ */
+export declare const stickyHeader: (sections: ReadonlyArray<{
+  readonly key: string;
+  readonly index: number;
+}>, startIndex: number) => string | null;
+/** Where `masonry` puts one item: its column and its box, in pixels. */
+export interface MasonryPlacement {
+  readonly key: string;
+  readonly column: number;
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+}
+/**
+ * Masonry layout as a pure function: fixed column count and width, each
+ * item packed into the currently shortest column. Unmeasured items use the
+ * estimate; poisoned heights fall back the same way. This is layout only,
+ * not windowing — every placed item renders, so it fits hundreds of images,
+ * not hundred-thousands. Needing a windowed grid is a different algorithm.
+ */
+export declare const masonry: (keys: ReadonlyArray<string>, heights: Readonly<Record<string, number>>, options: {
+  readonly columns: number;
+  readonly columnWidth: number;
+  readonly gap: number;
+  readonly estimatedHeight: number;
+}) => {
+  readonly placements: ReadonlyArray<MasonryPlacement>;
+  readonly totalHeight: number;
+};
+//# sourceMappingURL=virtual.d.ts.map

package/dist/state/virtual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"virtual.d.ts","names":[],"sources":["../../src/state/virtual.ts"],"mappings":";;;;iBAOiB;;WAEN;;WAEA;;;iBAIM;WACN;WACA;WACA;WACA;;;qBAmEE,cAAW,MAChB,uBAAqB,SAClB,SAAS,yBAAuB,QACjC;;qBAcG,YAAS,eACP,MACP,uBAAqB,SAClB,SAAS,yBAAuB,QACjC;;;;;;;;qBAUG,eAAY,MACjB,uBAAqB,SAClB,SAAS,yBAAuB,QACjC,eAAa,mBACJ,wBACK,qBAErB;qBAmBU,cAAY,OAAA;;;;;;;;;;;YAWb,sBAAsB,aAAa;qBAElC,0CAAc;;IACb,KAAG,OAAA;;;IACH,KAAG,OAAA;IAAiB,QAAM,OAAA;;;;;IAG7B,MAAI,OAAA,OAAA,OAAA;;;;;IAGF,YAAU,OAAA;;;YAEX,wBAAwB,eAAe;;;;;;;qBAetC,YAAS,OACb,cAAY,MACb,uBAAqB,2BAE1B;WAA2B;;;;;;;qBAkBjB,gBAAa,OACjB,cAAY,MACb,uBAAqB;;;;;;;qBAahB,UAAO,OACX,cAAY,MACb,uBAAqB,wBACL;;;;;;;;;;;;;;;qBA2BX,SAAO,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAuGP,kBAAgB,OAAA;;;YACjB,0BAA0B,iBAAiB;;;;;;qBAO1C,UAAQ,MAAA;;;;qBAeR,aAAW,OAAA;;;;YAIZ,qBAAqB,YAAY;;;;;;qBAShC,YAAU,MAAA;;;;;;;;;;;;;;qBAgCV,eAAY,UACb;WAAyB;WAAsB;IAAgB;;iBAe1D;WACN;WACA;WACA;WACA;WACA;WACA;;;;;;;;;qBAUE,UAAO,MACZ,uBAAqB,SAClB,SAAS,yBAAuB;WAE9B;WACA;WACA;WACA;;WAEC,YAAY,cAAc;WAA4B"}