foldkit-primitives 0.15.3 → 0.16.0

package/dist/time/relative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relative.d.ts","names":[],"sources":["../../src/time/relative.ts"],"mappings":";;;;;;qBAMa,qBAAkB,MAAU,MAAI,IAAM,MAAI"}

package/dist/time/relative.js

@@ -0,0 +1,27 @@
+// 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");
+};
+export { formatRelativeTime };
+
+//# sourceMappingURL=relative.js.map

package/dist/time/relative.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relative.js","names":[],"sources":["../../src/time/relative.ts"],"sourcesContent":["/**\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"],"mappings":";;;;;;;AAMA,MAAa,sBAAsB,MAAY,IAAU,SAAS,SAAiB;CACjF,MAAM,SAAS,IAAI,KAAK,mBAAmB,QAAQ,EAAE,SAAS,OAAO,CAAC;CACtE,MAAM,UAAU,KAAK,OAAO,GAAG,QAAQ,IAAI,KAAK,QAAQ,KAAK,GAAI;CACjE,MAAM,MAAM,KAAK,IAAI,OAAO;CAC5B,IAAI,MAAM,IAAI,OAAO,OAAO,OAAO,CAAC,SAAS,QAAQ;CACrD,MAAM,UAAU,KAAK,MAAM,UAAU,EAAE;CACvC,IAAI,MAAM,MAAS,OAAO,OAAO,OAAO,CAAC,SAAS,QAAQ;CAC1D,MAAM,QAAQ,KAAK,MAAM,UAAW,IAAQ;CAC5C,IAAI,MAAM,OAAc,OAAO,OAAO,OAAO,CAAC,OAAO,MAAM;CAC3D,MAAM,OAAO,KAAK,MAAM,UAAW,KAAa;CAChD,IAAI,MAAM,QAAkB,OAAO,OAAO,OAAO,CAAC,MAAM,KAAK;CAC7D,MAAM,QAAQ,KAAK,MAAM,UAAW,MAAiB;CACrD,IAAI,MAAM,QAAmB,OAAO,OAAO,OAAO,CAAC,OAAO,MAAM;CAChE,MAAM,SAAS,KAAK,MAAM,UAAW,MAAkB;CACvD,IAAI,MAAM,SAAoB,OAAO,OAAO,OAAO,CAAC,QAAQ,OAAO;CACnE,OAAO,OAAO,OAAO,CAAC,KAAK,MAAM,UAAW,OAAmB,GAAG,MAAM;AAC1E"}

package/dist/time/throttle.d.ts

@@ -0,0 +1,38 @@
+import { Schema } from "effect";
+import { Bundle } from "foldkit-bundle";
+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, {}, {}>;
+//# sourceMappingURL=throttle.d.ts.map

package/dist/time/throttle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"throttle.d.ts","names":[],"sources":["../../src/time/throttle.ts"],"mappings":";;qBAKa,eAAa,OAAA;;;YACd,uBAAuB,cAAc;qBAEpC,2CAAe;;;IAEb,KAAG,OAAA;;;YAEN,yBAAyB,gBAAgB;qBAExC,WAAS,OAAA;;;YACV,mBAAmB,UAAU;;;;;;;;qBAS5B,UAAQ,OAAA"}

package/dist/time/throttle.js

@@ -0,0 +1,39 @@
+import { Clock, Effect, Schema } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+import { Bundle } from "foldkit-bundle";
+// 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 }
+	})
+});
+export { Throttle, ThrottleMessage, ThrottleModel, Throttled };
+
+//# sourceMappingURL=throttle.js.map

package/dist/time/throttle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"throttle.js","names":[],"sources":["../../src/time/throttle.ts"],"sourcesContent":["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"],"mappings":";;;;AAKA,MAAa,gBAAgB,OAAO,OAAO,EAAE,QAAQ,OAAO,OAAO,OAAO,MAAM,EAAE,CAAC;AAGnF,MAAa,kBAAkB,mBAAmB;CAChD,WAAW,CAAC;CACZ,WAAW,EAAE,KAAK,OAAO,OAAO;AAClC,CAAC;AAGD,MAAa,YAAY,OAAO,aAAa,aAAa,EAAE,IAAI,OAAO,OAAO,CAAC;;;;;;;;AAU/E,MAAa,WAAW,OAAO,KAAK,YAAY;CAC9C,OAAO;CACP,SAAS;CACT,MAAM,OAAO,OAAO,EAClB,YAAY,OAAO,OAAO,KACxB,OAAO,MAAM,OAAO,cAAc,CAAC,CAAC,GACpC,OAAO,MAAM,OAAO,SAAS,CAAC,CAChC,EACF,CAAC;CACD,aAAa,EAAE,OAAO,EAAE,QAAQ,KAAK,EAAE;CACvC,SAAS,OAAO,SAAS,SACvB,gBAAgB,MACd,SACA;EACE,kBAAkB;GAChB;GACA,UAAU,CACR;IACE,MAAM;IACN,QAAQ,OAAO,IAAI,MAAM,oBAAmB,QAC1C,gBAAgB,UAAU,EAAE,IAAI,CAAC,CACnC;GACF,CACF;EACF;EAEA,YAAY,EAAE,UACZ,MAAM,WAAW,QAAQ,MAAM,MAAM,UAAU,KAAK,aAChD;GAAE,OAAO,EAAE,QAAQ,IAAI;GAAG,YAAY,UAAU,KAAK,EAAE,IAAI,IAAI,CAAC;EAAE,IAClE,EAAE,MAAM;CAChB,CACF;AACJ,CAAC"}

package/dist/time/ticks.d.ts

@@ -0,0 +1,21 @@
+import { Option, Schema } from "effect";
+import * as Subscription from "foldkit/subscription";
+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 {};
+//# sourceMappingURL=ticks.d.ts.map

package/dist/time/ticks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ticks.d.ts","names":[],"sources":["../../src/time/ticks.ts"],"mappings":";;cASM;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"}

package/dist/time/ticks.js

@@ -0,0 +1,30 @@
+import { Clock, Effect, Option, Schema, Stream } from "effect";
+import * as Subscription from "foldkit/subscription";
+// 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;
+export { ticks };
+
+//# sourceMappingURL=ticks.js.map

package/dist/time/ticks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ticks.js","names":[],"sources":["../../src/time/ticks.ts"],"sourcesContent":["/**\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"],"mappings":";;;;;;;;;AASA,MAAM,mBAAmB,EAAE,YAAY,OAAO,OAAO,OAAO,MAAM,EAAE;AAGpE,MAAM,WAAW,eAA6D;CAG5E,IAAI,OAAO,OAAO,UAAU,KAAK,EAAE,WAAW,QAAQ,KAAK,OAAO,SAAS,WAAW,KAAK,IACzF,MAAM,IAAI,MAAM,sDAAsD,WAAW,OAAO;CAC1F,OAAO;AACT;;;;;;AAOA,MAAa,SAAyB,WAMpC,aAAa,KAAqB,CAAC,EAAC,WAAU,EAC5C,OAAO,MAAM,kBAAkB;CAC7B,sBAAqB,WAAU,EAAE,YAAY,QAAQ,OAAO,WAAW,KAAK,CAAC,EAAE;CAG/E,uBAAuB,GAAG,MAAM,OAAO,OAAO,EAAE,UAAU,MAAM,OAAO,OAAO,EAAE,UAAU;CAC1F,uBAAuB,EAAE,cAAc,qBACrC,OAAO,MAAM,YAAY;EACvB,cAAc,OAAO;EACrB,SAAQ,YACN,OAAO,iBACL,OAAO,cACL,OAAO,MAAM,OAAO,UAAU,iBAAiB,CAAC,CAAC,kBAAkB,OAAO,CAAC,CAC7E,CAAC,CAAC,KAAK,OAAO,QAAQ,MAAM,iBAAiB,GAAG,OAAO,IAAI,OAAO,MAAM,CAAC,CAC3E;CACJ,CAAC;AACL,CAAC,EACH,EAAE,CAAC,CAAC"}

package/dist/time/timer.d.ts

@@ -0,0 +1,32 @@
+import { Schema } from "effect";
+import { Bundle } from "foldkit-bundle";
+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, {}, {}>;
+//# sourceMappingURL=timer.d.ts.map

package/dist/time/timer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.d.ts","names":[],"sources":["../../src/time/timer.ts"],"mappings":";;qBAKa,YAAU,OAAA;;;;YACX,oBAAoB,WAAW;qBAE9B,wCAAY;;;;;YAKb,sBAAsB,aAAa;;;;;;;qBAQlC,OAAK,OAAA"}

package/dist/time/timer.js

@@ -0,0 +1,50 @@
+import { Option, Schema } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+import { Bundle } from "foldkit-bundle";
+import { ticks } from "./ticks.js";
+// 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 { Timer, TimerMessage, TimerModel };
+
+//# sourceMappingURL=timer.js.map

package/dist/time/timer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.js","names":[],"sources":["../../src/time/timer.ts"],"sourcesContent":["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":";;;;;AAKA,MAAa,aAAa,OAAO,OAAO;CAAE,OAAO,OAAO;CAAQ,SAAS,OAAO;AAAQ,CAAC;AAGzF,MAAa,eAAe,mBAAmB;CAC7C,SAAS,CAAC;CACV,SAAS,CAAC;CACV,QAAQ,CAAC;AACX,CAAC;;;;;;;AASD,MAAa,QAAQ,OAAO,KAAK,SAAS;CACxC,OAAO;CACP,SAAS;CACT,MAAM,OAAO,OAAO,EAClB,YAAY,OAAO,OAAO,KACxB,OAAO,MAAM,OAAO,cAAc,CAAC,CAAC,GACpC,OAAO,MAAM,OAAO,SAAS,CAAC,CAChC,EACF,CAAC;CACD,aAAa,EAAE,OAAO;EAAE,OAAO;EAAG,SAAS;CAAM,EAAE;CACnD,SAAS,OAAO,YACd,aAAa,MAAM,SAAS;EAC1B,eAAgB,MAAM,UAAU,EAAE,MAAM,IAAI,EAAE,OAAO;GAAE,GAAG;GAAO,SAAS;EAAK,EAAE;EACjF,eAAgB,MAAM,UAAU,EAAE,OAAO;GAAE,GAAG;GAAO,SAAS;EAAM,EAAE,IAAI,EAAE,MAAM;EAClF,eAAe,EAAE,OAAO;GAAE,GAAG;GAAO,OAAO,MAAM,QAAQ;EAAE,EAAE;CAC/D,CAAC;CACH,gBAAgB,EAAE,kBAAkB,EAClC,OAAO,MAAgC;EACrC,aAAY,UAAU,MAAM,UAAU,OAAO,KAAK,UAAU,IAAI,OAAO,KAAK;EAC5E,cAAc,aAAa,OAAO;CACpC,CAAC,EACH;AACF,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foldkit-primitives",
-  "version": "0.15.3",
+  "version": "0.16.0",
   "description": "Ready-made primitives for the Elm architecture, packaged with foldkit-bundle: media queries, presence, timers, pagination, history, sockets, observers, clipboard, and interaction Bundles with their Behaviors.",
   "keywords": [
     "foldkit",
@@ -28,58 +28,58 @@
   "exports": {
     ".": {
       "foldkit-plus:source": "./src/index.ts",
-      "types": "./dist/index.d.mts",
-      "import": "./dist/index.mjs"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     },
     "./dom": {
       "foldkit-plus:source": "./src/dom/index.ts",
-      "types": "./dist/dom/index.d.mts",
-      "import": "./dist/dom/index.mjs"
+      "types": "./dist/dom/index.d.ts",
+      "import": "./dist/dom/index.js"
     },
     "./device": {
       "foldkit-plus:source": "./src/device/index.ts",
-      "types": "./dist/device/index.d.mts",
-      "import": "./dist/device/index.mjs"
+      "types": "./dist/device/index.d.ts",
+      "import": "./dist/device/index.js"
     },
     "./events": {
       "foldkit-plus:source": "./src/events/index.ts",
-      "types": "./dist/events/index.d.mts",
-      "import": "./dist/events/index.mjs"
+      "types": "./dist/events/index.d.ts",
+      "import": "./dist/events/index.js"
     },
     "./interaction": {
       "foldkit-plus:source": "./src/interaction/index.ts",
-      "types": "./dist/interaction/index.d.mts",
-      "import": "./dist/interaction/index.mjs"
+      "types": "./dist/interaction/index.d.ts",
+      "import": "./dist/interaction/index.js"
     },
     "./media": {
       "foldkit-plus:source": "./src/media/index.ts",
-      "types": "./dist/media/index.d.mts",
-      "import": "./dist/media/index.mjs"
+      "types": "./dist/media/index.d.ts",
+      "import": "./dist/media/index.js"
     },
     "./motion": {
       "foldkit-plus:source": "./src/motion/index.ts",
-      "types": "./dist/motion/index.d.mts",
-      "import": "./dist/motion/index.mjs"
+      "types": "./dist/motion/index.d.ts",
+      "import": "./dist/motion/index.js"
     },
     "./net": {
       "foldkit-plus:source": "./src/net/index.ts",
-      "types": "./dist/net/index.d.mts",
-      "import": "./dist/net/index.mjs"
+      "types": "./dist/net/index.d.ts",
+      "import": "./dist/net/index.js"
     },
     "./observers": {
       "foldkit-plus:source": "./src/observers/index.ts",
-      "types": "./dist/observers/index.d.mts",
-      "import": "./dist/observers/index.mjs"
+      "types": "./dist/observers/index.d.ts",
+      "import": "./dist/observers/index.js"
     },
     "./state": {
       "foldkit-plus:source": "./src/state/index.ts",
-      "types": "./dist/state/index.d.mts",
-      "import": "./dist/state/index.mjs"
+      "types": "./dist/state/index.d.ts",
+      "import": "./dist/state/index.js"
     },
     "./time": {
       "foldkit-plus:source": "./src/time/index.ts",
-      "types": "./dist/time/index.d.mts",
-      "import": "./dist/time/index.mjs"
+      "types": "./dist/time/index.d.ts",
+      "import": "./dist/time/index.js"
     },
     "./package.json": "./package.json"
   },
@@ -89,23 +89,23 @@
     "LICENSE"
   ],
   "dependencies": {
-    "foldkit-bundle": "0.8.1"
+    "foldkit-bundle": "0.9.0"
   },
   "peerDependencies": {
-    "effect": "^4.0.0",
-    "foldkit": "^0.169.0",
-    "foldkit-mixins": "^0.19.1"
+    "effect": "^4.1.0",
+    "foldkit": "^0.170.0",
+    "foldkit-mixins": "^0.21.0"
   },
   "devDependencies": {
-    "@effect/platform-browser": "^4.0.5",
+    "@effect/platform-browser": "^4.1.0",
     "@types/ws": "^8.18.2",
-    "effect": "^4.0.5",
-    "foldkit": "0.169.0",
+    "effect": "^4.1.0",
+    "foldkit": "0.170.0",
     "jsdom": "30.1.3",
     "tsdown": "^0.23.1",
     "typescript": "7.0.2",
     "ws": "^8.22.0",
-    "foldkit-mixins": "0.19.1"
+    "foldkit-mixins": "0.21.0"
   },
   "peerDependenciesMeta": {
     "foldkit-mixins": {