import type { HostPowerSnapshot } from "@t3tools/contracts";
import * as Context from "effect/Context";
import * as DateTime from "effect/DateTime";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as PubSub from "effect/PubSub";
import * as Ref from "effect/Ref";
import * as Stream from "effect/Stream";
import * as DesktopTelemetryReceiver from "../resourceTelemetry/DesktopTelemetryReceiver.ts";
export class HostPowerMonitor extends Context.Service<
HostPowerMonitor,
{
readonly snapshot: Effect.Effect<HostPowerSnapshot>;
readonly report: (snapshot: HostPowerSnapshot) => Effect.Effect<void>;
readonly streamChanges: Stream.Stream<HostPowerSnapshot>;
}
>()("t3/background/HostPowerMonitor") {}
const makeUnknownSnapshot = (
source: HostPowerSnapshot["source"],
updatedAt: HostPowerSnapshot["updatedAt"],
): HostPowerSnapshot => ({
source,
idle: "unknown",
idleSeconds: null,
locked: "unknown",
suspended: false,
onBattery: "unknown",
lowPowerMode: "unknown",
thermalState: "unknown",
stale: true,
updatedAt,
});
function samePowerState(left: HostPowerSnapshot, right: HostPowerSnapshot): boolean {
return (
left.source === right.source &&
left.idle === right.idle &&
left.locked === right.locked &&
left.suspended === right.suspended &&
left.onBattery === right.onBattery &&
left.lowPowerMode === right.lowPowerMode &&
left.thermalState === right.thermalState &&
left.stale === right.stale
);
}
export const make = Effect.fn("background.hostPower.make")(function* (
initialSnapshot?: HostPowerSnapshot,
) {
const initial = initialSnapshot ?? makeUnknownSnapshot("unknown", yield* DateTime.now);
const latestRef = yield* Ref.make(initial);
const changes = yield* PubSub.sliding<HostPowerSnapshot>(1);
const report: HostPowerMonitor["Service"]["report"] = (snapshot) =>
Ref.modify(latestRef, (current) => {
if (DateTime.isLessThan(snapshot.updatedAt, current.updatedAt)) {
return [Option.none<HostPowerSnapshot>(), current] as const;
}
return [
samePowerState(current, snapshot) ? Option.none() : Option.some(snapshot),
snapshot,
] as const;
}).pipe(
Effect.flatMap(
Option.match({
onNone: () => Effect.void,
onSome: (next) => PubSub.publish(changes, next),
}),
),
Effect.asVoid,
);
return HostPowerMonitor.of({
snapshot: Ref.get(latestRef),
report,
streamChanges: Stream.fromPubSub(changes),
});
});
export const layer = Layer.effect(
HostPowerMonitor,
Effect.gen(function* () {
const desktopTelemetry = yield* DesktopTelemetryReceiver.DesktopTelemetryReceiver;
const desktopSubscription = yield* desktopTelemetry.subscribe;
const initial = desktopSubscription.latest;
const monitor = yield* Option.match(initial, {
onNone: () => make(),
onSome: (snapshot) => make(snapshot.power),
});
yield* desktopSubscription.changes.pipe(
Stream.map((snapshot) => snapshot.power),
Stream.runForEach(monitor.report),
Effect.forkScoped,
);
return monitor;
}),
);