@kensio/quando 0.1.0-beta.0 → 0.2.0

package/dist/schedule.js

@@ -0,0 +1,85 @@
+/**
+ * Opening hours, in the words people use for them.
+ *
+ * Everything here is a cascade underneath, and a `Schedule` *is* one — the
+ * same trick the rule builders use, so it serialises to the same document and
+ * `resolve` reads it unchanged. What this adds is vocabulary: nobody running a
+ * warehouse says "add a layer to the cascade", they say we are open weekdays,
+ * closed on bank holidays, and on the eleventh we close at three.
+ *
+ * Those three read in the order they are said, and each one outranks what came
+ * before it — which is the same precedence a cascade has, arrived at by
+ * writing the sentence in the obvious order rather than by knowing the rule.
+ */
+import { all } from "./build.js";
+import { layer, replace } from "./cascade.js";
+import { duration } from "./interval.js";
+import { asDays, asHours } from "./plain-forms.js";
+import { resolve } from "./resolve.js";
+import { take } from "./stream.js";
+/** Zero, as a duration to accumulate onto. */
+const NOTHING = Temporal.Duration.from({ seconds: 0 });
+function open(scope, hours) {
+    const when = asDays(scope);
+    return layer(hours === undefined ? when : all(when, asHours(hours)), true);
+}
+function build(layers) {
+    const self = {
+        type: "cascade",
+        layers,
+        open: (scope, hours) => build([...layers, open(scope, hours)]),
+        closed: (scope) => build([...layers, layer(asDays(scope), false)]),
+        hoursOn: (day, hours) => build([...layers, replace(asDays(day), asHours(hours))]),
+        isOpen: (at) => {
+            // The smallest window there is, so this terminates whatever the layers
+            // say — the same trick `activeAt` uses on a rule.
+            const moment = { from: at, to: at.add({ nanoseconds: 1 }) };
+            const [now] = take(resolve(self, moment), 1);
+            return now?.value ?? false;
+        },
+        opensNext: (at, within) => {
+            const search = within === undefined ? { from: at } : { from: at, to: at.add(within) };
+            for (const period of resolve(self, search)) {
+                if (!period.value) {
+                    continue;
+                }
+                if (within === undefined || period.start === undefined) {
+                    return period;
+                }
+                // The horizon bounds how far to look, not what is found. Everything
+                // resolved against a context is clipped to it, so a stretch that runs
+                // past the horizon comes back ending at the horizon — which reads as a
+                // closing time and is not one. Read it again from its own start, with
+                // nothing to clip it, so the end is when it really closes.
+                const [whole] = take(resolve(self, { from: period.start }), 1);
+                return whole ?? period;
+            }
+            return;
+        },
+        openBetween: (from, to) => {
+            let total = NOTHING;
+            for (const period of resolve(self, { from, to })) {
+                const length = period.value ? duration(period) : undefined;
+                if (length !== undefined) {
+                    total = total.add(length);
+                }
+            }
+            return total.round({ largestUnit: "hour" });
+        },
+    };
+    return self;
+}
+/**
+ * An empty schedule: open for nothing until something says otherwise.
+ *
+ * ```ts
+ * const openingHours = schedule()
+ *   .open(weekdays(), "09:00-17:00")
+ *   .closed("2026-12-25")
+ *   .hoursOn("2026-03-11", "09:00-15:00");
+ * ```
+ */
+export function schedule() {
+    return build([]);
+}
+//# sourceMappingURL=schedule.js.map

package/dist/schedule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedule.js","sourceRoot":"","sources":["../src/schedule.ts"],"names":[],"mappings":"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"}

package/dist/time-rules.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The rule that selects a wall-clock window within each day.
+ *
+ * Wall clock rather than elapsed time is the whole point: across a daylight
+ * saving transition the clock times stay put and the real length of the window
+ * changes, which is what a schedule means by "nine to five".
+ */
+import { type Context } from "./context.js";
+import type { IntervalStream } from "./interval-stream.js";
+/**
+ * A wall-clock window within each day, endless unless the context bounds it.
+ *
+ * Starts a day earlier than the context does, because a window that wraps past
+ * midnight may have opened yesterday and still be running. Clipping to the
+ * window drops whatever that turns up too early.
+ */
+export declare function timeOfDayIntervals(context: Context, from: string, to: string, zone?: string): IntervalStream;
+//# sourceMappingURL=time-rules.d.ts.map

package/dist/time-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-rules.d.ts","sourceRoot":"","sources":["../src/time-rules.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,KAAK,OAAO,EAAU,MAAM,cAAc,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D;;;;;;GAMG;AACH,wBAAiB,kBAAkB,CACjC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,IAAI,CAAC,EAAE,MAAM,GACZ,cAAc,CAgDhB"}

package/dist/time-rules.js

@@ -0,0 +1,55 @@
+/**
+ * The rule that selects a wall-clock window within each day.
+ *
+ * Wall clock rather than elapsed time is the whole point: across a daylight
+ * saving transition the clock times stay put and the real length of the window
+ * changes, which is what a schedule means by "nine to five".
+ */
+import { zoneOf } from "./context.js";
+/**
+ * A wall-clock window within each day, endless unless the context bounds it.
+ *
+ * Starts a day earlier than the context does, because a window that wraps past
+ * midnight may have opened yesterday and still be running. Clipping to the
+ * window drops whatever that turns up too early.
+ */
+export function* timeOfDayIntervals(context, from, to, zone) {
+    const inZone = zoneOf(context, zone);
+    const opens = Temporal.PlainTime.from(from);
+    const closes = Temporal.PlainTime.from(to);
+    if (Temporal.PlainTime.compare(opens, closes) === 0) {
+        throw new RangeError(`A time-of-day window from ${from} to ${to} has the same start and end. ` +
+            `Use { type: "always" } for a whole day.`);
+    }
+    // Earlier `to` than `from` means the window runs past midnight into the day
+    // after — a night shift, not an empty window.
+    const wraps = Temporal.PlainTime.compare(closes, opens) < 0;
+    const stop = context.to;
+    let date = context.from
+        .withTimeZone(inZone)
+        .toPlainDate()
+        .subtract({ days: 1 });
+    for (;;) {
+        const start = date.toZonedDateTime({ timeZone: inZone, plainTime: opens });
+        if (stop !== undefined &&
+            Temporal.ZonedDateTime.compare(start, stop) >= 0) {
+            return;
+        }
+        const closing = wraps ? date.add({ days: 1 }) : date;
+        const end = closing.toZonedDateTime({
+            timeZone: inZone,
+            plainTime: closes,
+        });
+        // A window can collapse to nothing on the morning clocks go forward. Both
+        // ends of 01:00-02:00 in London on 2026-03-29 resolve to the same instant,
+        // because the hour between them does not exist and Temporal's default
+        // disambiguation moves a nonexistent time forward to the far side of the
+        // gap. Yielding that would put a zero-length interval into a stream whose
+        // contract says there are none.
+        if (Temporal.ZonedDateTime.compare(start, end) < 0) {
+            yield { start, end };
+        }
+        date = date.add({ days: 1 });
+    }
+}
+//# sourceMappingURL=time-rules.js.map

package/dist/time-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-rules.js","sourceRoot":"","sources":["../src/time-rules.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAgB,MAAM,EAAE,MAAM,cAAc,CAAC;AAGpD;;;;;;GAMG;AACH,MAAM,SAAS,CAAC,CAAC,kBAAkB,CACjC,OAAgB,EAChB,IAAY,EACZ,EAAU,EACV,IAAa;IAEb,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IACrC,MAAM,KAAK,GAAG,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC5C,MAAM,MAAM,GAAG,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAE3C,IAAI,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QACpD,MAAM,IAAI,UAAU,CAClB,6BAA6B,IAAI,OAAO,EAAE,+BAA+B;YACvE,yCAAyC,CAC5C,CAAC;IACJ,CAAC;IAED,4EAA4E;IAC5E,8CAA8C;IAC9C,MAAM,KAAK,GAAG,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IAC5D,MAAM,IAAI,GAAG,OAAO,CAAC,EAAE,CAAC;IACxB,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI;SACpB,YAAY,CAAC,MAAM,CAAC;SACpB,WAAW,EAAE;SACb,QAAQ,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC;IAEzB,SAAS,CAAC;QACR,MAAM,KAAK,GAAG,IAAI,CAAC,eAAe,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;QAC3E,IACE,IAAI,KAAK,SAAS;YAClB,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,EAChD,CAAC;YACD,OAAO;QACT,CAAC;QAED,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QACrD,MAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC;YAClC,QAAQ,EAAE,MAAM;YAChB,SAAS,EAAE,MAAM;SAClB,CAAC,CAAC;QAEH,0EAA0E;QAC1E,2EAA2E;QAC3E,sEAAsE;QACtE,yEAAyE;QACzE,0EAA0E;QAC1E,gCAAgC;QAChC,IAAI,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACnD,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC;QACvB,CAAC;QAED,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC;IAC/B,CAAC;AACH,CAAC"}

package/dist/valued-stream.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Streams of intervals that carry values, and the two operations resolution
+ * needs over them.
+ *
+ * The same shape as `interval-stream.ts` one level down, and deliberately
+ * separate from it: those sweeps are set algebra over *when*, and nothing in
+ * them has an opinion about values. These two do nothing but carry values
+ * along, which is why neither needs the overlap arithmetic next door.
+ */
+import type { Valued } from "./cascade.js";
+/**
+ * A lazy sequence of valued intervals.
+ *
+ * Same contract as `IntervalStream` — ascending by start, non-overlapping,
+ * coalesced — with one addition: touching intervals carrying the same value
+ * are merged, so where two intervals do touch, the values on either side of
+ * the boundary differ.
+ */
+export type ValuedStream<V> = Iterable<Valued<V>>;
+/**
+ * One ascending stream from many.
+ *
+ * The sources are disjoint by construction — a moment is won by exactly one
+ * layer — so this only has to take whichever starts earliest, with none of the
+ * overlap arithmetic the interval sweeps need.
+ */
+export declare function interleave<V>(sources: readonly ValuedStream<V>[]): ValuedStream<V>;
+/**
+ * Adjacent intervals carrying the same value are one interval.
+ *
+ * Without this, a run that happens to be split across two layers comes back as
+ * two touching intervals with equal values — the same assignment said twice,
+ * and a stream that no longer satisfies the coalesced contract the rest of the
+ * library keeps.
+ *
+ * Sameness is `Object.is`, so primitives and shared references merge while
+ * structurally-equal objects do not. That is the conservative way round: it
+ * splits an interval that could have been merged rather than merging two the
+ * caller meant to keep apart.
+ */
+export declare function coalesce<V>(source: ValuedStream<V>): ValuedStream<V>;
+//# sourceMappingURL=valued-stream.d.ts.map

package/dist/valued-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valued-stream.d.ts","sourceRoot":"","sources":["../src/valued-stream.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAI3C;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAElD;;;;;;GAMG;AACH,wBAAiB,UAAU,CAAC,CAAC,EAC3B,OAAO,EAAE,SAAS,YAAY,CAAC,CAAC,CAAC,EAAE,GAClC,YAAY,CAAC,CAAC,CAAC,CAyBjB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAiB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAmBrE"}

package/dist/valued-stream.js

@@ -0,0 +1,77 @@
+/**
+ * Streams of intervals that carry values, and the two operations resolution
+ * needs over them.
+ *
+ * The same shape as `interval-stream.ts` one level down, and deliberately
+ * separate from it: those sweeps are set algebra over *when*, and nothing in
+ * them has an opinion about values. These two do nothing but carry values
+ * along, which is why neither needs the overlap arithmetic next door.
+ */
+import { compareStarts } from "./interval.js";
+import { peekable } from "./stream.js";
+/**
+ * One ascending stream from many.
+ *
+ * The sources are disjoint by construction — a moment is won by exactly one
+ * layer — so this only has to take whichever starts earliest, with none of the
+ * overlap arithmetic the interval sweeps need.
+ */
+export function* interleave(sources) {
+    const fronts = sources.map((source) => peekable(source));
+    for (;;) {
+        let earliest;
+        let from;
+        for (const front of fronts) {
+            const next = front.peek();
+            if (next !== undefined &&
+                (earliest === undefined ||
+                    compareStarts(next.start, earliest.start) < 0)) {
+                earliest = next;
+                from = front;
+            }
+        }
+        if (from === undefined || earliest === undefined) {
+            return;
+        }
+        from.drop();
+        yield earliest;
+    }
+}
+/**
+ * Adjacent intervals carrying the same value are one interval.
+ *
+ * Without this, a run that happens to be split across two layers comes back as
+ * two touching intervals with equal values — the same assignment said twice,
+ * and a stream that no longer satisfies the coalesced contract the rest of the
+ * library keeps.
+ *
+ * Sameness is `Object.is`, so primitives and shared references merge while
+ * structurally-equal objects do not. That is the conservative way round: it
+ * splits an interval that could have been merged rather than merging two the
+ * caller meant to keep apart.
+ */
+export function* coalesce(source) {
+    let open;
+    for (const next of source) {
+        if (open === undefined) {
+            open = next;
+            continue;
+        }
+        if (Object.is(open.value, next.value) && touches(open, next)) {
+            open = { ...open, end: next.end };
+            continue;
+        }
+        yield open;
+        open = next;
+    }
+    if (open !== undefined) {
+        yield open;
+    }
+}
+/** Whether one interval ends exactly where the next begins. */
+function touches(open, next) {
+    return (open.end !== undefined &&
+        next.start !== undefined &&
+        Temporal.ZonedDateTime.compare(open.end, next.start) === 0);
+}
+//# sourceMappingURL=valued-stream.js.map

package/dist/valued-stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"valued-stream.js","sourceRoot":"","sources":["../src/valued-stream.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAYvC;;;;;;GAMG;AACH,MAAM,SAAS,CAAC,CAAC,UAAU,CACzB,OAAmC;IAEnC,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;IAEzD,SAAS,CAAC;QACR,IAAI,QAA+B,CAAC;QACpC,IAAI,IAAyC,CAAC;QAE9C,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YAC3B,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;YAC1B,IACE,IAAI,KAAK,SAAS;gBAClB,CAAC,QAAQ,KAAK,SAAS;oBACrB,aAAa,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAChD,CAAC;gBACD,QAAQ,GAAG,IAAI,CAAC;gBAChB,IAAI,GAAG,KAAK,CAAC;YACf,CAAC;QACH,CAAC;QAED,IAAI,IAAI,KAAK,SAAS,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YACjD,OAAO;QACT,CAAC;QACD,IAAI,CAAC,IAAI,EAAE,CAAC;QACZ,MAAM,QAAQ,CAAC;IACjB,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,SAAS,CAAC,CAAC,QAAQ,CAAI,MAAuB;IAClD,IAAI,IAA2B,CAAC;IAEhC,KAAK,MAAM,IAAI,IAAI,MAAM,EAAE,CAAC;QAC1B,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,IAAI,GAAG,IAAI,CAAC;YACZ,SAAS;QACX,CAAC;QACD,IAAI,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC;YAC7D,IAAI,GAAG,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC;YAClC,SAAS;QACX,CAAC;QACD,MAAM,IAAI,CAAC;QACX,IAAI,GAAG,IAAI,CAAC;IACd,CAAC;IAED,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QACvB,MAAM,IAAI,CAAC;IACb,CAAC;AACH,CAAC;AAED,+DAA+D;AAC/D,SAAS,OAAO,CAAC,IAAqB,EAAE,IAAqB;IAC3D,OAAO,CACL,IAAI,CAAC,GAAG,KAAK,SAAS;QACtB,IAAI,CAAC,KAAK,KAAK,SAAS;QACxB,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAC3D,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kensio/quando",
-  "version": "0.1.0-beta.0",
+  "version": "0.2.0",
   "description": "Declarative temporal rules for schedules, deadlines, constraints, and exceptions",
   "repository": "https://github.com/KensioSoftware/quando",
   "homepage": "https://quandojs.dev",