foldkit-primitives 0.15.3 → 0.16.0

package/dist/observers/mutation.js

@@ -0,0 +1,53 @@
+import { Effect, Queue, Schema, Stream } from "effect";
+import * as Mount from "foldkit/mount";
+// src/observers/mutation.ts
+const Mutated = Schema.TaggedStruct("Mutated", {
+	type: Schema.Literals([
+		"childList",
+		"attributes",
+		"characterData"
+	]),
+	added: Schema.Array(Schema.String),
+	removed: Schema.Array(Schema.String),
+	attribute: Schema.NullOr(Schema.String)
+});
+const recordType = (type) => type === "childList" || type === "attributes" || type === "characterData" ? type : null;
+/**
+* DOM mutations as a Mount: MutationObserver reports child, attribute, and
+* text changes as Messages for the element carrying this Mount. Nodes cross
+* as their names (serializable); the live nodes stay in the DOM, never in
+* the Model. No observer (SSR, old browser) emits nothing instead of
+* throwing. Observes the whole subtree — narrow by placing on a smaller
+* element, not by options.
+*/
+const Mutation = Mount.defineStream("Mutation", {
+	messages: [Mutated],
+	execute: ({ element }) => Stream.callback((queue) => Effect.gen(function* () {
+		const Observed = globalThis.MutationObserver;
+		if (Observed === void 0) return;
+		yield* Effect.acquireRelease(Effect.sync(() => {
+			const observer = new Observed((records) => {
+				for (const record of records) {
+					const type = recordType(record.type);
+					if (type === null) continue;
+					Queue.offerUnsafe(queue, Mutated.make({
+						type,
+						added: type === "childList" ? Array.from(record.addedNodes, (node) => node.nodeName) : [],
+						removed: type === "childList" ? Array.from(record.removedNodes, (node) => node.nodeName) : [],
+						attribute: type === "attributes" ? record.attributeName ?? null : null
+					}));
+				}
+			});
+			observer.observe(element, {
+				childList: true,
+				attributes: true,
+				characterData: true,
+				subtree: true
+			});
+			return observer;
+		}), (observer) => Effect.sync(() => observer.disconnect()));
+	}))
+});
+export { Mutated, Mutation };
+
+//# sourceMappingURL=mutation.js.map

package/dist/observers/mutation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation.js","names":[],"sources":["../../src/observers/mutation.ts"],"sourcesContent":["import { Effect, Queue, Schema, Stream } from 'effect'\nimport * as Mount from 'foldkit/mount'\n\nexport const Mutated = Schema.TaggedStruct('Mutated', {\n  type: Schema.Literals(['childList', 'attributes', 'characterData']),\n  added: Schema.Array(Schema.String),\n  removed: Schema.Array(Schema.String),\n  attribute: Schema.NullOr(Schema.String),\n})\nexport type Mutated = typeof Mutated.Type\n\ntype ObserverCtor = new (callback: MutationCallback) => MutationObserver\n\nconst recordType = (type: string): Mutated['type'] | null =>\n  type === 'childList' || type === 'attributes' || type === 'characterData' ? type : null\n\n/**\n * DOM mutations as a Mount: MutationObserver reports child, attribute, and\n * text changes as Messages for the element carrying this Mount. Nodes cross\n * as their names (serializable); the live nodes stay in the DOM, never in\n * the Model. No observer (SSR, old browser) emits nothing instead of\n * throwing. Observes the whole subtree — narrow by placing on a smaller\n * element, not by options.\n */\nexport const Mutation = Mount.defineStream('Mutation', {\n  messages: [Mutated],\n  execute: ({ element }) =>\n    Stream.callback<typeof Mutated.Type>(queue =>\n      Effect.gen(function* () {\n        const Observed = (globalThis as { MutationObserver?: ObserverCtor }).MutationObserver\n        if (Observed === undefined) return\n        yield* Effect.acquireRelease(\n          Effect.sync(() => {\n            const observer = new Observed(records => {\n              for (const record of records) {\n                const type = recordType(record.type)\n                if (type === null) continue\n                Queue.offerUnsafe(\n                  queue,\n                  Mutated.make({\n                    type,\n                    added:\n                      type === 'childList'\n                        ? Array.from(record.addedNodes, node => node.nodeName)\n                        : [],\n                    removed:\n                      type === 'childList'\n                        ? Array.from(record.removedNodes, node => node.nodeName)\n                        : [],\n                    attribute: type === 'attributes' ? (record.attributeName ?? null) : null,\n                  }),\n                )\n              }\n            })\n            observer.observe(element, {\n              childList: true,\n              attributes: true,\n              characterData: true,\n              subtree: true,\n            })\n            return observer\n          }),\n          observer => Effect.sync(() => observer.disconnect()),\n        )\n      }),\n    ),\n})\n"],"mappings":";;;AAGA,MAAa,UAAU,OAAO,aAAa,WAAW;CACpD,MAAM,OAAO,SAAS;EAAC;EAAa;EAAc;CAAe,CAAC;CAClE,OAAO,OAAO,MAAM,OAAO,MAAM;CACjC,SAAS,OAAO,MAAM,OAAO,MAAM;CACnC,WAAW,OAAO,OAAO,OAAO,MAAM;AACxC,CAAC;AAKD,MAAM,cAAc,SAClB,SAAS,eAAe,SAAS,gBAAgB,SAAS,kBAAkB,OAAO;;;;;;;;;AAUrF,MAAa,WAAW,MAAM,aAAa,YAAY;CACrD,UAAU,CAAC,OAAO;CAClB,UAAU,EAAE,cACV,OAAO,UAA8B,UACnC,OAAO,IAAI,aAAa;EACtB,MAAM,WAAY,WAAmD;EACrE,IAAI,aAAa,KAAA,GAAW;EAC5B,OAAO,OAAO,eACZ,OAAO,WAAW;GAChB,MAAM,WAAW,IAAI,UAAS,YAAW;IACvC,KAAK,MAAM,UAAU,SAAS;KAC5B,MAAM,OAAO,WAAW,OAAO,IAAI;KACnC,IAAI,SAAS,MAAM;KACnB,MAAM,YACJ,OACA,QAAQ,KAAK;MACX;MACA,OACE,SAAS,cACL,MAAM,KAAK,OAAO,aAAY,SAAQ,KAAK,QAAQ,IACnD,CAAC;MACP,SACE,SAAS,cACL,MAAM,KAAK,OAAO,eAAc,SAAQ,KAAK,QAAQ,IACrD,CAAC;MACP,WAAW,SAAS,eAAgB,OAAO,iBAAiB,OAAQ;KACtE,CAAC,CACH;IACF;GACF,CAAC;GACD,SAAS,QAAQ,SAAS;IACxB,WAAW;IACX,YAAY;IACZ,eAAe;IACf,SAAS;GACX,CAAC;GACD,OAAO;EACT,CAAC,IACD,aAAY,OAAO,WAAW,SAAS,WAAW,CAAC,CACrD;CACF,CAAC,CACH;AACJ,CAAC"}

package/dist/observers/resize.d.ts

@@ -0,0 +1,18 @@
+import { Schema } from "effect";
+import * as Mount from "foldkit/mount";
+export declare const Resized: Schema.TaggedStruct<"Resized", {
+  readonly width: Schema.Number;
+  readonly height: Schema.Number;
+}>;
+export type Resized = typeof Resized.Type;
+/**
+ * Element size as a Mount: ResizeObserver reports content-box changes as
+ * Messages for the element carrying this Mount. No observer (SSR, old
+ * browser) emits nothing instead of throwing.
+ */
+export declare const Resize: Mount.MountDefinitionNoArgs<"Resize", {
+  readonly _tag: "Resized";
+  readonly width: number;
+  readonly height: number;
+}>;
+//# sourceMappingURL=resize.d.ts.map

package/dist/observers/resize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resize.d.ts","names":[],"sources":["../../src/observers/resize.ts"],"mappings":";;qBAGa,SAAO,OAAA;;;;YAIR,iBAAiB,QAAQ;;;;;;qBASxB,QAAM,MAAA"}

package/dist/observers/resize.js

@@ -0,0 +1,33 @@
+import { Effect, Queue, Schema, Stream } from "effect";
+import * as Mount from "foldkit/mount";
+// src/observers/resize.ts
+const Resized = Schema.TaggedStruct("Resized", {
+	width: Schema.Number,
+	height: Schema.Number
+});
+/**
+* Element size as a Mount: ResizeObserver reports content-box changes as
+* Messages for the element carrying this Mount. No observer (SSR, old
+* browser) emits nothing instead of throwing.
+*/
+const Resize = Mount.defineStream("Resize", {
+	messages: [Resized],
+	execute: ({ element }) => Stream.callback((queue) => Effect.gen(function* () {
+		const Observed = globalThis.ResizeObserver;
+		if (Observed === void 0) return;
+		yield* Effect.acquireRelease(Effect.sync(() => {
+			const observer = new Observed((entries) => {
+				const rect = entries[0]?.contentRect;
+				if (rect !== void 0) Queue.offerUnsafe(queue, Resized.make({
+					width: rect.width,
+					height: rect.height
+				}));
+			});
+			observer.observe(element);
+			return observer;
+		}), (observer) => Effect.sync(() => observer.disconnect()));
+	}))
+});
+export { Resize, Resized };
+
+//# sourceMappingURL=resize.js.map

package/dist/observers/resize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resize.js","names":[],"sources":["../../src/observers/resize.ts"],"sourcesContent":["import { Effect, Queue, Schema, Stream } from 'effect'\nimport * as Mount from 'foldkit/mount'\n\nexport const Resized = Schema.TaggedStruct('Resized', {\n  width: Schema.Number,\n  height: Schema.Number,\n})\nexport type Resized = typeof Resized.Type\n\ntype ObserverCtor = new (callback: ResizeObserverCallback) => ResizeObserver\n\n/**\n * Element size as a Mount: ResizeObserver reports content-box changes as\n * Messages for the element carrying this Mount. No observer (SSR, old\n * browser) emits nothing instead of throwing.\n */\nexport const Resize = Mount.defineStream('Resize', {\n  messages: [Resized],\n  execute: ({ element }) =>\n    Stream.callback<typeof Resized.Type>(queue =>\n      Effect.gen(function* () {\n        const Observed = (globalThis as { ResizeObserver?: ObserverCtor }).ResizeObserver\n        if (Observed === undefined) return\n        yield* Effect.acquireRelease(\n          Effect.sync(() => {\n            const observer = new Observed(entries => {\n              const rect = entries[0]?.contentRect\n              if (rect !== undefined) {\n                Queue.offerUnsafe(queue, Resized.make({ width: rect.width, height: rect.height }))\n              }\n            })\n            observer.observe(element)\n            return observer\n          }),\n          observer => Effect.sync(() => observer.disconnect()),\n        )\n      }),\n    ),\n})\n"],"mappings":";;;AAGA,MAAa,UAAU,OAAO,aAAa,WAAW;CACpD,OAAO,OAAO;CACd,QAAQ,OAAO;AACjB,CAAC;;;;;;AAUD,MAAa,SAAS,MAAM,aAAa,UAAU;CACjD,UAAU,CAAC,OAAO;CAClB,UAAU,EAAE,cACV,OAAO,UAA8B,UACnC,OAAO,IAAI,aAAa;EACtB,MAAM,WAAY,WAAiD;EACnE,IAAI,aAAa,KAAA,GAAW;EAC5B,OAAO,OAAO,eACZ,OAAO,WAAW;GAChB,MAAM,WAAW,IAAI,UAAS,YAAW;IACvC,MAAM,OAAO,QAAQ,EAAE,EAAE;IACzB,IAAI,SAAS,KAAA,GACX,MAAM,YAAY,OAAO,QAAQ,KAAK;KAAE,OAAO,KAAK;KAAO,QAAQ,KAAK;IAAO,CAAC,CAAC;GAErF,CAAC;GACD,SAAS,QAAQ,OAAO;GACxB,OAAO;EACT,CAAC,IACD,aAAY,OAAO,WAAW,SAAS,WAAW,CAAC,CACrD;CACF,CAAC,CACH;AACJ,CAAC"}

package/dist/state/history.d.ts

@@ -0,0 +1,115 @@
+import { Schema } from "effect";
+import { Bundle } from "foldkit-bundle";
+export declare const HistoryModel: <Value>(value: Schema.Codec<Value, unknown>) => Schema.Struct<{
+  readonly past: Schema.$Array<Schema.Codec<Value, unknown, never, never>>;
+  readonly present: Schema.Codec<Value, unknown, never, never>;
+  readonly future: Schema.$Array<Schema.Codec<Value, unknown, never, never>>;
+  /** The group of the last push, so the next push of the same group joins it; `null` for none. */
+  readonly group: Schema.NullOr<Schema.String>;
+}>;
+export type HistoryModel<Value> = {
+  readonly past: ReadonlyArray<Value>;
+  readonly present: Value;
+  readonly future: ReadonlyArray<Value>;
+  readonly group: string | null;
+};
+declare const start: <Value>(present: Value) => HistoryModel<Value>;
+declare const push: <Value>(model: HistoryModel<Value>, value: Value, options: {
+  readonly capacity: number;
+  readonly group?: string | null | undefined;
+}) => HistoryModel<Value>;
+declare const undo: <Value>(model: HistoryModel<Value>) => HistoryModel<Value>;
+declare const redo: <Value>(model: HistoryModel<Value>) => HistoryModel<Value>;
+declare const goTo: <Value>(model: HistoryModel<Value>, step: number) => HistoryModel<Value>;
+declare const clear: <Value>(model: HistoryModel<Value>) => HistoryModel<Value>;
+declare const close: <Value>(model: HistoryModel<Value>) => HistoryModel<Value>;
+declare const revert: <Value>(model: HistoryModel<Value>, group: string) => HistoryModel<Value>;
+/** Whether Undo would move: the past is non-empty. */
+export declare const canUndo: <Value>(model: HistoryModel<Value>) => boolean;
+/** Whether Redo would move: the future is non-empty. */
+export declare const canRedo: <Value>(model: HistoryModel<Value>) => boolean;
+/** The steps of a history as pure functions of its Model. */
+export declare const History: {
+  /** A history whose present is `value`, with nothing to undo. */
+  start: typeof start;
+  /** Records `value` as the present; the same `group` as the last push joins its step. */
+  push: typeof push;
+  /** One step back, or the Model as it was when there is none. */
+  undo: typeof undo;
+  /** One step forward, or the Model as it was when there is none. */
+  redo: typeof redo;
+  /**
+   * The value at `step` made the present, counting every kept value from the
+   * oldest (0), so the present is at `past.length`: what a click on a step's
+   * thumbnail does. The Model as it was for the present or a step not kept.
+   */
+  goTo: typeof goTo;
+  /** Nothing to undo or redo, the present kept. */
+  clear: typeof clear;
+  /** The next push starts a step of its own, whatever its group: a group ends here. */
+  close: typeof close;
+  /**
+   * The step `group` is making taken back, and not redoable: what a cancelled
+   * edit, or one that ended where it began, leaves. The Model as it was when
+   * the last push was not of `group`. What the group's first push dropped
+   * stays dropped: the redo future it cleared, and an entry capacity evicted;
+   * with a capacity of 0 nothing was kept, so the present stays and only the
+   * group ends.
+   */
+  revert: typeof revert;
+  canUndo: typeof canUndo;
+  canRedo: typeof canRedo;
+};
+/**
+ * Undo/redo as a bundle factory: the past, present, and future of one value
+ * live in the Model, so every step replays. Pushing records, even an unchanged
+ * value; skipping duplicates is the application's policy, not the stack's.
+ *
+ * A push may name a `group`. Consecutive pushes of the same group are one step:
+ * the present moves and nothing new is recorded, so typing a word undoes as a
+ * whole. Grouping needs no clock; the application names what belongs together.
+ *
+ * The steps are also pure functions (`History.push`, `undo`, `redo`, `goTo`, `clear`),
+ * for a parent that records an edit in the same transition that makes it
+ * rather than dispatching a Message to a placed bundle.
+ */
+export declare const history: <const Name extends string, Value>(config: {
+  readonly name: Name;
+  readonly value: Schema.Codec<Value, unknown>;
+  readonly capacity?: number | undefined;
+}) => Bundle.Bundle<Name, {
+  readonly initial: Value;
+}, {
+  readonly past: readonly Value[];
+  readonly present: Value;
+  readonly future: readonly Value[];
+  readonly group: string | null;
+}, {
+  readonly _tag: "Clear";
+} | {
+  readonly _tag: "GoTo";
+  readonly step: number;
+} | {
+  readonly _tag: "Push";
+  readonly value: Value;
+  readonly group?: string | undefined;
+} | {
+  readonly _tag: "Redo";
+} | {
+  readonly _tag: "Undo";
+}, never, never, never, void, {}, {}> & {
+  Message: import("foldkit/message").MessageUnion<{
+    readonly Push: {
+      value: Schema.Codec<Value, unknown, never, never>;
+      group: Schema.optional<Schema.String>;
+    };
+    readonly Undo: {};
+    readonly Redo: {};
+    readonly GoTo: {
+      step: Schema.Number;
+    };
+    readonly Clear: {};
+  }>;
+};
+export {};
+//# sourceMappingURL=history.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"history.d.ts","names":[],"sources":["../../src/state/history.ts"],"mappings":";;qBAIa,eAAgB,OAAK,OAAS,OAAO,MAAM,oBAAe,OAAA;;;;;;;YAQ3D,aAAa;WACd,MAAM,cAAc;WACpB,SAAS;WACT,QAAQ,cAAc;WACtB;;cAGL,QAAS,OAAK,SAAW,UAAQ,aAAa;cAe9C,OAAQ,OAAK,OACV,aAAa,QAAM,OACnB,OAAK;WACQ;WAA2B;MAC9C,aAAa;cAcV,OAAQ,OAAK,OAAS,aAAa,WAAS,aAAa;cAWzD,OAAQ,OAAK,OAAS,aAAa,WAAS,aAAa;cAWzD,OAAQ,OAAK,OAAS,aAAa,QAAM,iBAAiB,aAAa;cAYvE,QAAS,OAAK,OAAS,aAAa,WAAS,aAAa;cAK1D,QAAS,OAAK,OAAS,aAAa,WAAS,aAAa;cAG1D,SAAU,OAAK,OAAS,aAAa,QAAM,kBAAkB,aAAa;;qBAanE,UAAW,OAAK,OAAS,aAAa;;qBAGtC,UAAW,OAAK,OAAS,aAAa;;qBAGtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA6CA,gBAAiB,qBAAqB,OAAK;WAC7C,MAAM;WACN,OAAO,OAAO,MAAM;WACpB;MACV,OAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;MAIW,OAAK,OAAA,MAAA;MAAgB,OAAK,OAAA,SAAA,OAAA;;;;;MAG1B,MAAI,OAAA"}

package/dist/state/history.js

@@ -0,0 +1,167 @@
+import { Schema } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+import { Bundle } from "foldkit-bundle";
+// src/state/history.ts
+const HistoryModel = (value) => Schema.Struct({
+	past: Schema.Array(value),
+	present: value,
+	future: Schema.Array(value),
+	/** The group of the last push, so the next push of the same group joins it; `null` for none. */
+	group: Schema.NullOr(Schema.String)
+});
+const start = (present) => ({
+	past: [],
+	present,
+	future: [],
+	group: null
+});
+/**
+* No redo steps, keeping an already empty future: a view that reads the
+* future compares it by identity, so a push per keystroke or stroke cell
+* must not hand it a new empty array each time.
+*/
+const noFuture = (model) => model.future.length === 0 ? model.future : [];
+const push = (model, value, options) => {
+	const group = options.group ?? null;
+	if (group !== null && group === model.group && model.past.length > 0) return {
+		...model,
+		present: value,
+		future: noFuture(model)
+	};
+	return {
+		past: options.capacity === 0 ? [] : [...model.past, model.present].slice(-options.capacity),
+		present: value,
+		future: noFuture(model),
+		group
+	};
+};
+const undo = (model) => {
+	const previous = model.past[model.past.length - 1];
+	if (previous === void 0) return model;
+	return {
+		past: model.past.slice(0, -1),
+		present: previous,
+		future: [model.present, ...model.future],
+		group: null
+	};
+};
+const redo = (model) => {
+	const next = model.future[0];
+	if (next === void 0) return model;
+	return {
+		past: [...model.past, model.present],
+		present: next,
+		future: model.future.slice(1),
+		group: null
+	};
+};
+const goTo = (model, step) => {
+	const steps = [
+		...model.past,
+		model.present,
+		...model.future
+	];
+	if (!Number.isInteger(step) || step < 0 || step >= steps.length || step === model.past.length) return model;
+	return {
+		past: steps.slice(0, step),
+		present: steps[step],
+		future: steps.slice(step + 1),
+		group: null
+	};
+};
+const clear = (model) => model.past.length === 0 && model.future.length === 0 && model.group === null ? model : start(model.present);
+const close = (model) => model.group === null ? model : {
+	...model,
+	group: null
+};
+const revert = (model, group) => model.group === group ? {
+	...undo(model),
+	future: [],
+	group: null
+} : model;
+const checkCapacity = (name, capacity) => {
+	if (!Number.isInteger(capacity) || capacity < 0) throw new Error(`History "${name}": capacity must be a non-negative integer`);
+	return capacity;
+};
+/** Whether Undo would move: the past is non-empty. */
+const canUndo = (model) => model.past.length > 0;
+/** Whether Redo would move: the future is non-empty. */
+const canRedo = (model) => model.future.length > 0;
+/** The steps of a history as pure functions of its Model. */
+const History = {
+	/** A history whose present is `value`, with nothing to undo. */
+	start,
+	/** Records `value` as the present; the same `group` as the last push joins its step. */
+	push,
+	/** One step back, or the Model as it was when there is none. */
+	undo,
+	/** One step forward, or the Model as it was when there is none. */
+	redo,
+	/**
+	* The value at `step` made the present, counting every kept value from the
+	* oldest (0), so the present is at `past.length`: what a click on a step's
+	* thumbnail does. The Model as it was for the present or a step not kept.
+	*/
+	goTo,
+	/** Nothing to undo or redo, the present kept. */
+	clear,
+	/** The next push starts a step of its own, whatever its group: a group ends here. */
+	close,
+	/**
+	* The step `group` is making taken back, and not redoable: what a cancelled
+	* edit, or one that ended where it began, leaves. The Model as it was when
+	* the last push was not of `group`. What the group's first push dropped
+	* stays dropped: the redo future it cleared, and an entry capacity evicted;
+	* with a capacity of 0 nothing was kept, so the present stays and only the
+	* group ends.
+	*/
+	revert,
+	canUndo,
+	canRedo
+};
+/**
+* Undo/redo as a bundle factory: the past, present, and future of one value
+* live in the Model, so every step replays. Pushing records, even an unchanged
+* value; skipping duplicates is the application's policy, not the stack's.
+*
+* A push may name a `group`. Consecutive pushes of the same group are one step:
+* the present moves and nothing new is recorded, so typing a word undoes as a
+* whole. Grouping needs no clock; the application names what belongs together.
+*
+* The steps are also pure functions (`History.push`, `undo`, `redo`, `goTo`, `clear`),
+* for a parent that records an edit in the same transition that makes it
+* rather than dispatching a Message to a placed bundle.
+*/
+const history = (config) => {
+	const capacity = checkCapacity(config.name, config.capacity ?? 100);
+	const Model = HistoryModel(config.value);
+	const Message = defineMessageUnion({
+		Push: {
+			value: config.value,
+			group: Schema.optional(Schema.String)
+		},
+		Undo: {},
+		Redo: {},
+		GoTo: { step: Schema.Number },
+		Clear: {}
+	});
+	return Object.assign(Bundle.make(config.name, {
+		Model,
+		Message,
+		args: Schema.Struct({ initial: config.value }),
+		init: (args) => ({ model: start(args.initial) }),
+		update: (model, message) => Message.match(message, {
+			Push: ({ value, group }) => ({ model: push(model, value, {
+				capacity,
+				group
+			}) }),
+			Undo: () => ({ model: undo(model) }),
+			Redo: () => ({ model: redo(model) }),
+			GoTo: ({ step }) => ({ model: goTo(model, step) }),
+			Clear: () => ({ model: clear(model) })
+		})
+	}), { Message });
+};
+export { History, HistoryModel, canRedo, canUndo, history };
+
+//# sourceMappingURL=history.js.map

package/dist/state/history.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.js","names":[],"sources":["../../src/state/history.ts"],"sourcesContent":["import { Schema } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport { Bundle } from 'foldkit-bundle'\n\nexport const HistoryModel = <Value>(value: Schema.Codec<Value, unknown>) =>\n  Schema.Struct({\n    past: Schema.Array(value),\n    present: value,\n    future: Schema.Array(value),\n    /** The group of the last push, so the next push of the same group joins it; `null` for none. */\n    group: Schema.NullOr(Schema.String),\n  })\nexport type HistoryModel<Value> = {\n  readonly past: ReadonlyArray<Value>\n  readonly present: Value\n  readonly future: ReadonlyArray<Value>\n  readonly group: string | null\n}\n\nconst start = <Value>(present: Value): HistoryModel<Value> => ({\n  past: [],\n  present,\n  future: [],\n  group: null,\n})\n\n/**\n * No redo steps, keeping an already empty future: a view that reads the\n * future compares it by identity, so a push per keystroke or stroke cell\n * must not hand it a new empty array each time.\n */\nconst noFuture = <Value>(model: HistoryModel<Value>): ReadonlyArray<Value> =>\n  model.future.length === 0 ? model.future : []\n\nconst push = <Value>(\n  model: HistoryModel<Value>,\n  value: Value,\n  options: { readonly capacity: number; readonly group?: string | null | undefined },\n): HistoryModel<Value> => {\n  const group = options.group ?? null\n  // The same group again joins the last step: the present moves, the past stays.\n  if (group !== null && group === model.group && model.past.length > 0)\n    return { ...model, present: value, future: noFuture(model) }\n  return {\n    // slice(-0) is slice(0): a zero capacity keeps nothing, explicitly.\n    past: options.capacity === 0 ? [] : [...model.past, model.present].slice(-options.capacity),\n    present: value,\n    future: noFuture(model),\n    group,\n  }\n}\n\nconst undo = <Value>(model: HistoryModel<Value>): HistoryModel<Value> => {\n  const previous = model.past[model.past.length - 1]\n  if (previous === undefined) return model\n  return {\n    past: model.past.slice(0, -1),\n    present: previous,\n    future: [model.present, ...model.future],\n    group: null,\n  }\n}\n\nconst redo = <Value>(model: HistoryModel<Value>): HistoryModel<Value> => {\n  const next = model.future[0]\n  if (next === undefined) return model\n  return {\n    past: [...model.past, model.present],\n    present: next,\n    future: model.future.slice(1),\n    group: null,\n  }\n}\n\nconst goTo = <Value>(model: HistoryModel<Value>, step: number): HistoryModel<Value> => {\n  const steps = [...model.past, model.present, ...model.future]\n  if (!Number.isInteger(step) || step < 0 || step >= steps.length || step === model.past.length)\n    return model\n  return {\n    past: steps.slice(0, step),\n    present: steps[step]!,\n    future: steps.slice(step + 1),\n    group: null,\n  }\n}\n\nconst clear = <Value>(model: HistoryModel<Value>): HistoryModel<Value> =>\n  model.past.length === 0 && model.future.length === 0 && model.group === null\n    ? model\n    : start(model.present)\n\nconst close = <Value>(model: HistoryModel<Value>): HistoryModel<Value> =>\n  model.group === null ? model : { ...model, group: null }\n\nconst revert = <Value>(model: HistoryModel<Value>, group: string): HistoryModel<Value> =>\n  // The group is ended even where there is nothing to take back (capacity 0).\n  model.group === group ? { ...undo(model), future: [], group: null } : model\n\nconst checkCapacity = (name: string, capacity: number): number => {\n  // A negative or fractional capacity would silently keep a wrong-sized past;\n  // fail where it is given, naming the caller, instead.\n  if (!Number.isInteger(capacity) || capacity < 0)\n    throw new Error(`History \"${name}\": capacity must be a non-negative integer`)\n  return capacity\n}\n\n/** Whether Undo would move: the past is non-empty. */\nexport const canUndo = <Value>(model: HistoryModel<Value>): boolean => model.past.length > 0\n\n/** Whether Redo would move: the future is non-empty. */\nexport const canRedo = <Value>(model: HistoryModel<Value>): boolean => model.future.length > 0\n\n/** The steps of a history as pure functions of its Model. */\nexport const History = {\n  /** A history whose present is `value`, with nothing to undo. */\n  start,\n  /** Records `value` as the present; the same `group` as the last push joins its step. */\n  push,\n  /** One step back, or the Model as it was when there is none. */\n  undo,\n  /** One step forward, or the Model as it was when there is none. */\n  redo,\n  /**\n   * The value at `step` made the present, counting every kept value from the\n   * oldest (0), so the present is at `past.length`: what a click on a step's\n   * thumbnail does. The Model as it was for the present or a step not kept.\n   */\n  goTo,\n  /** Nothing to undo or redo, the present kept. */\n  clear,\n  /** The next push starts a step of its own, whatever its group: a group ends here. */\n  close,\n  /**\n   * The step `group` is making taken back, and not redoable: what a cancelled\n   * edit, or one that ended where it began, leaves. The Model as it was when\n   * the last push was not of `group`. What the group's first push dropped\n   * stays dropped: the redo future it cleared, and an entry capacity evicted;\n   * with a capacity of 0 nothing was kept, so the present stays and only the\n   * group ends.\n   */\n  revert,\n  canUndo,\n  canRedo,\n}\n\n/**\n * Undo/redo as a bundle factory: the past, present, and future of one value\n * live in the Model, so every step replays. Pushing records, even an unchanged\n * value; skipping duplicates is the application's policy, not the stack's.\n *\n * A push may name a `group`. Consecutive pushes of the same group are one step:\n * the present moves and nothing new is recorded, so typing a word undoes as a\n * whole. Grouping needs no clock; the application names what belongs together.\n *\n * The steps are also pure functions (`History.push`, `undo`, `redo`, `goTo`, `clear`),\n * for a parent that records an edit in the same transition that makes it\n * rather than dispatching a Message to a placed bundle.\n */\nexport const history = <const Name extends string, Value>(config: {\n  readonly name: Name\n  readonly value: Schema.Codec<Value, unknown>\n  readonly capacity?: number | undefined\n}) => {\n  const capacity = checkCapacity(config.name, config.capacity ?? 100)\n  const Model = HistoryModel(config.value)\n  const Message = defineMessageUnion({\n    Push: { value: config.value, group: Schema.optional(Schema.String) },\n    Undo: {},\n    Redo: {},\n    GoTo: { step: Schema.Number },\n    Clear: {},\n  })\n  return Object.assign(\n    Bundle.make(config.name, {\n      Model,\n      Message,\n      args: Schema.Struct({ initial: config.value }),\n      init: args => ({ model: start(args.initial) }),\n      update: (model, message) =>\n        Message.match(message, {\n          Push: ({ value, group }) => ({ model: push(model, value, { capacity, group }) }),\n          Undo: () => ({ model: undo(model) }),\n          Redo: () => ({ model: redo(model) }),\n          GoTo: ({ step }) => ({ model: goTo(model, step) }),\n          Clear: () => ({ model: clear(model) }),\n        }),\n    }),\n    // The union object is both the Message codec and its constructors, so a\n    // placement dispatches `EditHistory.Message.Push(...)` like any bundle's\n    // exported Message.\n    { Message },\n  )\n}\n"],"mappings":";;;;AAIA,MAAa,gBAAuB,UAClC,OAAO,OAAO;CACZ,MAAM,OAAO,MAAM,KAAK;CACxB,SAAS;CACT,QAAQ,OAAO,MAAM,KAAK;;CAE1B,OAAO,OAAO,OAAO,OAAO,MAAM;AACpC,CAAC;AAQH,MAAM,SAAgB,aAAyC;CAC7D,MAAM,CAAC;CACP;CACA,QAAQ,CAAC;CACT,OAAO;AACT;;;;;;AAOA,MAAM,YAAmB,UACvB,MAAM,OAAO,WAAW,IAAI,MAAM,SAAS,CAAC;AAE9C,MAAM,QACJ,OACA,OACA,YACwB;CACxB,MAAM,QAAQ,QAAQ,SAAS;CAE/B,IAAI,UAAU,QAAQ,UAAU,MAAM,SAAS,MAAM,KAAK,SAAS,GACjE,OAAO;EAAE,GAAG;EAAO,SAAS;EAAO,QAAQ,SAAS,KAAK;CAAE;CAC7D,OAAO;EAEL,MAAM,QAAQ,aAAa,IAAI,CAAC,IAAI,CAAC,GAAG,MAAM,MAAM,MAAM,OAAO,CAAC,CAAC,MAAM,CAAC,QAAQ,QAAQ;EAC1F,SAAS;EACT,QAAQ,SAAS,KAAK;EACtB;CACF;AACF;AAEA,MAAM,QAAe,UAAoD;CACvE,MAAM,WAAW,MAAM,KAAK,MAAM,KAAK,SAAS;CAChD,IAAI,aAAa,KAAA,GAAW,OAAO;CACnC,OAAO;EACL,MAAM,MAAM,KAAK,MAAM,GAAG,EAAE;EAC5B,SAAS;EACT,QAAQ,CAAC,MAAM,SAAS,GAAG,MAAM,MAAM;EACvC,OAAO;CACT;AACF;AAEA,MAAM,QAAe,UAAoD;CACvE,MAAM,OAAO,MAAM,OAAO;CAC1B,IAAI,SAAS,KAAA,GAAW,OAAO;CAC/B,OAAO;EACL,MAAM,CAAC,GAAG,MAAM,MAAM,MAAM,OAAO;EACnC,SAAS;EACT,QAAQ,MAAM,OAAO,MAAM,CAAC;EAC5B,OAAO;CACT;AACF;AAEA,MAAM,QAAe,OAA4B,SAAsC;CACrF,MAAM,QAAQ;EAAC,GAAG,MAAM;EAAM,MAAM;EAAS,GAAG,MAAM;CAAM;CAC5D,IAAI,CAAC,OAAO,UAAU,IAAI,KAAK,OAAO,KAAK,QAAQ,MAAM,UAAU,SAAS,MAAM,KAAK,QACrF,OAAO;CACT,OAAO;EACL,MAAM,MAAM,MAAM,GAAG,IAAI;EACzB,SAAS,MAAM;EACf,QAAQ,MAAM,MAAM,OAAO,CAAC;EAC5B,OAAO;CACT;AACF;AAEA,MAAM,SAAgB,UACpB,MAAM,KAAK,WAAW,KAAK,MAAM,OAAO,WAAW,KAAK,MAAM,UAAU,OACpE,QACA,MAAM,MAAM,OAAO;AAEzB,MAAM,SAAgB,UACpB,MAAM,UAAU,OAAO,QAAQ;CAAE,GAAG;CAAO,OAAO;AAAK;AAEzD,MAAM,UAAiB,OAA4B,UAEjD,MAAM,UAAU,QAAQ;CAAE,GAAG,KAAK,KAAK;CAAG,QAAQ,CAAC;CAAG,OAAO;AAAK,IAAI;AAExE,MAAM,iBAAiB,MAAc,aAA6B;CAGhE,IAAI,CAAC,OAAO,UAAU,QAAQ,KAAK,WAAW,GAC5C,MAAM,IAAI,MAAM,YAAY,KAAK,2CAA2C;CAC9E,OAAO;AACT;;AAGA,MAAa,WAAkB,UAAwC,MAAM,KAAK,SAAS;;AAG3F,MAAa,WAAkB,UAAwC,MAAM,OAAO,SAAS;;AAG7F,MAAa,UAAU;;CAErB;;CAEA;;CAEA;;CAEA;;;;;;CAMA;;CAEA;;CAEA;;;;;;;;;CASA;CACA;CACA;AACF;;;;;;;;;;;;;;AAeA,MAAa,WAA6C,WAIpD;CACJ,MAAM,WAAW,cAAc,OAAO,MAAM,OAAO,YAAY,GAAG;CAClE,MAAM,QAAQ,aAAa,OAAO,KAAK;CACvC,MAAM,UAAU,mBAAmB;EACjC,MAAM;GAAE,OAAO,OAAO;GAAO,OAAO,OAAO,SAAS,OAAO,MAAM;EAAE;EACnE,MAAM,CAAC;EACP,MAAM,CAAC;EACP,MAAM,EAAE,MAAM,OAAO,OAAO;EAC5B,OAAO,CAAC;CACV,CAAC;CACD,OAAO,OAAO,OACZ,OAAO,KAAK,OAAO,MAAM;EACvB;EACA;EACA,MAAM,OAAO,OAAO,EAAE,SAAS,OAAO,MAAM,CAAC;EAC7C,OAAM,UAAS,EAAE,OAAO,MAAM,KAAK,OAAO,EAAE;EAC5C,SAAS,OAAO,YACd,QAAQ,MAAM,SAAS;GACrB,OAAO,EAAE,OAAO,aAAa,EAAE,OAAO,KAAK,OAAO,OAAO;IAAE;IAAU;GAAM,CAAC,EAAE;GAC9E,aAAa,EAAE,OAAO,KAAK,KAAK,EAAE;GAClC,aAAa,EAAE,OAAO,KAAK,KAAK,EAAE;GAClC,OAAO,EAAE,YAAY,EAAE,OAAO,KAAK,OAAO,IAAI,EAAE;GAChD,cAAc,EAAE,OAAO,MAAM,KAAK,EAAE;EACtC,CAAC;CACL,CAAC,GAID,EAAE,QAAQ,CACZ;AACF"}

package/dist/state/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./history.js";
+export * from "./locale.js";
+export * from "./pagination.js";
+export * from "./range.js";
+export * from "./selection.js";
+export * from "./virtual.js";

package/dist/state/index.js

@@ -0,0 +1,7 @@
+export * from "./history.js";
+export * from "./locale.js";
+export * from "./pagination.js";
+export * from "./range.js";
+export * from "./selection.js";
+export * from "./virtual.js";
+export {};

package/dist/state/locale.d.ts

@@ -0,0 +1,27 @@
+import { Schema } from "effect";
+import { Bundle } from "foldkit-bundle";
+export declare const LocaleModel: Schema.Struct<{
+  readonly locale: Schema.String;
+}>;
+export type LocaleModel = typeof LocaleModel.Type;
+export declare const LocaleMessage: import("foldkit/message").MessageUnion<{
+  readonly SetLocale: {
+    locale: Schema.String;
+  };
+}>;
+export type LocaleMessage = typeof LocaleMessage.Type;
+/**
+ * Locale as a bundle: the current locale string in the Model. Starts from
+ * `navigator.language` where available, falling back to the configured
+ * default; changes arrive as Messages. No subscriptions: language changes
+ * take effect on reload.
+ */
+export declare const Locale: Bundle.Bundle<"Locale", {
+  readonly default: string;
+}, {
+  readonly locale: string;
+}, {
+  readonly _tag: "SetLocale";
+  readonly locale: string;
+}, never, never, never, void, {}, {}>;
+//# sourceMappingURL=locale.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"locale.d.ts","names":[],"sources":["../../src/state/locale.ts"],"mappings":";;qBAIa,aAAW,OAAA;;;YACZ,qBAAqB,YAAY;qBAEhC,yCAAa;;IAAqC,QAAM,OAAA;;;YACzD,uBAAuB,cAAc;;;;;;;qBAQpC,QAAM,OAAA"}

package/dist/state/locale.js

@@ -0,0 +1,25 @@
+import { Schema } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+import { Bundle } from "foldkit-bundle";
+// src/state/locale.ts
+const LocaleModel = Schema.Struct({ locale: Schema.String });
+const LocaleMessage = defineMessageUnion({ SetLocale: { locale: Schema.String } });
+/**
+* Locale as a bundle: the current locale string in the Model. Starts from
+* `navigator.language` where available, falling back to the configured
+* default; changes arrive as Messages. No subscriptions: language changes
+* take effect on reload.
+*/
+const Locale = Bundle.make("Locale", {
+	Model: LocaleModel,
+	Message: LocaleMessage,
+	args: Schema.Struct({ default: Schema.String }),
+	init: (args) => ({ model: { locale: typeof navigator !== "undefined" && typeof navigator.language === "string" ? navigator.language : args.default } }),
+	update: (model, message) => LocaleMessage.match(message, { SetLocale: ({ locale }) => locale === model.locale ? { model } : { model: {
+		...model,
+		locale
+	} } })
+});
+export { Locale, LocaleMessage, LocaleModel };
+
+//# sourceMappingURL=locale.js.map

package/dist/state/locale.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale.js","names":[],"sources":["../../src/state/locale.ts"],"sourcesContent":["import { Schema } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport { Bundle } from 'foldkit-bundle'\n\nexport const LocaleModel = Schema.Struct({ locale: Schema.String })\nexport type LocaleModel = typeof LocaleModel.Type\n\nexport const LocaleMessage = defineMessageUnion({ SetLocale: { locale: Schema.String } })\nexport type LocaleMessage = typeof LocaleMessage.Type\n\n/**\n * Locale as a bundle: the current locale string in the Model. Starts from\n * `navigator.language` where available, falling back to the configured\n * default; changes arrive as Messages. No subscriptions: language changes\n * take effect on reload.\n */\nexport const Locale = Bundle.make('Locale', {\n  Model: LocaleModel,\n  Message: LocaleMessage,\n  args: Schema.Struct({ default: Schema.String }),\n  init: args => ({\n    model: {\n      locale:\n        typeof navigator !== 'undefined' && typeof navigator.language === 'string'\n          ? navigator.language\n          : args.default,\n    },\n  }),\n  update: (model, message) =>\n    LocaleMessage.match(message, {\n      SetLocale: ({ locale }) =>\n        locale === model.locale ? { model } : { model: { ...model, locale } },\n    }),\n})\n"],"mappings":";;;;AAIA,MAAa,cAAc,OAAO,OAAO,EAAE,QAAQ,OAAO,OAAO,CAAC;AAGlE,MAAa,gBAAgB,mBAAmB,EAAE,WAAW,EAAE,QAAQ,OAAO,OAAO,EAAE,CAAC;;;;;;;AASxF,MAAa,SAAS,OAAO,KAAK,UAAU;CAC1C,OAAO;CACP,SAAS;CACT,MAAM,OAAO,OAAO,EAAE,SAAS,OAAO,OAAO,CAAC;CAC9C,OAAM,UAAS,EACb,OAAO,EACL,QACE,OAAO,cAAc,eAAe,OAAO,UAAU,aAAa,WAC9D,UAAU,WACV,KAAK,QACb,EACF;CACA,SAAS,OAAO,YACd,cAAc,MAAM,SAAS,EAC3B,YAAY,EAAE,aACZ,WAAW,MAAM,SAAS,EAAE,MAAM,IAAI,EAAE,OAAO;EAAE,GAAG;EAAO;CAAO,EAAE,EACxE,CAAC;AACL,CAAC"}

package/dist/state/pagination.d.ts

@@ -0,0 +1,53 @@
+import { Schema } from "effect";
+import { Bundle } from "foldkit-bundle";
+export declare const PaginationModel: Schema.Struct<{
+  readonly page: Schema.Number;
+  readonly perPage: Schema.Number;
+  readonly total: Schema.NullOr<Schema.Number>;
+}>;
+export type PaginationModel = typeof PaginationModel.Type;
+export declare const PaginationMessage: import("foldkit/message").MessageUnion<{
+  readonly GoToPage: {
+    page: Schema.Number;
+  };
+  readonly NextPage: {};
+  readonly PrevPage: {};
+  readonly SetPerPage: {
+    perPage: Schema.Number;
+  };
+  readonly SetTotal: {
+    total: Schema.NullOr<Schema.Number>;
+  };
+}>;
+export type PaginationMessage = typeof PaginationMessage.Type;
+/** The number of pages, or null while the total is unknown. */
+export declare const pageCount: (model: PaginationModel) => number | null;
+/** The offset of the first item on the page, for a slice or a query. */
+export declare const offset: (model: PaginationModel) => number;
+/**
+ * Pagination as a bundle: the page, page size, and total live in the Model,
+ * so page changes replay and every transition clamps into range. Pure logic,
+ * no streams: data loading stays the application's job.
+ */
+export declare const Pagination: Bundle.Bundle<"Pagination", {
+  readonly perPage: number;
+  readonly total?: number | null | undefined;
+}, {
+  readonly page: number;
+  readonly perPage: number;
+  readonly total: number | null;
+}, {
+  readonly _tag: "GoToPage";
+  readonly page: number;
+} | {
+  readonly _tag: "NextPage";
+} | {
+  readonly _tag: "PrevPage";
+} | {
+  readonly _tag: "SetPerPage";
+  readonly perPage: number;
+} | {
+  readonly _tag: "SetTotal";
+  readonly total: number | null;
+}, never, never, never, void, {}, {}>;
+//# sourceMappingURL=pagination.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.d.ts","names":[],"sources":["../../src/state/pagination.ts"],"mappings":";;qBAKa,iBAAe,OAAA;;;;;YAKhB,yBAAyB,gBAAgB;qBAExC,6CAAiB;;IAChB,MAAI,OAAA;;;;;IAGF,SAAO,OAAA;;;IACT,OAAK,OAAA,OAAA,OAAA;;;YAEP,2BAA2B,kBAAkB;;qBAU5C,YAAS,OAAW;;qBAIpB,SAAM,OAAW;;;;;;qBAOjB,YAAU,OAAA"}

package/dist/state/pagination.js

@@ -0,0 +1,72 @@
+import { Schema } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+import { Bundle } from "foldkit-bundle";
+import { unlessSame } from "../internal.js";
+// src/state/pagination.ts
+const PaginationModel = Schema.Struct({
+	page: Schema.Number,
+	perPage: Schema.Number,
+	total: Schema.NullOr(Schema.Number)
+});
+const PaginationMessage = defineMessageUnion({
+	GoToPage: { page: Schema.Number },
+	NextPage: {},
+	PrevPage: {},
+	SetPerPage: { perPage: Schema.Number },
+	SetTotal: { total: Schema.NullOr(Schema.Number) }
+});
+const clampPage = (page, perPage, total) => {
+	if (!Number.isInteger(page)) return 1;
+	if (page < 1) return 1;
+	if (total === null) return page;
+	return Math.min(page, Math.max(1, Math.ceil(total / perPage)));
+};
+/** The number of pages, or null while the total is unknown. */
+const pageCount = (model) => model.total === null ? null : Math.max(1, Math.ceil(model.total / model.perPage));
+/** The offset of the first item on the page, for a slice or a query. */
+const offset = (model) => (model.page - 1) * model.perPage;
+/**
+* Pagination as a bundle: the page, page size, and total live in the Model,
+* so page changes replay and every transition clamps into range. Pure logic,
+* no streams: data loading stays the application's job.
+*/
+const Pagination = Bundle.make("Pagination", {
+	Model: PaginationModel,
+	Message: PaginationMessage,
+	args: Schema.Struct({
+		perPage: Schema.Number.pipe(Schema.check(Schema.isGreaterThan(0)), Schema.check(Schema.isFinite())),
+		total: Schema.optional(Schema.NullOr(Schema.Number.pipe(Schema.check(Schema.isFinite()))))
+	}),
+	init: (args) => ({ model: {
+		page: 1,
+		perPage: args.perPage,
+		total: args.total ?? null
+	} }),
+	update: (model, message) => PaginationMessage.match(message, {
+		GoToPage: ({ page }) => ({ model: unlessSame(model, {
+			...model,
+			page: clampPage(page, model.perPage, model.total)
+		}) }),
+		NextPage: () => ({ model: unlessSame(model, {
+			...model,
+			page: clampPage(model.page + 1, model.perPage, model.total)
+		}) }),
+		PrevPage: () => ({ model: unlessSame(model, {
+			...model,
+			page: clampPage(model.page - 1, model.perPage, model.total)
+		}) }),
+		SetPerPage: ({ perPage }) => perPage > 0 ? { model: unlessSame(model, {
+			...model,
+			perPage,
+			page: clampPage(model.page, perPage, model.total)
+		}) } : { model },
+		SetTotal: ({ total }) => total === null || total >= 0 ? { model: unlessSame(model, {
+			...model,
+			total,
+			page: clampPage(model.page, model.perPage, total)
+		}) } : { model }
+	})
+});
+export { Pagination, PaginationMessage, PaginationModel, offset, pageCount };
+
+//# sourceMappingURL=pagination.js.map