foldkit-primitives 0.15.4 → 0.16.0

package/dist/time/index.d.mts

@@ -1,167 +0,0 @@
-import { Option, Schema } from "effect";
-import * as Subscription from "foldkit/subscription";
-import { Bundle } from "foldkit-bundle";
-/**
- * Debounced input as a bundle factory: `Changed` restarts a timer, and the
- * latest value settles as an OutMessage the placement must handle with
- * `onOut`. Each `Changed` bumps a generation carried by the `Settled` fact
- * it schedules, so a superseded timer's fact emits nothing — the same guard
- * as Presence's exit timeout. Generic over the value Schema, like History.
- * The clock is Effect's, so tests drive it with TestClock.
- */
-export declare const debounce: <const Name extends string, Value>(config: {
-  readonly name: Name;
-  readonly value: Schema.Codec<Value, unknown>;
-}) => Bundle.Bundle<Name, {
-  readonly delayMs: number;
-}, {
-  readonly latest: Value | null;
-  readonly generation: number;
-}, {
-  readonly _tag: "Changed";
-  readonly value: Value;
-} | {
-  readonly _tag: "Settled";
-  readonly value: Value;
-  readonly generation: number;
-}, {
-  readonly _tag: "Debounced";
-  readonly value: Value;
-}, never, never, void, {}, {}> & {
-  Message: import("foldkit/message").MessageUnion<{
-    readonly Changed: {
-      value: Schema.Codec<Value, unknown, never, never>;
-    };
-    readonly Settled: {
-      value: Schema.Codec<Value, unknown, never, never>;
-      generation: Schema.Number;
-    };
-  }>;
-  Debounced: Schema.TaggedStruct<"Debounced", {
-    readonly value: Schema.Codec<Value, unknown, never, never>;
-  }>;
-};
-export declare const IntervalModel: Schema.Struct<{
-  readonly running: Schema.Boolean;
-  readonly lastAt: Schema.NullOr<Schema.Number>;
-}>;
-export type IntervalModel = typeof IntervalModel.Type;
-export declare const IntervalMessage: import("foldkit/message").MessageUnion<{
-  readonly Started: {};
-  readonly Stopped: {};
-  readonly Ticked: {
-    at: Schema.Number;
-  };
-}>;
-export type IntervalMessage = typeof IntervalMessage.Type;
-/**
- * A wall-clock interval as a bundle: the last tick time in the Model,
- * advanced by a tick stream while running. Sibling of Timer (which counts
- * ticks); this one records *when* they happened, so views can render clocks
- * and elapsed times. The clock is Effect's, so tests drive it with TestClock.
- * For a clock whose running or interval the parent's Model decides, use the
- * `ticks` entry instead.
- */
-export declare const Interval: Bundle.Bundle<"Interval", {
-  readonly intervalMs: number;
-}, {
-  readonly running: boolean;
-  readonly lastAt: number | null;
-}, {
-  readonly _tag: "Started";
-} | {
-  readonly _tag: "Stopped";
-} | {
-  readonly _tag: "Ticked";
-  readonly at: number;
-}, never, never, never, void, {}, {}>;
-/**
- * Relative time as a pure function: picks the unit (seconds through years)
- * and delegates the wording to `Intl.RelativeTimeFormat`, so locales come
- * from the platform, not a phrase table. `from` is the earlier moment;
- * swap the arguments for future phrasing ("in 3 days").
- */
-export declare const formatRelativeTime: (from: Date, to: Date, locale?: string) => string;
-export declare const ThrottleModel: Schema.Struct<{
-  readonly lastAt: Schema.NullOr<Schema.Number>;
-}>;
-export type ThrottleModel = typeof ThrottleModel.Type;
-export declare const ThrottleMessage: import("foldkit/message").MessageUnion<{
-  readonly Attempted: {};
-  readonly Evaluated: {
-    now: Schema.Number;
-  };
-}>;
-export type ThrottleMessage = typeof ThrottleMessage.Type;
-export declare const Throttled: Schema.TaggedStruct<"Throttled", {
-  readonly at: Schema.Number;
-}>;
-export type Throttled = typeof Throttled.Type;
-/**
- * Leading-edge throttle as a bundle: the first `Attempted` in an interval
- * surfaces a `Throttled` OutMessage, the rest are dropped. `Attempted`
- * reads the clock through a Command, so the check runs against Effect time
- * and tests drive it with TestClock. Trailing-edge needs are Debounce's:
- * pair the two rather than adding a second timer here.
- */
-export declare const Throttle: Bundle.Bundle<"Throttle", {
-  readonly intervalMs: number;
-}, {
-  readonly lastAt: number | null;
-}, {
-  readonly _tag: "Attempted";
-} | {
-  readonly _tag: "Evaluated";
-  readonly now: number;
-}, {
-  readonly _tag: "Throttled";
-  readonly at: number;
-}, never, never, void, {}, {}>;
-declare const TickDependencies: {
-  intervalMs: Schema.Option<Schema.Number>;
-};
-type TickDependencies = {
-  readonly intervalMs: Option.Option<number>;
-};
-/**
- * Ticks while `intervalMs` answers `Some`, each tick one interval after the
- * last and the first one interval after starting. A changed interval applies
- * from the next tick, with no restart; other Model changes do nothing.
- */
-export declare const ticks: <Model, Message>(config: {
-  /** The time between ticks for this Model, in milliseconds; `None` stops the clock. */
-  readonly intervalMs: (model: Model) => Option.Option<number>;
-  /** The Message a tick sends, given its time on Effect's clock. */
-  readonly onTick: (at: number) => Message;
-}) => Subscription.Subscription<Model, Message, TickDependencies>;
-export declare const TimerModel: Schema.Struct<{
-  readonly count: Schema.Number;
-  readonly running: Schema.Boolean;
-}>;
-export type TimerModel = typeof TimerModel.Type;
-export declare const TimerMessage: import("foldkit/message").MessageUnion<{
-  readonly Started: {};
-  readonly Stopped: {};
-  readonly Ticked: {};
-}>;
-export type TimerMessage = typeof TimerMessage.Type;
-/**
- * A timer as a bundle: a count in the Model, advanced by a tick stream while
- * running. The clock is Effect's, so tests drive it with TestClock instead of
- * waiting. For a clock whose running or interval the parent's Model decides,
- * use the `ticks` entry instead.
- */
-export declare const Timer: Bundle.Bundle<"Timer", {
-  readonly intervalMs: number;
-}, {
-  readonly count: number;
-  readonly running: boolean;
-}, {
-  readonly _tag: "Started";
-} | {
-  readonly _tag: "Stopped";
-} | {
-  readonly _tag: "Ticked";
-}, never, never, never, void, {}, {}>;
-export {};
-//# sourceMappingURL=index.d.mts.map

package/dist/time/index.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/time/debounce.ts","../../src/time/interval.ts","../../src/time/relative.ts","../../src/time/throttle.ts","../../src/time/ticks.ts","../../src/time/timer.ts"],"mappings":";;;;;;;;;;;qBAaa,iBAAkB,qBAAqB,OAAK;WAC9C,MAAM;WACN,OAAO,OAAO,MAAM;MAC9B,OAAA,OAAA;;;;;;;;;;;;;;;;;;MAQc,OAAK,OAAA,MAAA;;;MACL,OAAK,OAAA,MAAA;MAAgB,YAAU,OAAA;;;;;;;qBCnBjC,eAAa,OAAA;;;;YAId,uBAAuB,cAAc;qBAEpC,2CAAe;;;;IAGhB,IAAE,OAAA;;;YAEF,yBAAyB,gBAAgB;;;;;;;;;qBAUxC,UAAQ,OAAA;;;;;;;;;;;;;;;;;;;qBCrBR,qBAAkB,MAAU,MAAI,IAAM,MAAI;qBCD1C,eAAa,OAAA;;;YACd,uBAAuB,cAAc;qBAEpC,2CAAe;;;IAEb,KAAG,OAAA;;;YAEN,yBAAyB,gBAAgB;qBAExC,WAAS,OAAA;;;YACV,mBAAmB,UAAU;;;;;;;;qBAS5B,UAAQ,OAAA;;;;;;;;;;;;;cCff;EAAqB,YAAU,OAAA,OAAA,OAAA;;KAChC;WAA8B,YAAY,OAAO;;;;;;;qBAezC,QAAS,OAAO,SAAO;;WAEzB,aAAa,OAAO,UAAU,OAAO;;WAErC,SAAS,eAAe;MAC/B,aAAa,aAAa,OAAO,SAAS;qBCzBjC,YAAU,OAAA;;;;YACX,oBAAoB,WAAW;qBAE9B,wCAAY;;;;;YAKb,sBAAsB,aAAa;;;;;;;qBAQlC,OAAK,OAAA"}

package/dist/time/index.mjs

@@ -1,236 +0,0 @@
-import { Clock, Effect, Option, Schema, Stream } from "effect";
-import { defineMessageUnion } from "foldkit/message";
-import * as Subscription from "foldkit/subscription";
-import { Bundle } from "foldkit-bundle";
-// src/time/debounce.ts
-/**
-* Debounced input as a bundle factory: `Changed` restarts a timer, and the
-* latest value settles as an OutMessage the placement must handle with
-* `onOut`. Each `Changed` bumps a generation carried by the `Settled` fact
-* it schedules, so a superseded timer's fact emits nothing — the same guard
-* as Presence's exit timeout. Generic over the value Schema, like History.
-* The clock is Effect's, so tests drive it with TestClock.
-*/
-const debounce = (config) => {
-	const Model = Schema.Struct({
-		latest: Schema.NullOr(config.value),
-		generation: Schema.Number
-	});
-	const Message = defineMessageUnion({
-		Changed: { value: config.value },
-		Settled: {
-			value: config.value,
-			generation: Schema.Number
-		}
-	});
-	const Debounced = Schema.TaggedStruct("Debounced", { value: config.value });
-	const bundle = Bundle.make(config.name, {
-		Model,
-		Message,
-		args: Schema.Struct({ delayMs: Schema.Number.pipe(Schema.check(Schema.isGreaterThan(0)), Schema.check(Schema.isFinite())) }),
-		init: () => ({ model: {
-			latest: null,
-			generation: 0
-		} }),
-		update: (model, message, args) => Message.match(message, {
-			Changed: ({ value }) => {
-				const generation = model.generation + 1;
-				return {
-					model: {
-						latest: value,
-						generation
-					},
-					commands: [{
-						name: `${config.name}.settle`,
-						args: { generation },
-						effect: Effect.as(Effect.sleep(args.delayMs), Message.Settled({
-							value,
-							generation
-						}))
-					}]
-				};
-			},
-			Settled: ({ generation, value }) => generation === model.generation ? {
-				model,
-				outMessage: Debounced.make({ value })
-			} : { model }
-		})
-	});
-	return Object.assign(bundle, {
-		Message,
-		Debounced
-	});
-};
-// src/time/ticks.ts
-/**
-* A clock the parent owns, as an entry: whether it ticks and how fast are
-* functions of the parent's Model, so nothing keeps a second running flag or
-* interval beside the state they derive from (a game's phase and score).
-* Timer and Interval are built on it, for a clock that owns its own flag.
-*/
-const TickDependencies = { intervalMs: Schema.Option(Schema.Number) };
-const checked = (intervalMs) => {
-	if (Option.isSome(intervalMs) && !(intervalMs.value > 0 && Number.isFinite(intervalMs.value))) throw new Error(`ticks: intervalMs must be positive and finite, got ${intervalMs.value}`);
-	return intervalMs;
-};
-/**
-* Ticks while `intervalMs` answers `Some`, each tick one interval after the
-* last and the first one interval after starting. A changed interval applies
-* from the next tick, with no restart; other Model changes do nothing.
-*/
-const ticks = (config) => Subscription.make()((entry) => ({ ticks: entry(TickDependencies, {
-	modelToDependencies: (model) => ({ intervalMs: checked(config.intervalMs(model)) }),
-	keepAliveEquivalence: (a, b) => Option.isSome(a.intervalMs) === Option.isSome(b.intervalMs),
-	dependenciesToStream: ({ intervalMs }, readDependencies) => Option.match(intervalMs, {
-		onNone: () => Stream.empty,
-		onSome: (started) => Stream.fromEffectRepeat(Effect.suspend(() => Effect.sleep(Option.getOrElse(readDependencies().intervalMs, () => started))).pipe(Effect.andThen(Clock.currentTimeMillis), Effect.map(config.onTick)))
-	})
-}) })).ticks;
-// src/time/interval.ts
-const IntervalModel = Schema.Struct({
-	running: Schema.Boolean,
-	lastAt: Schema.NullOr(Schema.Number)
-});
-const IntervalMessage = defineMessageUnion({
-	Started: {},
-	Stopped: {},
-	Ticked: { at: Schema.Number }
-});
-/**
-* A wall-clock interval as a bundle: the last tick time in the Model,
-* advanced by a tick stream while running. Sibling of Timer (which counts
-* ticks); this one records *when* they happened, so views can render clocks
-* and elapsed times. The clock is Effect's, so tests drive it with TestClock.
-* For a clock whose running or interval the parent's Model decides, use the
-* `ticks` entry instead.
-*/
-const Interval = Bundle.make("Interval", {
-	Model: IntervalModel,
-	Message: IntervalMessage,
-	args: Schema.Struct({ intervalMs: Schema.Number.pipe(Schema.check(Schema.isGreaterThan(0)), Schema.check(Schema.isFinite())) }),
-	init: () => ({ model: {
-		running: false,
-		lastAt: null
-	} }),
-	update: (model, message) => IntervalMessage.match(message, {
-		Started: () => model.running ? { model } : { model: {
-			...model,
-			running: true
-		} },
-		Stopped: () => model.running ? { model: {
-			...model,
-			running: false
-		} } : { model },
-		Ticked: ({ at }) => ({ model: {
-			...model,
-			lastAt: at
-		} })
-	}),
-	subscriptions: ({ intervalMs }) => ({ ticks: ticks({
-		intervalMs: (model) => model.running ? Option.some(intervalMs) : Option.none(),
-		onTick: (at) => IntervalMessage.Ticked({ at })
-	}) })
-});
-// src/time/relative.ts
-/**
-* Relative time as a pure function: picks the unit (seconds through years)
-* and delegates the wording to `Intl.RelativeTimeFormat`, so locales come
-* from the platform, not a phrase table. `from` is the earlier moment;
-* swap the arguments for future phrasing ("in 3 days").
-*/
-const formatRelativeTime = (from, to, locale = "en") => {
-	const format = new Intl.RelativeTimeFormat(locale, { numeric: "auto" });
-	const seconds = Math.round((to.getTime() - from.getTime()) / 1e3);
-	const abs = Math.abs(seconds);
-	if (abs < 60) return format.format(-seconds, "second");
-	const minutes = Math.round(seconds / 60);
-	if (abs < 3600) return format.format(-minutes, "minute");
-	const hours = Math.round(seconds / 3600);
-	if (abs < 86400) return format.format(-hours, "hour");
-	const days = Math.round(seconds / 86400);
-	if (abs < 604800) return format.format(-days, "day");
-	const weeks = Math.round(seconds / 604800);
-	if (abs < 2592e3) return format.format(-weeks, "week");
-	const months = Math.round(seconds / 2592e3);
-	if (abs < 31536e3) return format.format(-months, "month");
-	return format.format(-Math.round(seconds / 31536e3), "year");
-};
-// src/time/throttle.ts
-const ThrottleModel = Schema.Struct({ lastAt: Schema.NullOr(Schema.Number) });
-const ThrottleMessage = defineMessageUnion({
-	Attempted: {},
-	Evaluated: { now: Schema.Number }
-});
-const Throttled = Schema.TaggedStruct("Throttled", { at: Schema.Number });
-/**
-* Leading-edge throttle as a bundle: the first `Attempted` in an interval
-* surfaces a `Throttled` OutMessage, the rest are dropped. `Attempted`
-* reads the clock through a Command, so the check runs against Effect time
-* and tests drive it with TestClock. Trailing-edge needs are Debounce's:
-* pair the two rather than adding a second timer here.
-*/
-const Throttle = Bundle.make("Throttle", {
-	Model: ThrottleModel,
-	Message: ThrottleMessage,
-	args: Schema.Struct({ intervalMs: Schema.Number.pipe(Schema.check(Schema.isGreaterThan(0)), Schema.check(Schema.isFinite())) }),
-	init: () => ({ model: { lastAt: null } }),
-	update: (model, message, args) => ThrottleMessage.match(message, {
-		Attempted: () => ({
-			model,
-			commands: [{
-				name: "Throttle.evaluate",
-				effect: Effect.map(Clock.currentTimeMillis, (now) => ThrottleMessage.Evaluated({ now }))
-			}]
-		}),
-		Evaluated: ({ now }) => model.lastAt === null || now - model.lastAt >= args.intervalMs ? {
-			model: { lastAt: now },
-			outMessage: Throttled.make({ at: now })
-		} : { model }
-	})
-});
-// src/time/timer.ts
-const TimerModel = Schema.Struct({
-	count: Schema.Number,
-	running: Schema.Boolean
-});
-const TimerMessage = defineMessageUnion({
-	Started: {},
-	Stopped: {},
-	Ticked: {}
-});
-/**
-* A timer as a bundle: a count in the Model, advanced by a tick stream while
-* running. The clock is Effect's, so tests drive it with TestClock instead of
-* waiting. For a clock whose running or interval the parent's Model decides,
-* use the `ticks` entry instead.
-*/
-const Timer = Bundle.make("Timer", {
-	Model: TimerModel,
-	Message: TimerMessage,
-	args: Schema.Struct({ intervalMs: Schema.Number.pipe(Schema.check(Schema.isGreaterThan(0)), Schema.check(Schema.isFinite())) }),
-	init: () => ({ model: {
-		count: 0,
-		running: false
-	} }),
-	update: (model, message) => TimerMessage.match(message, {
-		Started: () => model.running ? { model } : { model: {
-			...model,
-			running: true
-		} },
-		Stopped: () => model.running ? { model: {
-			...model,
-			running: false
-		} } : { model },
-		Ticked: () => ({ model: {
-			...model,
-			count: model.count + 1
-		} })
-	}),
-	subscriptions: ({ intervalMs }) => ({ ticks: ticks({
-		intervalMs: (model) => model.running ? Option.some(intervalMs) : Option.none(),
-		onTick: () => TimerMessage.Ticked()
-	}) })
-});
-export { Interval, IntervalMessage, IntervalModel, Throttle, ThrottleMessage, ThrottleModel, Throttled, Timer, TimerMessage, TimerModel, debounce, formatRelativeTime, ticks };
-
-//# sourceMappingURL=index.mjs.map

package/dist/time/index.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/time/debounce.ts","../../src/time/ticks.ts","../../src/time/interval.ts","../../src/time/relative.ts","../../src/time/throttle.ts","../../src/time/timer.ts"],"sourcesContent":["import { Effect, Schema } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport type * as Update from 'foldkit/update'\nimport { Bundle } from 'foldkit-bundle'\n\n/**\n * Debounced input as a bundle factory: `Changed` restarts a timer, and the\n * latest value settles as an OutMessage the placement must handle with\n * `onOut`. Each `Changed` bumps a generation carried by the `Settled` fact\n * it schedules, so a superseded timer's fact emits nothing — the same guard\n * as Presence's exit timeout. Generic over the value Schema, like History.\n * The clock is Effect's, so tests drive it with TestClock.\n */\nexport const debounce = <const Name extends string, Value>(config: {\n  readonly name: Name\n  readonly value: Schema.Codec<Value, unknown>\n}) => {\n  const Model = Schema.Struct({\n    latest: Schema.NullOr(config.value),\n    generation: Schema.Number,\n  })\n  type Model = typeof Model.Type\n\n  const Message = defineMessageUnion({\n    Changed: { value: config.value },\n    Settled: { value: config.value, generation: Schema.Number },\n  })\n  type Message = typeof Message.Type\n\n  const Debounced = Schema.TaggedStruct('Debounced', { value: config.value })\n  type Debounced = typeof Debounced.Type\n\n  const bundle = Bundle.make(config.name, {\n    Model,\n    Message,\n    args: Schema.Struct({\n      delayMs: Schema.Number.pipe(\n        Schema.check(Schema.isGreaterThan(0)),\n        Schema.check(Schema.isFinite()),\n      ),\n    }),\n    init: () => ({ model: { latest: null, generation: 0 } }),\n    update: (model, message, args) =>\n      Message.match<Update.ReturnWithOutMessage<Model, Message, Debounced>>(message, {\n        Changed: ({ value }) => {\n          const generation = model.generation + 1\n          return {\n            model: { latest: value, generation },\n            commands: [\n              {\n                name: `${config.name}.settle`,\n                args: { generation },\n                effect: Effect.as(\n                  Effect.sleep(args.delayMs),\n                  Message.Settled({ value, generation }),\n                ),\n              },\n            ],\n          }\n        },\n        // A superseded timer's fact arrives with an old generation: no\n        // OutMessage, so the placement never sees it.\n        Settled: ({ generation, value }) =>\n          generation === model.generation\n            ? { model, outMessage: Debounced.make({ value }) }\n            : { model },\n      }),\n  })\n\n  return Object.assign(bundle, { Message, Debounced })\n}\n","/**\n * A clock the parent owns, as an entry: whether it ticks and how fast are\n * functions of the parent's Model, so nothing keeps a second running flag or\n * interval beside the state they derive from (a game's phase and score).\n * Timer and Interval are built on it, for a clock that owns its own flag.\n */\nimport { Clock, Effect, Option, Schema, Stream } from 'effect'\nimport * as Subscription from 'foldkit/subscription'\n\nconst TickDependencies = { intervalMs: Schema.Option(Schema.Number) }\ntype TickDependencies = { readonly intervalMs: Option.Option<number> }\n\nconst checked = (intervalMs: Option.Option<number>): Option.Option<number> => {\n  // A zero, negative or non-finite interval would spin or never tick; the\n  // runtime crashes on a defect here, which names the mistake where it is made.\n  if (Option.isSome(intervalMs) && !(intervalMs.value > 0 && Number.isFinite(intervalMs.value)))\n    throw new Error(`ticks: intervalMs must be positive and finite, got ${intervalMs.value}`)\n  return intervalMs\n}\n\n/**\n * Ticks while `intervalMs` answers `Some`, each tick one interval after the\n * last and the first one interval after starting. A changed interval applies\n * from the next tick, with no restart; other Model changes do nothing.\n */\nexport const ticks = <Model, Message>(config: {\n  /** The time between ticks for this Model, in milliseconds; `None` stops the clock. */\n  readonly intervalMs: (model: Model) => Option.Option<number>\n  /** The Message a tick sends, given its time on Effect's clock. */\n  readonly onTick: (at: number) => Message\n}): Subscription.Subscription<Model, Message, TickDependencies> =>\n  Subscription.make<Model, Message>()(entry => ({\n    ticks: entry(TickDependencies, {\n      modelToDependencies: model => ({ intervalMs: checked(config.intervalMs(model)) }),\n      // Stopping and starting restart the stream; a new interval does not, so\n      // a clock that speeds up keeps its phase instead of ticking at once.\n      keepAliveEquivalence: (a, b) => Option.isSome(a.intervalMs) === Option.isSome(b.intervalMs),\n      dependenciesToStream: ({ intervalMs }, readDependencies) =>\n        Option.match(intervalMs, {\n          onNone: () => Stream.empty,\n          onSome: started =>\n            Stream.fromEffectRepeat(\n              Effect.suspend(() =>\n                Effect.sleep(Option.getOrElse(readDependencies().intervalMs, () => started)),\n              ).pipe(Effect.andThen(Clock.currentTimeMillis), Effect.map(config.onTick)),\n            ),\n        }),\n    }),\n  })).ticks\n","import { Option, Schema } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport type * as Update from 'foldkit/update'\nimport { Bundle } from 'foldkit-bundle'\nimport { ticks } from './ticks.js'\n\nexport const IntervalModel = Schema.Struct({\n  running: Schema.Boolean,\n  lastAt: Schema.NullOr(Schema.Number),\n})\nexport type IntervalModel = typeof IntervalModel.Type\n\nexport const IntervalMessage = defineMessageUnion({\n  Started: {},\n  Stopped: {},\n  Ticked: { at: Schema.Number },\n})\nexport type IntervalMessage = typeof IntervalMessage.Type\n\n/**\n * A wall-clock interval as a bundle: the last tick time in the Model,\n * advanced by a tick stream while running. Sibling of Timer (which counts\n * ticks); this one records *when* they happened, so views can render clocks\n * and elapsed times. The clock is Effect's, so tests drive it with TestClock.\n * For a clock whose running or interval the parent's Model decides, use the\n * `ticks` entry instead.\n */\nexport const Interval = Bundle.make('Interval', {\n  Model: IntervalModel,\n  Message: IntervalMessage,\n  args: Schema.Struct({\n    intervalMs: Schema.Number.pipe(\n      Schema.check(Schema.isGreaterThan(0)),\n      Schema.check(Schema.isFinite()),\n    ),\n  }),\n  init: () => ({ model: { running: false, lastAt: null } }),\n  update: (model, message) =>\n    IntervalMessage.match<Update.ReturnWithOutMessage<IntervalModel, IntervalMessage, never>>(\n      message,\n      {\n        Started: () => (model.running ? { model } : { model: { ...model, running: true } }),\n        Stopped: () => (model.running ? { model: { ...model, running: false } } : { model }),\n        Ticked: ({ at }) => ({ model: { ...model, lastAt: at } }),\n      },\n    ),\n  subscriptions: ({ intervalMs }) => ({\n    ticks: ticks<IntervalModel, IntervalMessage>({\n      intervalMs: model => (model.running ? Option.some(intervalMs) : Option.none()),\n      onTick: at => IntervalMessage.Ticked({ at }),\n    }),\n  }),\n})\n","/**\n * Relative time as a pure function: picks the unit (seconds through years)\n * and delegates the wording to `Intl.RelativeTimeFormat`, so locales come\n * from the platform, not a phrase table. `from` is the earlier moment;\n * swap the arguments for future phrasing (\"in 3 days\").\n */\nexport const formatRelativeTime = (from: Date, to: Date, locale = 'en'): string => {\n  const format = new Intl.RelativeTimeFormat(locale, { numeric: 'auto' })\n  const seconds = Math.round((to.getTime() - from.getTime()) / 1000)\n  const abs = Math.abs(seconds)\n  if (abs < 60) return format.format(-seconds, 'second')\n  const minutes = Math.round(seconds / 60)\n  if (abs < 60 * 60) return format.format(-minutes, 'minute')\n  const hours = Math.round(seconds / (60 * 60))\n  if (abs < 24 * 60 * 60) return format.format(-hours, 'hour')\n  const days = Math.round(seconds / (24 * 60 * 60))\n  if (abs < 7 * 24 * 60 * 60) return format.format(-days, 'day')\n  const weeks = Math.round(seconds / (7 * 24 * 60 * 60))\n  if (abs < 30 * 24 * 60 * 60) return format.format(-weeks, 'week')\n  const months = Math.round(seconds / (30 * 24 * 60 * 60))\n  if (abs < 365 * 24 * 60 * 60) return format.format(-months, 'month')\n  return format.format(-Math.round(seconds / (365 * 24 * 60 * 60)), 'year')\n}\n","import { Clock, Effect, Schema } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport type * as Update from 'foldkit/update'\nimport { Bundle } from 'foldkit-bundle'\n\nexport const ThrottleModel = Schema.Struct({ lastAt: Schema.NullOr(Schema.Number) })\nexport type ThrottleModel = typeof ThrottleModel.Type\n\nexport const ThrottleMessage = defineMessageUnion({\n  Attempted: {},\n  Evaluated: { now: Schema.Number },\n})\nexport type ThrottleMessage = typeof ThrottleMessage.Type\n\nexport const Throttled = Schema.TaggedStruct('Throttled', { at: Schema.Number })\nexport type Throttled = typeof Throttled.Type\n\n/**\n * Leading-edge throttle as a bundle: the first `Attempted` in an interval\n * surfaces a `Throttled` OutMessage, the rest are dropped. `Attempted`\n * reads the clock through a Command, so the check runs against Effect time\n * and tests drive it with TestClock. Trailing-edge needs are Debounce's:\n * pair the two rather than adding a second timer here.\n */\nexport const Throttle = Bundle.make('Throttle', {\n  Model: ThrottleModel,\n  Message: ThrottleMessage,\n  args: Schema.Struct({\n    intervalMs: Schema.Number.pipe(\n      Schema.check(Schema.isGreaterThan(0)),\n      Schema.check(Schema.isFinite()),\n    ),\n  }),\n  init: () => ({ model: { lastAt: null } }),\n  update: (model, message, args) =>\n    ThrottleMessage.match<Update.ReturnWithOutMessage<ThrottleModel, ThrottleMessage, Throttled>>(\n      message,\n      {\n        Attempted: () => ({\n          model,\n          commands: [\n            {\n              name: 'Throttle.evaluate',\n              effect: Effect.map(Clock.currentTimeMillis, now =>\n                ThrottleMessage.Evaluated({ now }),\n              ),\n            },\n          ],\n        }),\n        // First attempt ever, or the interval has passed: fire and stamp.\n        Evaluated: ({ now }) =>\n          model.lastAt === null || now - model.lastAt >= args.intervalMs\n            ? { model: { lastAt: now }, outMessage: Throttled.make({ at: now }) }\n            : { model },\n      },\n    ),\n})\n","import { Option, Schema } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport { Bundle } from 'foldkit-bundle'\nimport { ticks } from './ticks.js'\n\nexport const TimerModel = Schema.Struct({ count: Schema.Number, running: Schema.Boolean })\nexport type TimerModel = typeof TimerModel.Type\n\nexport const TimerMessage = defineMessageUnion({\n  Started: {},\n  Stopped: {},\n  Ticked: {},\n})\nexport type TimerMessage = typeof TimerMessage.Type\n\n/**\n * A timer as a bundle: a count in the Model, advanced by a tick stream while\n * running. The clock is Effect's, so tests drive it with TestClock instead of\n * waiting. For a clock whose running or interval the parent's Model decides,\n * use the `ticks` entry instead.\n */\nexport const Timer = Bundle.make('Timer', {\n  Model: TimerModel,\n  Message: TimerMessage,\n  args: Schema.Struct({\n    intervalMs: Schema.Number.pipe(\n      Schema.check(Schema.isGreaterThan(0)),\n      Schema.check(Schema.isFinite()),\n    ),\n  }),\n  init: () => ({ model: { count: 0, running: false } }),\n  update: (model, message) =>\n    TimerMessage.match(message, {\n      Started: () => (model.running ? { model } : { model: { ...model, running: true } }),\n      Stopped: () => (model.running ? { model: { ...model, running: false } } : { model }),\n      Ticked: () => ({ model: { ...model, count: model.count + 1 } }),\n    }),\n  subscriptions: ({ intervalMs }) => ({\n    ticks: ticks<TimerModel, TimerMessage>({\n      intervalMs: model => (model.running ? Option.some(intervalMs) : Option.none()),\n      onTick: () => TimerMessage.Ticked(),\n    }),\n  }),\n})\n"],"mappings":"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"}