foldkit-primitives 0.1.0

package/dist/time/index.d.mts

@@ -0,0 +1,129 @@
+import { Schema } from "effect";
+import { Bundle } from "foldkit-bundle";
+//#region src/time/debounce.d.ts
+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: {
+      readonly value: Schema.Codec<Value, unknown, never, never>;
+    };
+    readonly Settled: {
+      readonly value: Schema.Codec<Value, unknown, never, never>;
+      readonly generation: Schema.Number;
+    };
+  }>;
+  Debounced: Schema.TaggedStruct<"Debounced", {
+    readonly value: Schema.Codec<Value, unknown, never, never>;
+  }>;
+};
+//#endregion
+//#region src/time/interval.d.ts
+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: {
+    readonly at: Schema.Number;
+  };
+}>;
+export type IntervalMessage = typeof IntervalMessage.Type;
+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, {}, {}>;
+//#endregion
+//#region src/time/relative.d.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").
+ */
+export declare const formatRelativeTime: (from: Date, to: Date, locale?: string) => string;
+//#endregion
+//#region src/time/throttle.d.ts
+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: {
+    readonly 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;
+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, {}, {}>;
+//#endregion
+//#region src/time/timer.d.ts
+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;
+export declare const Timer: Bundle.Bundle<"Timer", {
+  readonly intervalMs: number;
+}, {
+  count: number;
+  running: boolean;
+}, {
+  readonly _tag: "Started";
+} | {
+  readonly _tag: "Stopped";
+} | {
+  readonly _tag: "Ticked";
+}, never, never, never, void, {}, {}>;
+//#endregion
+//# sourceMappingURL=index.d.mts.map

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

@@ -0,0 +1 @@
+{"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/timer.ts"],"mappings":";;;qBAaa,iBAAkB,qBAAqB,OAAK;WAC9C,MAAM;WACN,OAAO,OAAO,MAAM;MAC9B,OAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBCJY,eAAa,OAAA;;;;YAId,uBAAuB,cAAc;qBAEpC,2CAAe;;;;iBAAf,OAAA;;;YAKD,yBAAyB,gBAAgB;qBAExC,UAAQ,OAAA;;;;;;;;;;;;;;;;;;;;;qBCnBR,qBAAkB,MAAU,MAAI,IAAM,MAAI;;;qBCM1C,eAAa,OAAA;;;YACd,uBAAuB,cAAc;qBAEpC,2CAAe;;;kBAAf,OAAA;;;YAID,yBAAyB,gBAAgB;qBAExC,WAAS,OAAA;;;YACV,mBAAmB,UAAU;qBAE5B,UAAQ,OAAA;;;;;;;;;;;;;;;qBCdR,YAAU,OAAA;;;;YACX,oBAAoB,WAAW;qBAE9B,wCAAY;;;;;YAKb,sBAAsB,aAAa;qBAElC,OAAK,OAAA"}

package/dist/time/index.mjs

@@ -0,0 +1,213 @@
+import { Clock, Effect, Schema, Stream } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+import * as Subscription from "foldkit/subscription";
+import { Bundle } from "foldkit-bundle";
+//#region 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
+	});
+};
+//#endregion
+//#region src/time/interval.ts
+/**
+* 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.
+*/
+const IntervalModel = Schema.Struct({
+	running: Schema.Boolean,
+	lastAt: Schema.NullOr(Schema.Number)
+});
+const IntervalMessage = defineMessageUnion({
+	Started: {},
+	Stopped: {},
+	Ticked: { at: Schema.Number }
+});
+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: {
+			...model,
+			running: true
+		} }),
+		Stopped: () => ({ model: {
+			...model,
+			running: false
+		} }),
+		Ticked: ({ at }) => ({ model: {
+			...model,
+			lastAt: at
+		} })
+	}),
+	subscriptions: ({ intervalMs }) => Subscription.make()((entry) => ({ ticks: entry({ running: Schema.Boolean }, {
+		modelToDependencies: (model) => ({ running: model.running }),
+		dependenciesToStream: ({ running }) => running ? Stream.mapEffect(Stream.tick(intervalMs), () => Clock.currentTimeMillis).pipe(Stream.map((at) => IntervalMessage.Ticked({ at }))) : Stream.empty
+	}) }))
+});
+//#endregion
+//#region 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");
+};
+//#endregion
+//#region src/time/throttle.ts
+/**
+* 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 ThrottleModel = Schema.Struct({ lastAt: Schema.NullOr(Schema.Number) });
+const ThrottleMessage = defineMessageUnion({
+	Attempted: {},
+	Evaluated: { now: Schema.Number }
+});
+const Throttled = Schema.TaggedStruct("Throttled", { at: Schema.Number });
+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 }
+	})
+});
+//#endregion
+//#region src/time/timer.ts
+/**
+* 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.
+*/
+const TimerModel = Schema.Struct({
+	count: Schema.Number,
+	running: Schema.Boolean
+});
+const TimerMessage = defineMessageUnion({
+	Started: {},
+	Stopped: {},
+	Ticked: {}
+});
+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: {
+			...model,
+			running: true
+		} }),
+		Stopped: () => ({ model: {
+			...model,
+			running: false
+		} }),
+		Ticked: () => ({ model: {
+			...model,
+			count: model.count + 1
+		} })
+	}),
+	subscriptions: ({ intervalMs }) => Subscription.make()((entry) => ({ ticks: entry({ running: Schema.Boolean }, {
+		modelToDependencies: (model) => ({ running: model.running }),
+		dependenciesToStream: ({ running }) => running ? Stream.map(Stream.tick(intervalMs), () => TimerMessage.Ticked()) : Stream.empty
+	}) }))
+});
+//#endregion
+export { Interval, IntervalMessage, IntervalModel, Throttle, ThrottleMessage, ThrottleModel, Throttled, Timer, TimerMessage, TimerModel, debounce, formatRelativeTime };
+
+//# sourceMappingURL=index.mjs.map

package/dist/time/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/time/debounce.ts","../../src/time/interval.ts","../../src/time/relative.ts","../../src/time/throttle.ts","../../src/time/timer.ts"],"sourcesContent":["/**\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 */\nimport { Effect, Schema } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport type * as Update from 'foldkit/update'\nimport { Bundle } from 'foldkit-bundle'\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 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 */\nimport { Clock, Schema, Stream } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport * as Subscription from 'foldkit/subscription'\nimport type * as Update from 'foldkit/update'\nimport { Bundle } from 'foldkit-bundle'\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\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: { ...model, running: true } }),\n        Stopped: () => ({ model: { ...model, running: false } }),\n        Ticked: ({ at }) => ({ model: { ...model, lastAt: at } }),\n      },\n    ),\n  subscriptions: ({ intervalMs }): Subscription.Subscriptions<IntervalModel, IntervalMessage> =>\n    Subscription.make<IntervalModel, IntervalMessage>()(entry => ({\n      ticks: entry(\n        { running: Schema.Boolean },\n        {\n          modelToDependencies: model => ({ running: model.running }),\n          dependenciesToStream: ({ running }) =>\n            running\n              ? Stream.mapEffect(Stream.tick(intervalMs), () => Clock.currentTimeMillis).pipe(\n                  Stream.map(at => IntervalMessage.Ticked({ at })),\n                )\n              : Stream.empty,\n        },\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","/**\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 */\nimport { 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\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","/**\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.\n */\nimport { Schema, Stream } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport * as Subscription from 'foldkit/subscription'\nimport { Bundle } from 'foldkit-bundle'\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\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: { ...model, running: true } }),\n      Stopped: () => ({ model: { ...model, running: false } }),\n      Ticked: () => ({ model: { ...model, count: model.count + 1 } }),\n    }),\n  subscriptions: ({ intervalMs }): Subscription.Subscriptions<TimerModel, TimerMessage> =>\n    Subscription.make<TimerModel, TimerMessage>()(entry => ({\n      ticks: entry(\n        { running: Schema.Boolean },\n        {\n          modelToDependencies: model => ({ running: model.running }),\n          dependenciesToStream: ({ running }) =>\n            running\n              ? Stream.map(Stream.tick(intervalMs), () => TimerMessage.Ticked())\n              : Stream.empty,\n        },\n      ),\n    })),\n})\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "foldkit-primitives",
+  "version": "0.1.0",
+  "description": "Ready-made primitives for the Elm architecture, packaged with foldkit-bundle: media queries, presence, timers, pagination, history, sockets, observers, and clipboard.",
+  "keywords": [
+    "foldkit",
+    "effect",
+    "submodel",
+    "primitives",
+    "elm-architecture"
+  ],
+  "type": "module",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Patrick Glenn <doeixd@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/doeixd/foldkit-plus.git",
+    "directory": "packages/primitives"
+  },
+  "homepage": "https://github.com/doeixd/foldkit-plus/tree/main/packages/primitives#readme",
+  "bugs": {
+    "url": "https://github.com/doeixd/foldkit-plus/issues"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./dom": {
+      "types": "./dist/dom/index.d.mts",
+      "import": "./dist/dom/index.mjs"
+    },
+    "./device": {
+      "types": "./dist/device/index.d.mts",
+      "import": "./dist/device/index.mjs"
+    },
+    "./events": {
+      "types": "./dist/events/index.d.mts",
+      "import": "./dist/events/index.mjs"
+    },
+    "./media": {
+      "types": "./dist/media/index.d.mts",
+      "import": "./dist/media/index.mjs"
+    },
+    "./motion": {
+      "types": "./dist/motion/index.d.mts",
+      "import": "./dist/motion/index.mjs"
+    },
+    "./net": {
+      "types": "./dist/net/index.d.mts",
+      "import": "./dist/net/index.mjs"
+    },
+    "./observers": {
+      "types": "./dist/observers/index.d.mts",
+      "import": "./dist/observers/index.mjs"
+    },
+    "./state": {
+      "types": "./dist/state/index.d.mts",
+      "import": "./dist/state/index.mjs"
+    },
+    "./time": {
+      "types": "./dist/time/index.d.mts",
+      "import": "./dist/time/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "foldkit-bundle": "0.1.0"
+  },
+  "peerDependencies": {
+    "effect": "^4.0.0-rc.112",
+    "foldkit": "^0.158.2"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.5.12",
+    "effect": "4.0.0-rc.112",
+    "foldkit": "0.158.2",
+    "jsdom": "26.1.0",
+    "tsdown": "^0.23.0",
+    "typescript": "^5.7.2",
+    "ws": "^8.18.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc -b"
+  }
+}