@kensio/quando 0.1.0 → 1.0.0

package/dist/parse-shape.js

@@ -0,0 +1,77 @@
+/**
+ * Checking that incoming JSON is the shape it claims to be.
+ *
+ * Nothing here knows anything about time. These are the checks any document
+ * needs on the way in, and they say what was found instead and where. The
+ * `path` threaded through them is what turns "not a string" into
+ * `rule.rules[1].rules[0].dates[0]: expected a string, found number`.
+ *
+ * [parse-fields.ts](./parse-fields.ts) sits on top with the checks that do
+ * know about time, such as days of the week and zones.
+ */
+export function fail(path, problem) {
+    throw new TypeError(`${path}: ${problem}`);
+}
+/** What a value looks like, for an error message. */
+export function shapeOf(value) {
+    if (value === null) {
+        return "null";
+    }
+    if (Array.isArray(value)) {
+        return "an array";
+    }
+    return typeof value;
+}
+/**
+ * `expected` names what should have been there, and reads straight into the
+ * message. "a rule object", "a layer object".
+ */
+export function asRecord(value, path, expected) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return fail(path, `expected ${expected}, found ${shapeOf(value)}`);
+    }
+    return value;
+}
+/**
+ * Refuses a field the thing being parsed does not have.
+ *
+ * Quietly ignoring one is the worse option by some distance. A rule document
+ * carrying `"zonee"` would parse as a perfectly valid rule with no zone, which
+ * is a *different schedule* read in whatever zone the query happened to use,
+ * and nothing would have said so.
+ *
+ * The cost is that a document written by a later version of Quando, carrying a
+ * field this one has not heard of, is rejected rather than tolerated. That is
+ * the right way round. A field exists to change what a document means, so
+ * ignoring an unknown one is agreeing to get the answer wrong quietly.
+ *
+ * `type` is exempt, because every caller has already read it to get here.
+ */
+export function checkFields(node, allowed, path, what) {
+    for (const field of Object.keys(node)) {
+        if (field !== "type" && !allowed.includes(field)) {
+            fail(`${path}.${field}`, allowed.length === 0
+                ? `is not a field of ${what}, which takes none`
+                : `is not a field of ${what}. Expected ${allowed.join(", ")}`);
+        }
+    }
+}
+export function asString(value, path) {
+    return typeof value === "string"
+        ? value
+        : fail(path, `expected a string, found ${shapeOf(value)}`);
+}
+export function asBoolean(value, path) {
+    return typeof value === "boolean"
+        ? value
+        : fail(path, `expected a boolean, found ${shapeOf(value)}`);
+}
+export function asStrings(value, path) {
+    if (!Array.isArray(value)) {
+        return fail(path, `expected an array, found ${shapeOf(value)}`);
+    }
+    return value.map((item, index) => typeof item === "string"
+        ? item
+        : fail(`${path}[${index}]`, `expected a string, found ${shapeOf(item)}`));
+}
+//# sourceMappingURL=parse-shape.js.map

package/dist/parse-shape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-shape.js","sourceRoot":"","sources":["../src/parse-shape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,UAAU,IAAI,CAAC,IAAY,EAAE,OAAe;IAChD,MAAM,IAAI,SAAS,CAAC,GAAG,IAAI,KAAK,OAAO,EAAE,CAAC,CAAC;AAC7C,CAAC;AAED,qDAAqD;AACrD,MAAM,UAAU,OAAO,CAAC,KAAc;IACpC,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QACnB,OAAO,MAAM,CAAC;IAChB,CAAC;IACD,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,UAAU,CAAC;IACpB,CAAC;IACD,OAAO,OAAO,KAAK,CAAC;AACtB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,QAAQ,CACtB,KAAc,EACd,IAAY,EACZ,QAAgB;IAEhB,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACxE,OAAO,IAAI,CAAC,IAAI,EAAE,YAAY,QAAQ,WAAW,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IACrE,CAAC;IACD,OAAO,KAAgC,CAAC;AAC1C,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,WAAW,CACzB,IAA6B,EAC7B,OAA0B,EAC1B,IAAY,EACZ,IAAY;IAEZ,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QACtC,IAAI,KAAK,KAAK,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YACjD,IAAI,CACF,GAAG,IAAI,IAAI,KAAK,EAAE,EAClB,OAAO,CAAC,MAAM,KAAK,CAAC;gBAClB,CAAC,CAAC,qBAAqB,IAAI,oBAAoB;gBAC/C,CAAC,CAAC,qBAAqB,IAAI,cAAc,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAChE,CAAC;QACJ,CAAC;IACH,CAAC;AACH,CAAC;AAED,MAAM,UAAU,QAAQ,CAAC,KAAc,EAAE,IAAY;IACnD,OAAO,OAAO,KAAK,KAAK,QAAQ;QAC9B,CAAC,CAAC,KAAK;QACP,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,4BAA4B,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;AAC/D,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,KAAc,EAAE,IAAY;IACpD,OAAO,OAAO,KAAK,KAAK,SAAS;QAC/B,CAAC,CAAC,KAAK;QACP,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,6BAA6B,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;AAChE,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,KAAc,EAAE,IAAY;IACpD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,IAAI,CAAC,IAAI,EAAE,4BAA4B,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAClE,CAAC;IACD,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAC/B,OAAO,IAAI,KAAK,QAAQ;QACtB,CAAC,CAAC,IAAI;QACN,CAAC,CAAC,IAAI,CAAC,GAAG,IAAI,IAAI,KAAK,GAAG,EAAE,4BAA4B,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAC3E,CAAC;AACJ,CAAC"}

package/dist/parse.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Turning arbitrary JSON back into a rule.
+ *
+ * This is the boundary. Rules are meant to be stored, sent and edited, so what
+ * comes back is whatever a database row, an API body or a form actually holds
+ * — and the useful thing to do with a bad one is say precisely what is wrong
+ * and where, rather than fail somewhere further in with the reason lost.
+ *
+ * Shape and vocabulary are checked here: is it an object, is the type one that
+ * exists, are those really days of the week, does that parse as a time. What a
+ * rule *means* is not — `interpret.ts` owns that, and duplicating it here would
+ * only give the two somewhere to disagree.
+ */
+import type { Rule } from "./rule.js";
+/**
+ * A rule from unknown JSON, or a `TypeError` saying what is wrong and where.
+ *
+ * The `path` is what appears in front of every message, so a rule nested six
+ * deep reports as `rule.rules[2].rules[0].days[3]` rather than as a puzzle.
+ */
+export declare function parseRule(value: unknown, path?: string): Rule;
+//# sourceMappingURL=parse.d.ts.map

package/dist/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAwBtC;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,SAAS,GAAG,IAAI,CA+D7D"}

package/dist/parse.js

@@ -0,0 +1,93 @@
+/**
+ * Turning arbitrary JSON back into a rule.
+ *
+ * This is the boundary. Rules are meant to be stored, sent and edited, so what
+ * comes back is whatever a database row, an API body or a form actually holds
+ * — and the useful thing to do with a bad one is say precisely what is wrong
+ * and where, rather than fail somewhere further in with the reason lost.
+ *
+ * Shape and vocabulary are checked here: is it an object, is the type one that
+ * exists, are those really days of the week, does that parse as a time. What a
+ * rule *means* is not — `interpret.ts` owns that, and duplicating it here would
+ * only give the two somewhere to disagree.
+ */
+import { asDates, asDays, asTime, zonePart } from "./parse-fields.js";
+import { asRecord, checkFields, fail, shapeOf } from "./parse-shape.js";
+/**
+ * Every rule type, and the fields it is allowed to carry. One table rather than
+ * two, so the list of known types and the list of known fields cannot drift.
+ */
+const FIELDS = new Map([
+    ["always", []],
+    ["never", []],
+    ["daysOfWeek", ["days", "zone"]],
+    ["timeOfDay", ["from", "to", "zone"]],
+    ["dates", ["dates", "zone"]],
+    ["all", ["rules"]],
+    ["any", ["rules"]],
+    ["not", ["rule"]],
+]);
+function asRules(value, path) {
+    if (!Array.isArray(value)) {
+        return fail(path, `expected an array of rules, found ${shapeOf(value)}`);
+    }
+    return value.map((rule, index) => parseRule(rule, `${path}[${index}]`));
+}
+/**
+ * A rule from unknown JSON, or a `TypeError` saying what is wrong and where.
+ *
+ * The `path` is what appears in front of every message, so a rule nested six
+ * deep reports as `rule.rules[2].rules[0].days[3]` rather than as a puzzle.
+ */
+export function parseRule(value, path = "rule") {
+    const node = asRecord(value, path, "a rule object");
+    const type = node["type"];
+    if (typeof type !== "string") {
+        return fail(`${path}.type`, `expected a string, found ${shapeOf(type)}`);
+    }
+    const allowed = FIELDS.get(type);
+    if (allowed === undefined) {
+        return fail(`${path}.type`, `"${type}" is not a rule type. Expected one of ${[...FIELDS.keys()].join(", ")}`);
+    }
+    checkFields(node, allowed, path, `a ${type} rule`);
+    switch (type) {
+        case "always": {
+            return { type: "always" };
+        }
+        case "never": {
+            return { type: "never" };
+        }
+        case "daysOfWeek": {
+            return {
+                type: "daysOfWeek",
+                days: asDays(node["days"], `${path}.days`),
+                ...zonePart(node, path),
+            };
+        }
+        case "dates": {
+            return {
+                type: "dates",
+                dates: asDates(node["dates"], `${path}.dates`),
+                ...zonePart(node, path),
+            };
+        }
+        case "timeOfDay": {
+            return {
+                type: "timeOfDay",
+                from: asTime(node["from"], `${path}.from`),
+                to: asTime(node["to"], `${path}.to`),
+                ...zonePart(node, path),
+            };
+        }
+        case "all": {
+            return { type: "all", rules: asRules(node["rules"], `${path}.rules`) };
+        }
+        case "any": {
+            return { type: "any", rules: asRules(node["rules"], `${path}.rules`) };
+        }
+        default: {
+            return { type: "not", rule: parseRule(node["rule"], `${path}.rule`) };
+        }
+    }
+}
+//# sourceMappingURL=parse.js.map

package/dist/parse.js.map

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

package/dist/plain-forms.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The plain forms the domain layer accepts in place of rules.
+ *
+ * `"09:00-17:00"` instead of `timeOfDay("09:00", "17:00")`, and `"2026-03-11"`
+ * instead of `dates("2026-03-11")`. Both are what someone writing a schedule
+ * by hand would type, and neither is ambiguous: a rule is an object and these
+ * are strings, so nothing has to guess which was meant.
+ *
+ * These check what they are given, which the rule layer deliberately does not
+ * — `timeOfDay` accepts any string and complains when the rule is evaluated,
+ * because parsing shape and deciding meaning are kept apart there. This layer
+ * exists to be written by hand, and a hand-written mistake is worth catching
+ * where it was written rather than at the first query.
+ */
+import type { Rule } from "./rule.js";
+/** A rule, a `"09:00-17:00"` window, or a whole day given as a date. */
+export type PlainRule = Rule | string;
+/** A wall-clock window from `"09:00-17:00"`, or a rule left as it is. */
+export declare function asHours(hours: PlainRule): Rule;
+/** Whole days from `"2026-03-11"`, or a rule left as it is. */
+export declare function asDays(scope: PlainRule): Rule;
+//# sourceMappingURL=plain-forms.d.ts.map

package/dist/plain-forms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plain-forms.d.ts","sourceRoot":"","sources":["../src/plain-forms.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEtC,wEAAwE;AACxE,MAAM,MAAM,SAAS,GAAG,IAAI,GAAG,MAAM,CAAC;AAStC,yEAAyE;AACzE,wBAAgB,OAAO,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAoB9C;AAED,+DAA+D;AAC/D,wBAAgB,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAe7C"}

package/dist/plain-forms.js

@@ -0,0 +1,54 @@
+/**
+ * The plain forms the domain layer accepts in place of rules.
+ *
+ * `"09:00-17:00"` instead of `timeOfDay("09:00", "17:00")`, and `"2026-03-11"`
+ * instead of `dates("2026-03-11")`. Both are what someone writing a schedule
+ * by hand would type, and neither is ambiguous: a rule is an object and these
+ * are strings, so nothing has to guess which was meant.
+ *
+ * These check what they are given, which the rule layer deliberately does not
+ * — `timeOfDay` accepts any string and complains when the rule is evaluated,
+ * because parsing shape and deciding meaning are kept apart there. This layer
+ * exists to be written by hand, and a hand-written mistake is worth catching
+ * where it was written rather than at the first query.
+ */
+import { dates, timeOfDay } from "./build.js";
+function badRange(range, problem) {
+    throw new RangeError(`"${range}" is not a range of times: ${problem}. ` +
+        `Expected something like "09:00-17:00".`);
+}
+/** A wall-clock window from `"09:00-17:00"`, or a rule left as it is. */
+export function asHours(hours) {
+    if (typeof hours !== "string") {
+        return hours;
+    }
+    const parts = hours.split("-");
+    if (parts.length !== 2) {
+        badRange(hours, `it has ${parts.length - 1} dashes rather than one`);
+    }
+    const [from = "", to = ""] = parts.map((part) => part.trim());
+    for (const time of [from, to]) {
+        try {
+            Temporal.PlainTime.from(time);
+        }
+        catch {
+            badRange(hours, `"${time}" is not a time of day`);
+        }
+    }
+    return timeOfDay(from, to);
+}
+/** Whole days from `"2026-03-11"`, or a rule left as it is. */
+export function asDays(scope) {
+    if (typeof scope !== "string") {
+        return scope;
+    }
+    try {
+        Temporal.PlainDate.from(scope);
+    }
+    catch {
+        throw new RangeError(`"${scope}" is not a date. Expected something like "2026-03-11", ` +
+            `or a rule such as weekdays().`);
+    }
+    return dates(scope);
+}
+//# sourceMappingURL=plain-forms.js.map

package/dist/plain-forms.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plain-forms.js","sourceRoot":"","sources":["../src/plain-forms.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAM9C,SAAS,QAAQ,CAAC,KAAa,EAAE,OAAe;IAC9C,MAAM,IAAI,UAAU,CAClB,IAAI,KAAK,8BAA8B,OAAO,IAAI;QAChD,wCAAwC,CAC3C,CAAC;AACJ,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,OAAO,CAAC,KAAgB;IACtC,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC/B,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvB,QAAQ,CAAC,KAAK,EAAE,UAAU,KAAK,CAAC,MAAM,GAAG,CAAC,yBAAyB,CAAC,CAAC;IACvE,CAAC;IAED,MAAM,CAAC,IAAI,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;IAC9D,KAAK,MAAM,IAAI,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC,EAAE,CAAC;QAC9B,IAAI,CAAC;YACH,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChC,CAAC;QAAC,MAAM,CAAC;YACP,QAAQ,CAAC,KAAK,EAAE,IAAI,IAAI,wBAAwB,CAAC,CAAC;QACpD,CAAC;IACH,CAAC;IAED,OAAO,SAAS,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;AAC7B,CAAC;AAED,+DAA+D;AAC/D,MAAM,UAAU,MAAM,CAAC,KAAgB;IACrC,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,KAAK,CAAC;IACf,CAAC;IAED,IAAI,CAAC;QACH,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC;IAAC,MAAM,CAAC;QACP,MAAM,IAAI,UAAU,CAClB,IAAI,KAAK,yDAAyD;YAChE,+BAA+B,CAClC,CAAC;IACJ,CAAC;IAED,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC;AACtB,CAAC"}

package/dist/query.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Asking a question, rather than reading the times something covers.
+ *
+ * `intervals` is the plumbing. These are what a caller actually wants: is it
+ * open now, how much working time is in this window, when does it next open,
+ * and — the one both of the libraries this evolves from were built around —
+ * where do you get to after three hours that only count while it is open.
+ *
+ * Each takes a rule, or a cascade narrowed to one of its values by
+ * [`assigned`](./assigned.ts). "Three hours while the warehouse is open" and
+ * "three hours while Alice is on call" are the same question.
+ *
+ * Durations are exact elapsed time throughout. Three operating hours means
+ * three real hours of opening, so a window spanning a clock change is measured
+ * by how long it lasted rather than by what the clock said.
+ */
+import { type Covers } from "./assigned.js";
+import type { Context } from "./context.js";
+import { type Interval } from "./interval.js";
+/**
+ * How far a search runs.
+ *
+ * With neither the context's `to` nor a `within`, a search is unbounded. That
+ * is fine and often what you want — the first interval of a satisfiable rule
+ * arrives immediately, however far the rule recurs. It is only a rule that
+ * covers *nothing* that has no answer to give and no way to discover it, and
+ * that case runs until stopped. Give a bound when the answer might be nothing.
+ */
+export interface Search {
+    /**
+     * Look no further ahead than this from where the search starts.
+     *
+     * Narrows only. A context that already ends before the horizon keeps its own
+     * end, because a caller who gave a window meant it.
+     */
+    readonly within?: Temporal.Duration;
+}
+/**
+ * Whether a rule, or a value a cascade assigns, covers an instant.
+ *
+ * Always terminates, whatever it is reading and whatever the context: it asks
+ * about the smallest window there is, so nothing can walk far looking for an
+ * answer.
+ */
+export declare function activeAt<V>(covers: Covers<V>, at: Temporal.ZonedDateTime, context?: Omit<Context, "from" | "to">): boolean;
+/**
+ * How much time a rule, or a value a cascade assigns, covers within a window.
+ *
+ * Needs a window with an end, because the alternative is a number that never
+ * finishes being counted.
+ */
+export declare function elapsed<V>(covers: Covers<V>, context: Context): Temporal.Duration;
+/**
+ * The next stretch of time covered, at or after the context's start.
+ *
+ * `undefined` when there is none within the search. If time is being covered
+ * already at the context's start, that stretch is returned clipped to begin
+ * there — "when does it next open" answers "it is open" rather than skipping
+ * to tomorrow.
+ */
+export declare function next<V>(covers: Covers<V>, context: Context, search?: Search): Interval | undefined;
+/**
+ * Where you get to after an amount of time that only counts while something
+ * holds.
+ *
+ * Three operating hours from an order placed at five to five on a Friday is
+ * some way into Monday morning, and this is the function that says where.
+ * `undefined` when the search runs out before the time does.
+ */
+export declare function advanceBy<V>(from: Temporal.ZonedDateTime, amount: Temporal.Duration, options: {
+    readonly during: Covers<V>;
+} & Search & Omit<Context, "from" | "to">): Temporal.ZonedDateTime | undefined;
+//# sourceMappingURL=query.d.ts.map

package/dist/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,KAAK,MAAM,EAAW,MAAM,eAAe,CAAC;AACrD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAwB,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AAMpE;;;;;;;;GAQG;AACH,MAAM,WAAW,MAAM;IACrB;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,QAAQ,CAAC;CACrC;AA0CD;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACxB,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EACjB,EAAE,EAAE,QAAQ,CAAC,aAAa,EAC1B,OAAO,CAAC,EAAE,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC,GACrC,OAAO,CAOT;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EACjB,OAAO,EAAE,OAAO,GACf,QAAQ,CAAC,QAAQ,CAenB;AAED;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAAC,CAAC,EACpB,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EACjB,OAAO,EAAE,OAAO,EAChB,MAAM,CAAC,EAAE,MAAM,GACd,QAAQ,GAAG,SAAS,CAGtB;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,IAAI,EAAE,QAAQ,CAAC,aAAa,EAC5B,MAAM,EAAE,QAAQ,CAAC,QAAQ,EACzB,OAAO,EAAE;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAA;CAAE,GAAG,MAAM,GAC9C,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC,GAC7B,QAAQ,CAAC,aAAa,GAAG,SAAS,CA8BpC"}

package/dist/query.js

@@ -0,0 +1,127 @@
+/**
+ * Asking a question, rather than reading the times something covers.
+ *
+ * `intervals` is the plumbing. These are what a caller actually wants: is it
+ * open now, how much working time is in this window, when does it next open,
+ * and — the one both of the libraries this evolves from were built around —
+ * where do you get to after three hours that only count while it is open.
+ *
+ * Each takes a rule, or a cascade narrowed to one of its values by
+ * [`assigned`](./assigned.ts). "Three hours while the warehouse is open" and
+ * "three hours while Alice is on call" are the same question.
+ *
+ * Durations are exact elapsed time throughout. Three operating hours means
+ * three real hours of opening, so a window spanning a clock change is measured
+ * by how long it lasted rather than by what the clock said.
+ */
+import { covered } from "./assigned.js";
+import { duration, earlierEnd } from "./interval.js";
+import { take } from "./stream.js";
+/** Zero, as a duration to accumulate onto. */
+const NOTHING = Temporal.Duration.from({ seconds: 0 });
+function bounded(context, search) {
+    const within = search?.within;
+    if (within === undefined) {
+        return context;
+    }
+    // Whichever runs out first. `within` narrows a search and must never widen
+    // one: a context that already ends on Saturday means the caller is not
+    // interested in Monday, whatever horizon the search asks for.
+    const horizon = context.from.add(within);
+    return { ...context, to: earlierEnd(context.to, horizon) ?? horizon };
+}
+/**
+ * Refuses an amount whose units do not mean one fixed length of time.
+ *
+ * A day is not 24 hours on the two mornings a year a clock changes, and a
+ * month is not any number of hours at all. Both halves of this function would
+ * otherwise disagree about that: the accounting compares durations without a
+ * reference point, where a day *is* 24 hours, while the final step adds to a
+ * `ZonedDateTime`, where it is a calendar day. `P1D` and `PT24H` would land an
+ * hour apart, and neither answer would be wrong enough to notice.
+ *
+ * Weeks and months do not even get that far — comparing them without a
+ * reference point throws, with an empty message.
+ */
+function checkExact(amount) {
+    const calendar = ["years", "months", "weeks", "days"].filter((unit) => amount[unit] !== 0);
+    if (calendar.length > 0) {
+        throw new RangeError(`advanceBy() measures elapsed time, so ${amount.toString()} is ambiguous: ` +
+            `${calendar.join(" and ")} are calendar units, and a day is not 24 hours ` +
+            `on the mornings a clock changes. Give hours, minutes or seconds.`);
+    }
+}
+/**
+ * Whether a rule, or a value a cascade assigns, covers an instant.
+ *
+ * Always terminates, whatever it is reading and whatever the context: it asks
+ * about the smallest window there is, so nothing can walk far looking for an
+ * answer.
+ */
+export function activeAt(covers, at, context) {
+    const moment = {
+        ...context,
+        from: at,
+        to: at.add({ nanoseconds: 1 }),
+    };
+    return take(covered(covers, moment), 1).length > 0;
+}
+/**
+ * How much time a rule, or a value a cascade assigns, covers within a window.
+ *
+ * Needs a window with an end, because the alternative is a number that never
+ * finishes being counted.
+ */
+export function elapsed(covers, context) {
+    if (context.to === undefined) {
+        throw new RangeError("elapsed() needs a window with an end: give the context a `to`.");
+    }
+    let total = NOTHING;
+    for (const interval of covered(covers, context)) {
+        const length = duration(interval);
+        if (length !== undefined) {
+            total = total.add(length);
+        }
+    }
+    return total.round({ largestUnit: "hour" });
+}
+/**
+ * The next stretch of time covered, at or after the context's start.
+ *
+ * `undefined` when there is none within the search. If time is being covered
+ * already at the context's start, that stretch is returned clipped to begin
+ * there — "when does it next open" answers "it is open" rather than skipping
+ * to tomorrow.
+ */
+export function next(covers, context, search) {
+    const [first] = take(covered(covers, bounded(context, search)), 1);
+    return first;
+}
+/**
+ * Where you get to after an amount of time that only counts while something
+ * holds.
+ *
+ * Three operating hours from an order placed at five to five on a Friday is
+ * some way into Monday morning, and this is the function that says where.
+ * `undefined` when the search runs out before the time does.
+ */
+export function advanceBy(from, amount, options) {
+    checkExact(amount);
+    if (Temporal.Duration.compare(amount, NOTHING) < 0) {
+        throw new RangeError(`advanceBy() cannot go backwards. Asked for ${amount.toString()}.`);
+    }
+    const { during, within, ...rest } = options;
+    const context = bounded({ ...rest, from }, within === undefined ? undefined : { within });
+    let remaining = amount;
+    for (const interval of covered(during, context)) {
+        const length = duration(interval);
+        // An interval with no end has more than enough of whatever is left.
+        if (length === undefined ||
+            Temporal.Duration.compare(length, remaining) >= 0) {
+            return interval.start?.add(remaining);
+        }
+        remaining = remaining.subtract(length);
+    }
+    return undefined;
+}
+//# sourceMappingURL=query.js.map

package/dist/query.js.map

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

package/dist/resolve.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Reading a cascade as the values it assigns, over time.
+ *
+ * Resolution is a fold. Each layer is read as the times it covers, and laid
+ * over everything below it by the cascade's {@link MergeStrategy}. Precedence
+ * falls out of that as the merge that keeps the later value, so a rota and a
+ * roster of headcounts take the same path through here and differ only in what
+ * they do where two layers meet.
+ *
+ * The regions themselves stay ordinary rules. A layer covers its own scope,
+ * minus anything a *replacing* layer above it has claimed, and that is
+ * `all(scope, not(any(…)))` which the rule interpreter already evaluates. So
+ * the clipping, the zone normalisation and the laziness all come along
+ * unchanged, and the one new sweep is the two-stream {@link overlay}.
+ *
+ * What comes back is only the time a cascade actually assigns. A moment no
+ * layer claims is absent from the stream rather than present with some empty
+ * value, for the same reason a rule yields only the time it covers. There is
+ * no such thing as the value of an unassigned moment.
+ */
+import type { Cascade } from "./cascade.js";
+import type { Context } from "./context.js";
+import { type ValuedStream } from "./valued-stream.js";
+/**
+ * The values a cascade assigns within a context, in order and coalesced.
+ *
+ * Lazy, and endless when the context has no end and the layers recur, which is
+ * the same contract `intervals` keeps because this is built out of it.
+ */
+export declare function resolve<V>(cascade: Cascade<V>, context: Context): ValuedStream<V>;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../src/resolve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAS,MAAM,cAAc,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAK5C,OAAO,EAAqB,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAE1E;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,OAAO,EAAE,OAAO,GACf,YAAY,CAAC,CAAC,CAAC,CAWjB"}

package/dist/resolve.js

@@ -0,0 +1,95 @@
+/**
+ * Reading a cascade as the values it assigns, over time.
+ *
+ * Resolution is a fold. Each layer is read as the times it covers, and laid
+ * over everything below it by the cascade's {@link MergeStrategy}. Precedence
+ * falls out of that as the merge that keeps the later value, so a rota and a
+ * roster of headcounts take the same path through here and differ only in what
+ * they do where two layers meet.
+ *
+ * The regions themselves stay ordinary rules. A layer covers its own scope,
+ * minus anything a *replacing* layer above it has claimed, and that is
+ * `all(scope, not(any(…)))` which the rule interpreter already evaluates. So
+ * the clipping, the zone normalisation and the laziness all come along
+ * unchanged, and the one new sweep is the two-stream {@link overlay}.
+ *
+ * What comes back is only the time a cascade actually assigns. A moment no
+ * layer claims is absent from the stream rather than present with some empty
+ * value, for the same reason a rule yields only the time it covers. There is
+ * no such thing as the value of an unassigned moment.
+ */
+import { intervals } from "./interpret.js";
+import { mergeBy } from "./merge.js";
+import { coalesce, overlay } from "./valued-stream.js";
+/**
+ * The values a cascade assigns within a context, in order and coalesced.
+ *
+ * Lazy, and endless when the context has no end and the layers recur, which is
+ * the same contract `intervals` keeps because this is built out of it.
+ */
+export function resolve(cascade, context) {
+    const merge = mergeBy(cascade.merge);
+    let stack = [];
+    for (const [index, layer] of cascade.layers.entries()) {
+        const above = cascade.layers.slice(index + 1);
+        const claimed = assignments(layer, unreplaced(layer.scope, above), context);
+        stack = overlay(stack, claimed, merge);
+    }
+    return coalesce(stack);
+}
+/**
+ * A layer's own scope, minus every scope a replacing layer above it claims.
+ *
+ * Nothing needs subtracting for an ordinary layer above. The fold already
+ * settles that, and under `override` the later value wins the overlap outright.
+ * A replacing layer is the case that cannot be left to the fold, because it
+ * claims its scope whether or not the cascade inside it assigns anything
+ * there. Closing early on one day is exactly that. The base hours must stay
+ * out of the afternoon the override dropped, rather than showing through it.
+ */
+function unreplaced(scope, above) {
+    const replacing = above.filter((layer) => "replace" in layer);
+    if (replacing.length === 0) {
+        return scope;
+    }
+    return {
+        type: "all",
+        rules: [
+            scope,
+            {
+                type: "not",
+                rule: { type: "any", rules: replacing.map((layer) => layer.scope) },
+            },
+        ],
+    };
+}
+/** What a layer assigns, over the region it covers. */
+function* assignments(layer, region, context) {
+    for (const interval of intervals(region, context)) {
+        if ("value" in layer) {
+            yield { ...interval, value: layer.value };
+            continue;
+        }
+        // A replacing layer claims the region and hands the question inwards. The
+        // inner cascade is resolved against the region rather than against the
+        // whole context, which is what stops it reaching outside the scope it
+        // replaces. It also carries its own merge, so a replacement says how its
+        // own layers combine without the cascade around it having a view.
+        yield* resolve(layer.replace, within(context, interval));
+    }
+}
+/**
+ * A context narrowed to one interval.
+ *
+ * The interval came from evaluating a rule against this context, so its start
+ * is inside the window and never unbounded. The fallback is for the type
+ * rather than for a case that occurs.
+ */
+function within(context, interval) {
+    const { from, to: _replaced, ...rest } = context;
+    const start = interval.start ?? from;
+    return interval.end === undefined
+        ? { ...rest, from: start }
+        : { ...rest, from: start, to: interval.end };
+}
+//# sourceMappingURL=resolve.js.map

package/dist/resolve.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.js","sourceRoot":"","sources":["../src/resolve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAKH,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAErC,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAqB,MAAM,oBAAoB,CAAC;AAE1E;;;;;GAKG;AACH,MAAM,UAAU,OAAO,CACrB,OAAmB,EACnB,OAAgB;IAEhB,MAAM,KAAK,GAAG,OAAO,CAAI,OAAO,CAAC,KAAK,CAAC,CAAC;IAExC,IAAI,KAAK,GAAoB,EAAE,CAAC;IAChC,KAAK,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,CAAC;QACtD,MAAM,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;QAC9C,MAAM,OAAO,GAAG,WAAW,CAAC,KAAK,EAAE,UAAU,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,OAAO,CAAC,CAAC;QAC5E,KAAK,GAAG,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;IACzC,CAAC;IAED,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC;AACzB,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,UAAU,CAAC,KAAW,EAAE,KAAgC;IAC/D,MAAM,SAAS,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,SAAS,IAAI,KAAK,CAAC,CAAC;IAC9D,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC3B,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO;QACL,IAAI,EAAE,KAAK;QACX,KAAK,EAAE;YACL,KAAK;YACL;gBACE,IAAI,EAAE,KAAK;gBACX,IAAI,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE;aACpE;SACF;KACF,CAAC;AACJ,CAAC;AAED,uDAAuD;AACvD,QAAQ,CAAC,CAAC,WAAW,CACnB,KAAe,EACf,MAAY,EACZ,OAAgB;IAEhB,KAAK,MAAM,QAAQ,IAAI,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;QAClD,IAAI,OAAO,IAAI,KAAK,EAAE,CAAC;YACrB,MAAM,EAAE,GAAG,QAAQ,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC;YAC1C,SAAS;QACX,CAAC;QAED,0EAA0E;QAC1E,uEAAuE;QACvE,sEAAsE;QACtE,yEAAyE;QACzE,kEAAkE;QAClE,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC;IAC3D,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,SAAS,MAAM,CAAC,OAAgB,EAAE,QAAkB;IAClD,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE,SAAS,EAAE,GAAG,IAAI,EAAE,GAAG,OAAO,CAAC;IACjD,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,IAAI,IAAI,CAAC;IAErC,OAAO,QAAQ,CAAC,GAAG,KAAK,SAAS;QAC/B,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE;QAC1B,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,QAAQ,CAAC,GAAG,EAAE,CAAC;AACjD,CAAC"}