spanset 0.0.0-stage → 0.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +117 -2
- package/dist/index.cjs +316 -0
- package/dist/index.cjs.map +1 -0
- package/dist/index.d.cts +105 -0
- package/dist/index.d.ts +105 -0
- package/dist/index.js +290 -0
- package/dist/index.js.map +1 -0
- package/package.json +61 -4
package/LICENSE
ADDED
|
@@ -0,0 +1,21 @@
|
|
|
1
|
+
MIT License
|
|
2
|
+
|
|
3
|
+
Copyright (c) 2026 spanset contributors
|
|
4
|
+
|
|
5
|
+
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
6
|
+
of this software and associated documentation files (the "Software"), to deal
|
|
7
|
+
in the Software without restriction, including without limitation the rights
|
|
8
|
+
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
9
|
+
copies of the Software, and to permit persons to whom the Software is
|
|
10
|
+
furnished to do so, subject to the following conditions:
|
|
11
|
+
|
|
12
|
+
The above copyright notice and this permission notice shall be included in all
|
|
13
|
+
copies or substantial portions of the Software.
|
|
14
|
+
|
|
15
|
+
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
16
|
+
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
17
|
+
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
18
|
+
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
19
|
+
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
20
|
+
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
21
|
+
SOFTWARE.
|
package/README.md
CHANGED
|
@@ -1,3 +1,118 @@
|
|
|
1
|
-
#
|
|
1
|
+
# spanset
|
|
2
2
|
|
|
3
|
-
|
|
3
|
+
Immutable sets of half-open intervals `[start, end)` for JavaScript and TypeScript.
|
|
4
|
+
Union, intersect, subtract, complement, and "find me a free 30-minute slot" in a few lines.
|
|
5
|
+
Zero dependencies, ESM + CommonJS, fully typed.
|
|
6
|
+
|
|
7
|
+
```sh
|
|
8
|
+
npm install spanset
|
|
9
|
+
```
|
|
10
|
+
|
|
11
|
+
## Why
|
|
12
|
+
|
|
13
|
+
Lots of everyday problems are really interval arithmetic:
|
|
14
|
+
|
|
15
|
+
- When are *all* attendees free between 9:00 and 18:00?
|
|
16
|
+
- Which parts of a video timeline are not covered by subtitles?
|
|
17
|
+
- Which byte ranges of a file are still missing from the download?
|
|
18
|
+
- How many total hours did these overlapping shifts cover?
|
|
19
|
+
|
|
20
|
+
`spanset` keeps every set in canonical form (sorted, disjoint, no touching spans),
|
|
21
|
+
so results are always clean and comparable.
|
|
22
|
+
|
|
23
|
+
## Quick start
|
|
24
|
+
|
|
25
|
+
```ts
|
|
26
|
+
import { SpanSet, spans } from "spanset";
|
|
27
|
+
|
|
28
|
+
const a = spans([0, 10], [20, 30]);
|
|
29
|
+
const b = spans([5, 25]);
|
|
30
|
+
|
|
31
|
+
a.union(b).toString(); // "[0, 30)"
|
|
32
|
+
a.intersect(b).toString(); // "[5, 10) ∪ [20, 25)"
|
|
33
|
+
a.subtract(b).toString(); // "[0, 5) ∪ [25, 30)"
|
|
34
|
+
a.gaps().toString(); // "[10, 20)"
|
|
35
|
+
a.measure; // 20
|
|
36
|
+
a.has(10); // false — half-open, 10 is not included
|
|
37
|
+
```
|
|
38
|
+
|
|
39
|
+
### Scheduling example
|
|
40
|
+
|
|
41
|
+
Dates work anywhere a number does (they are stored as epoch milliseconds).
|
|
42
|
+
|
|
43
|
+
```ts
|
|
44
|
+
import { spans } from "spanset";
|
|
45
|
+
|
|
46
|
+
const MIN = 60_000;
|
|
47
|
+
const t = (h: number, m = 0) => new Date(2026, 10, 18, h, m);
|
|
48
|
+
|
|
49
|
+
const workday = spans([t(9), t(18)]);
|
|
50
|
+
const alice = spans([t(9), t(10, 30)], [t(13), t(14)]);
|
|
51
|
+
const bob = spans([t(10), t(11)], [t(15), t(17)]);
|
|
52
|
+
|
|
53
|
+
const busy = alice.union(bob).expand(0, 5 * MIN); // 5-minute buffer after each meeting
|
|
54
|
+
|
|
55
|
+
busy.free(workday, 60 * MIN).toDates();
|
|
56
|
+
// all shared free blocks of at least an hour
|
|
57
|
+
|
|
58
|
+
busy.findSlot(30 * MIN, workday, { step: 15 * MIN });
|
|
59
|
+
// { start: <11:15>, end: <11:45> } — earliest 30-minute slot on a quarter hour
|
|
60
|
+
```
|
|
61
|
+
|
|
62
|
+
## API
|
|
63
|
+
|
|
64
|
+
### Creating
|
|
65
|
+
|
|
66
|
+
| | |
|
|
67
|
+
|---|---|
|
|
68
|
+
| `spans(...inputs)` / `SpanSet.of(...inputs)` | Build from spans. Overlapping and adjacent spans merge. |
|
|
69
|
+
| `SpanSet.from(input)` | Build from a `SpanSet`, one span, an array, or any iterable of spans. |
|
|
70
|
+
| `SpanSet.empty` / `SpanSet.all` | The empty set / `(-∞, ∞)`. |
|
|
71
|
+
|
|
72
|
+
A span input is `[start, end]` or `{ start, end }`, where each bound is a `number` or `Date`.
|
|
73
|
+
Empty spans (`start === end`) are ignored; `start > end` throws `RangeError`; `NaN` or invalid dates throw `TypeError`.
|
|
74
|
+
|
|
75
|
+
### Reading
|
|
76
|
+
|
|
77
|
+
| | |
|
|
78
|
+
|---|---|
|
|
79
|
+
| `.spans` | Frozen array of `{ start, end }`, sorted and disjoint. |
|
|
80
|
+
| `.count`, `.isEmpty`, `.measure`, `.bounds` | Number of spans, emptiness, total length, overall extent. |
|
|
81
|
+
| `.has(point)`, `.spanAt(point)` | Point lookup in O(log n). |
|
|
82
|
+
| `.overlaps(x)`, `.covers(x)`, `.equals(x)` | Relations with another set or span. |
|
|
83
|
+
|
|
84
|
+
### Combining (all O(n + m), all return a new `SpanSet`)
|
|
85
|
+
|
|
86
|
+
`.union(...xs)`, `.intersect(x)`, `.subtract(x)`, `.xor(x)`, `.complement(within?)`, `.clip(within)`, `.gaps()`
|
|
87
|
+
|
|
88
|
+
### Transforming
|
|
89
|
+
|
|
90
|
+
| | |
|
|
91
|
+
|---|---|
|
|
92
|
+
| `.expand(before, after = before)` | Grow (or, with negatives, shrink) each span; merges/drops as needed. |
|
|
93
|
+
| `.shift(delta)` | Move every span. |
|
|
94
|
+
| `.filter(fn)` | Keep spans matching a predicate. |
|
|
95
|
+
|
|
96
|
+
### Scheduling
|
|
97
|
+
|
|
98
|
+
| | |
|
|
99
|
+
|---|---|
|
|
100
|
+
| `.free(within, minLength = 0)` | Free blocks inside `within`, at least `minLength` long. |
|
|
101
|
+
| `.findSlot(length, within, { step?, origin? })` | Earliest free span of exactly `length`, optionally aligned to multiples of `step` from `origin`. Returns `undefined` if nothing fits. Use a bounded `within`. |
|
|
102
|
+
|
|
103
|
+
### Output
|
|
104
|
+
|
|
105
|
+
`.toArray()` → `[start, end][]`, `.toDates()` → `{ start: Date, end: Date }[]`,
|
|
106
|
+
`.toJSON()`, `.toString()`, and iteration (`for (const { start, end } of set)`).
|
|
107
|
+
|
|
108
|
+
## Semantics
|
|
109
|
+
|
|
110
|
+
- Intervals are **half-open**: `[1, 3)` contains `1` and `2.999`, not `3`.
|
|
111
|
+
This makes `[1, 3)` and `[3, 5)` combine into `[1, 5)` with no gap and no overlap,
|
|
112
|
+
which is what you want for time ranges.
|
|
113
|
+
- `Infinity` / `-Infinity` are valid bounds.
|
|
114
|
+
- Instances and their spans are frozen; methods never mutate.
|
|
115
|
+
|
|
116
|
+
## License
|
|
117
|
+
|
|
118
|
+
MIT
|
package/dist/index.cjs
ADDED
|
@@ -0,0 +1,316 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
var __defProp = Object.defineProperty;
|
|
3
|
+
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
4
|
+
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
5
|
+
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
6
|
+
var __export = (target, all) => {
|
|
7
|
+
for (var name in all)
|
|
8
|
+
__defProp(target, name, { get: all[name], enumerable: true });
|
|
9
|
+
};
|
|
10
|
+
var __copyProps = (to, from, except, desc) => {
|
|
11
|
+
if (from && typeof from === "object" || typeof from === "function") {
|
|
12
|
+
for (let key of __getOwnPropNames(from))
|
|
13
|
+
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
14
|
+
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
15
|
+
}
|
|
16
|
+
return to;
|
|
17
|
+
};
|
|
18
|
+
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
19
|
+
|
|
20
|
+
// src/index.ts
|
|
21
|
+
var index_exports = {};
|
|
22
|
+
__export(index_exports, {
|
|
23
|
+
SpanSet: () => SpanSet,
|
|
24
|
+
spans: () => spans
|
|
25
|
+
});
|
|
26
|
+
module.exports = __toCommonJS(index_exports);
|
|
27
|
+
function toNumber(b, what) {
|
|
28
|
+
const n = b instanceof Date ? b.getTime() : b;
|
|
29
|
+
if (typeof n !== "number" || Number.isNaN(n)) {
|
|
30
|
+
throw new TypeError(`spanset: ${what} must be a number or a valid Date, got ${String(b)}`);
|
|
31
|
+
}
|
|
32
|
+
return n;
|
|
33
|
+
}
|
|
34
|
+
function isBound(v) {
|
|
35
|
+
return typeof v === "number" || v instanceof Date;
|
|
36
|
+
}
|
|
37
|
+
function isSingleSpan(v) {
|
|
38
|
+
if (Array.isArray(v)) return v.length === 2 && isBound(v[0]) && isBound(v[1]);
|
|
39
|
+
return typeof v === "object" && v !== null && "start" in v && "end" in v;
|
|
40
|
+
}
|
|
41
|
+
function parseSpan(input) {
|
|
42
|
+
const [s, e] = Array.isArray(input) ? input : [input.start, input.end];
|
|
43
|
+
const start = toNumber(s, "start");
|
|
44
|
+
const end = toNumber(e, "end");
|
|
45
|
+
if (start > end) {
|
|
46
|
+
throw new RangeError(`spanset: start (${start}) must not be greater than end (${end})`);
|
|
47
|
+
}
|
|
48
|
+
return start === end ? null : Object.freeze({ start, end });
|
|
49
|
+
}
|
|
50
|
+
function normalize(spans2) {
|
|
51
|
+
if (spans2.length < 2) return spans2;
|
|
52
|
+
spans2.sort((a, b) => a.start - b.start || a.end - b.end);
|
|
53
|
+
const out = [spans2[0]];
|
|
54
|
+
for (let i = 1; i < spans2.length; i++) {
|
|
55
|
+
const cur = spans2[i];
|
|
56
|
+
const last = out[out.length - 1];
|
|
57
|
+
if (cur.start <= last.end) {
|
|
58
|
+
if (cur.end > last.end) out[out.length - 1] = Object.freeze({ start: last.start, end: cur.end });
|
|
59
|
+
} else {
|
|
60
|
+
out.push(cur);
|
|
61
|
+
}
|
|
62
|
+
}
|
|
63
|
+
return out;
|
|
64
|
+
}
|
|
65
|
+
var EMPTY_SPANS = Object.freeze([]);
|
|
66
|
+
var SpanSet = class _SpanSet {
|
|
67
|
+
#spans;
|
|
68
|
+
constructor(normalized) {
|
|
69
|
+
this.#spans = Object.freeze(normalized);
|
|
70
|
+
}
|
|
71
|
+
/** The empty set. */
|
|
72
|
+
static empty = new _SpanSet(EMPTY_SPANS);
|
|
73
|
+
/** The set covering the whole number line. */
|
|
74
|
+
static all = new _SpanSet([Object.freeze({ start: -Infinity, end: Infinity })]);
|
|
75
|
+
/** Builds a set from any number of spans; overlapping spans are merged. */
|
|
76
|
+
static of(...inputs) {
|
|
77
|
+
return _SpanSet.from(inputs);
|
|
78
|
+
}
|
|
79
|
+
/** Builds a set from a SpanSet, a single span, or a list/iterable of spans. */
|
|
80
|
+
static from(input) {
|
|
81
|
+
if (input instanceof _SpanSet) return input;
|
|
82
|
+
if (isSingleSpan(input)) {
|
|
83
|
+
const s = parseSpan(input);
|
|
84
|
+
return s ? new _SpanSet([s]) : _SpanSet.empty;
|
|
85
|
+
}
|
|
86
|
+
const spans2 = [];
|
|
87
|
+
for (const item of input) {
|
|
88
|
+
const s = parseSpan(item);
|
|
89
|
+
if (s) spans2.push(s);
|
|
90
|
+
}
|
|
91
|
+
return spans2.length ? new _SpanSet(normalize(spans2)) : _SpanSet.empty;
|
|
92
|
+
}
|
|
93
|
+
/** The canonical spans, sorted and disjoint. */
|
|
94
|
+
get spans() {
|
|
95
|
+
return this.#spans;
|
|
96
|
+
}
|
|
97
|
+
/** Number of disjoint spans. */
|
|
98
|
+
get count() {
|
|
99
|
+
return this.#spans.length;
|
|
100
|
+
}
|
|
101
|
+
get isEmpty() {
|
|
102
|
+
return this.#spans.length === 0;
|
|
103
|
+
}
|
|
104
|
+
/** Total length covered by the set (may be `Infinity`). */
|
|
105
|
+
get measure() {
|
|
106
|
+
let total = 0;
|
|
107
|
+
for (const s of this.#spans) total += s.end - s.start;
|
|
108
|
+
return total;
|
|
109
|
+
}
|
|
110
|
+
/** The smallest single span containing the whole set, or `undefined` if empty. */
|
|
111
|
+
get bounds() {
|
|
112
|
+
const s = this.#spans;
|
|
113
|
+
if (!s.length) return void 0;
|
|
114
|
+
return Object.freeze({ start: s[0].start, end: s[s.length - 1].end });
|
|
115
|
+
}
|
|
116
|
+
/** Index of the span containing `point`, or -1. Binary search, O(log n). */
|
|
117
|
+
#indexOf(point) {
|
|
118
|
+
const s = this.#spans;
|
|
119
|
+
let lo = 0;
|
|
120
|
+
let hi = s.length - 1;
|
|
121
|
+
while (lo <= hi) {
|
|
122
|
+
const mid = lo + hi >>> 1;
|
|
123
|
+
const span = s[mid];
|
|
124
|
+
if (point < span.start) hi = mid - 1;
|
|
125
|
+
else if (point >= span.end) lo = mid + 1;
|
|
126
|
+
else return mid;
|
|
127
|
+
}
|
|
128
|
+
return -1;
|
|
129
|
+
}
|
|
130
|
+
/** Whether `point` lies inside the set. */
|
|
131
|
+
has(point) {
|
|
132
|
+
return this.#indexOf(toNumber(point, "point")) !== -1;
|
|
133
|
+
}
|
|
134
|
+
/** The span containing `point`, if any. */
|
|
135
|
+
spanAt(point) {
|
|
136
|
+
const i = this.#indexOf(toNumber(point, "point"));
|
|
137
|
+
return i === -1 ? void 0 : this.#spans[i];
|
|
138
|
+
}
|
|
139
|
+
/** Union of this set and every argument. */
|
|
140
|
+
union(...others) {
|
|
141
|
+
if (!others.length) return this;
|
|
142
|
+
const all = [...this.#spans];
|
|
143
|
+
for (const o of others) all.push(..._SpanSet.from(o).#spans);
|
|
144
|
+
return all.length ? new _SpanSet(normalize(all)) : _SpanSet.empty;
|
|
145
|
+
}
|
|
146
|
+
/** Points present in both sets. O(n + m). */
|
|
147
|
+
intersect(other) {
|
|
148
|
+
const a = this.#spans;
|
|
149
|
+
const b = _SpanSet.from(other).#spans;
|
|
150
|
+
const out = [];
|
|
151
|
+
let i = 0;
|
|
152
|
+
let j = 0;
|
|
153
|
+
while (i < a.length && j < b.length) {
|
|
154
|
+
const x = a[i];
|
|
155
|
+
const y = b[j];
|
|
156
|
+
const start = Math.max(x.start, y.start);
|
|
157
|
+
const end = Math.min(x.end, y.end);
|
|
158
|
+
if (start < end) out.push(Object.freeze({ start, end }));
|
|
159
|
+
if (x.end < y.end) i++;
|
|
160
|
+
else j++;
|
|
161
|
+
}
|
|
162
|
+
return out.length ? new _SpanSet(out) : _SpanSet.empty;
|
|
163
|
+
}
|
|
164
|
+
/** Points in this set that are not in `other`. O(n + m). */
|
|
165
|
+
subtract(other) {
|
|
166
|
+
const b = _SpanSet.from(other).#spans;
|
|
167
|
+
if (!b.length || this.isEmpty) return this;
|
|
168
|
+
const out = [];
|
|
169
|
+
let j = 0;
|
|
170
|
+
for (const x of this.#spans) {
|
|
171
|
+
let start = x.start;
|
|
172
|
+
while (j < b.length && b[j].end <= start) j++;
|
|
173
|
+
let k = j;
|
|
174
|
+
while (k < b.length && b[k].start < x.end) {
|
|
175
|
+
const y = b[k];
|
|
176
|
+
if (y.start > start) out.push(Object.freeze({ start, end: y.start }));
|
|
177
|
+
start = Math.max(start, y.end);
|
|
178
|
+
if (start >= x.end) break;
|
|
179
|
+
k++;
|
|
180
|
+
}
|
|
181
|
+
if (start < x.end) out.push(start === x.start ? x : Object.freeze({ start, end: x.end }));
|
|
182
|
+
}
|
|
183
|
+
return out.length ? new _SpanSet(out) : _SpanSet.empty;
|
|
184
|
+
}
|
|
185
|
+
/** Points in exactly one of the two sets. */
|
|
186
|
+
xor(other) {
|
|
187
|
+
const o = _SpanSet.from(other);
|
|
188
|
+
return this.subtract(o).union(o.subtract(this));
|
|
189
|
+
}
|
|
190
|
+
/** Everything inside `within` (default: the whole line) that is not in this set. */
|
|
191
|
+
complement(within = _SpanSet.all) {
|
|
192
|
+
return _SpanSet.from(within).subtract(this);
|
|
193
|
+
}
|
|
194
|
+
/** The holes between consecutive spans (excludes the unbounded outside). */
|
|
195
|
+
gaps() {
|
|
196
|
+
const s = this.#spans;
|
|
197
|
+
if (s.length < 2) return _SpanSet.empty;
|
|
198
|
+
const out = [];
|
|
199
|
+
for (let i = 1; i < s.length; i++) out.push(Object.freeze({ start: s[i - 1].end, end: s[i].start }));
|
|
200
|
+
return new _SpanSet(out);
|
|
201
|
+
}
|
|
202
|
+
/** Restricts the set to `within`. Alias of `intersect`. */
|
|
203
|
+
clip(within) {
|
|
204
|
+
return this.intersect(within);
|
|
205
|
+
}
|
|
206
|
+
/**
|
|
207
|
+
* Grows every span by `before` on the left and `after` on the right
|
|
208
|
+
* (negative values shrink). Spans that grow into each other are merged;
|
|
209
|
+
* spans that shrink to nothing are dropped.
|
|
210
|
+
*/
|
|
211
|
+
expand(before, after = before) {
|
|
212
|
+
if (Number.isNaN(before) || Number.isNaN(after)) throw new TypeError("spanset: expand amounts must be numbers");
|
|
213
|
+
const out = [];
|
|
214
|
+
for (const s of this.#spans) {
|
|
215
|
+
const start = s.start - before;
|
|
216
|
+
const end = s.end + after;
|
|
217
|
+
if (start < end) out.push(Object.freeze({ start, end }));
|
|
218
|
+
}
|
|
219
|
+
return out.length ? new _SpanSet(normalize(out)) : _SpanSet.empty;
|
|
220
|
+
}
|
|
221
|
+
/** Moves every span by `delta`. */
|
|
222
|
+
shift(delta) {
|
|
223
|
+
if (delta === 0) return this;
|
|
224
|
+
return new _SpanSet(this.#spans.map((s) => Object.freeze({ start: s.start + delta, end: s.end + delta })));
|
|
225
|
+
}
|
|
226
|
+
/** Keeps only spans for which `predicate` returns true. */
|
|
227
|
+
filter(predicate) {
|
|
228
|
+
const out = this.#spans.filter(predicate);
|
|
229
|
+
return out.length === this.#spans.length ? this : out.length ? new _SpanSet(out) : _SpanSet.empty;
|
|
230
|
+
}
|
|
231
|
+
/** Whether the two sets share at least one point. */
|
|
232
|
+
overlaps(other) {
|
|
233
|
+
const a = this.#spans;
|
|
234
|
+
const b = _SpanSet.from(other).#spans;
|
|
235
|
+
let i = 0;
|
|
236
|
+
let j = 0;
|
|
237
|
+
while (i < a.length && j < b.length) {
|
|
238
|
+
const x = a[i];
|
|
239
|
+
const y = b[j];
|
|
240
|
+
if (x.start < y.end && y.start < x.end) return true;
|
|
241
|
+
if (x.end <= y.end) i++;
|
|
242
|
+
else j++;
|
|
243
|
+
}
|
|
244
|
+
return false;
|
|
245
|
+
}
|
|
246
|
+
/** Whether every point of `other` is in this set. */
|
|
247
|
+
covers(other) {
|
|
248
|
+
return _SpanSet.from(other).subtract(this).isEmpty;
|
|
249
|
+
}
|
|
250
|
+
/** Structural equality. */
|
|
251
|
+
equals(other) {
|
|
252
|
+
const a = this.#spans;
|
|
253
|
+
const b = _SpanSet.from(other).#spans;
|
|
254
|
+
if (a.length !== b.length) return false;
|
|
255
|
+
for (let i = 0; i < a.length; i++) {
|
|
256
|
+
if (a[i].start !== b[i].start || a[i].end !== b[i].end) return false;
|
|
257
|
+
}
|
|
258
|
+
return true;
|
|
259
|
+
}
|
|
260
|
+
/**
|
|
261
|
+
* Free spans of at least `minLength` inside `within` — i.e. the complement
|
|
262
|
+
* of this set, filtered by length. Handy for "when is everyone free?".
|
|
263
|
+
*/
|
|
264
|
+
free(within, minLength = 0) {
|
|
265
|
+
const c = this.complement(within);
|
|
266
|
+
return minLength > 0 ? c.filter((s) => s.end - s.start >= minLength) : c;
|
|
267
|
+
}
|
|
268
|
+
/**
|
|
269
|
+
* The earliest span of exactly `length` inside `within` that does not
|
|
270
|
+
* touch this set, or `undefined` if none exists.
|
|
271
|
+
*
|
|
272
|
+
* `options.step` aligns the slot start to multiples of `step`
|
|
273
|
+
* (e.g. `15 * 60_000` for quarter hours), measured from `options.origin` (default 0).
|
|
274
|
+
*/
|
|
275
|
+
findSlot(length, within, options = {}) {
|
|
276
|
+
if (!(length > 0)) throw new RangeError("spanset: slot length must be > 0");
|
|
277
|
+
const { step, origin = 0 } = options;
|
|
278
|
+
if (step !== void 0 && !(step > 0)) throw new RangeError("spanset: step must be > 0");
|
|
279
|
+
for (const gap of this.complement(within).#spans) {
|
|
280
|
+
let start = gap.start;
|
|
281
|
+
if (step !== void 0 && Number.isFinite(start)) {
|
|
282
|
+
start = origin + Math.ceil((start - origin) / step) * step;
|
|
283
|
+
}
|
|
284
|
+
if (start + length <= gap.end && Number.isFinite(start)) {
|
|
285
|
+
return Object.freeze({ start, end: start + length });
|
|
286
|
+
}
|
|
287
|
+
}
|
|
288
|
+
return void 0;
|
|
289
|
+
}
|
|
290
|
+
/** Plain `[start, end]` tuples. */
|
|
291
|
+
toArray() {
|
|
292
|
+
return this.#spans.map((s) => [s.start, s.end]);
|
|
293
|
+
}
|
|
294
|
+
/** Spans as Date objects. */
|
|
295
|
+
toDates() {
|
|
296
|
+
return this.#spans.map((s) => ({ start: new Date(s.start), end: new Date(s.end) }));
|
|
297
|
+
}
|
|
298
|
+
toJSON() {
|
|
299
|
+
return this.toArray();
|
|
300
|
+
}
|
|
301
|
+
toString() {
|
|
302
|
+
return this.isEmpty ? "\u2205" : this.#spans.map((s) => `[${s.start}, ${s.end})`).join(" \u222A ");
|
|
303
|
+
}
|
|
304
|
+
[Symbol.iterator]() {
|
|
305
|
+
return this.#spans[Symbol.iterator]();
|
|
306
|
+
}
|
|
307
|
+
};
|
|
308
|
+
function spans(...inputs) {
|
|
309
|
+
return SpanSet.from(inputs);
|
|
310
|
+
}
|
|
311
|
+
// Annotate the CommonJS export names for ESM import in node:
|
|
312
|
+
0 && (module.exports = {
|
|
313
|
+
SpanSet,
|
|
314
|
+
spans
|
|
315
|
+
});
|
|
316
|
+
//# sourceMappingURL=index.cjs.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * spanset — immutable sets of half-open intervals `[start, end)`.\n *\n * Every SpanSet is kept in canonical form: spans are sorted, non-empty,\n * and never overlap or touch. All operations return new instances.\n */\n\n/** A point on the line. Dates are converted with `getTime()`. */\nexport type Bound = number | Date;\n\n/** Anything that describes a single span. */\nexport type SpanInput = readonly [Bound, Bound] | { readonly start: Bound; readonly end: Bound };\n\n/** Anything that describes a set of spans. */\nexport type SpanSetLike = SpanSet | SpanInput | readonly SpanInput[];\n\n/** A normalized half-open span `[start, end)` with `start < end`. */\nexport interface Span {\n readonly start: number;\n readonly end: number;\n}\n\n/** A span expressed with Date objects. */\nexport interface DateSpan {\n readonly start: Date;\n readonly end: Date;\n}\n\nfunction toNumber(b: Bound, what: string): number {\n const n = b instanceof Date ? b.getTime() : b;\n if (typeof n !== \"number\" || Number.isNaN(n)) {\n throw new TypeError(`spanset: ${what} must be a number or a valid Date, got ${String(b)}`);\n }\n return n;\n}\n\nfunction isBound(v: unknown): v is Bound {\n return typeof v === \"number\" || v instanceof Date;\n}\n\nfunction isSingleSpan(v: unknown): v is SpanInput {\n if (Array.isArray(v)) return v.length === 2 && isBound(v[0]) && isBound(v[1]);\n return typeof v === \"object\" && v !== null && \"start\" in v && \"end\" in v;\n}\n\nfunction parseSpan(input: SpanInput): Span | null {\n const [s, e] = Array.isArray(input)\n ? (input as readonly [Bound, Bound])\n : [(input as { start: Bound }).start, (input as { end: Bound }).end];\n const start = toNumber(s, \"start\");\n const end = toNumber(e, \"end\");\n if (start > end) {\n throw new RangeError(`spanset: start (${start}) must not be greater than end (${end})`);\n }\n return start === end ? null : Object.freeze({ start, end });\n}\n\n/** Sorts and merges overlapping/adjacent spans. Takes ownership of `spans`. */\nfunction normalize(spans: Span[]): Span[] {\n if (spans.length < 2) return spans;\n spans.sort((a, b) => a.start - b.start || a.end - b.end);\n const out: Span[] = [spans[0]!];\n for (let i = 1; i < spans.length; i++) {\n const cur = spans[i]!;\n const last = out[out.length - 1]!;\n if (cur.start <= last.end) {\n if (cur.end > last.end) out[out.length - 1] = Object.freeze({ start: last.start, end: cur.end });\n } else {\n out.push(cur);\n }\n }\n return out;\n}\n\nconst EMPTY_SPANS: readonly Span[] = Object.freeze([]);\n\nexport class SpanSet implements Iterable<Span> {\n readonly #spans: readonly Span[];\n\n private constructor(normalized: readonly Span[]) {\n this.#spans = Object.freeze(normalized);\n }\n\n /** The empty set. */\n static readonly empty: SpanSet = new SpanSet(EMPTY_SPANS);\n\n /** The set covering the whole number line. */\n static readonly all: SpanSet = new SpanSet([Object.freeze({ start: -Infinity, end: Infinity })]);\n\n /** Builds a set from any number of spans; overlapping spans are merged. */\n static of(...inputs: SpanInput[]): SpanSet {\n return SpanSet.from(inputs);\n }\n\n /** Builds a set from a SpanSet, a single span, or a list/iterable of spans. */\n static from(input: SpanSetLike | Iterable<SpanInput>): SpanSet {\n if (input instanceof SpanSet) return input;\n if (isSingleSpan(input)) {\n const s = parseSpan(input);\n return s ? new SpanSet([s]) : SpanSet.empty;\n }\n const spans: Span[] = [];\n for (const item of input as Iterable<SpanInput>) {\n const s = parseSpan(item);\n if (s) spans.push(s);\n }\n return spans.length ? new SpanSet(normalize(spans)) : SpanSet.empty;\n }\n\n /** The canonical spans, sorted and disjoint. */\n get spans(): readonly Span[] {\n return this.#spans;\n }\n\n /** Number of disjoint spans. */\n get count(): number {\n return this.#spans.length;\n }\n\n get isEmpty(): boolean {\n return this.#spans.length === 0;\n }\n\n /** Total length covered by the set (may be `Infinity`). */\n get measure(): number {\n let total = 0;\n for (const s of this.#spans) total += s.end - s.start;\n return total;\n }\n\n /** The smallest single span containing the whole set, or `undefined` if empty. */\n get bounds(): Span | undefined {\n const s = this.#spans;\n if (!s.length) return undefined;\n return Object.freeze({ start: s[0]!.start, end: s[s.length - 1]!.end });\n }\n\n /** Index of the span containing `point`, or -1. Binary search, O(log n). */\n #indexOf(point: number): number {\n const s = this.#spans;\n let lo = 0;\n let hi = s.length - 1;\n while (lo <= hi) {\n const mid = (lo + hi) >>> 1;\n const span = s[mid]!;\n if (point < span.start) hi = mid - 1;\n else if (point >= span.end) lo = mid + 1;\n else return mid;\n }\n return -1;\n }\n\n /** Whether `point` lies inside the set. */\n has(point: Bound): boolean {\n return this.#indexOf(toNumber(point, \"point\")) !== -1;\n }\n\n /** The span containing `point`, if any. */\n spanAt(point: Bound): Span | undefined {\n const i = this.#indexOf(toNumber(point, \"point\"));\n return i === -1 ? undefined : this.#spans[i];\n }\n\n /** Union of this set and every argument. */\n union(...others: SpanSetLike[]): SpanSet {\n if (!others.length) return this;\n const all: Span[] = [...this.#spans];\n for (const o of others) all.push(...SpanSet.from(o).#spans);\n return all.length ? new SpanSet(normalize(all)) : SpanSet.empty;\n }\n\n /** Points present in both sets. O(n + m). */\n intersect(other: SpanSetLike): SpanSet {\n const a = this.#spans;\n const b = SpanSet.from(other).#spans;\n const out: Span[] = [];\n let i = 0;\n let j = 0;\n while (i < a.length && j < b.length) {\n const x = a[i]!;\n const y = b[j]!;\n const start = Math.max(x.start, y.start);\n const end = Math.min(x.end, y.end);\n if (start < end) out.push(Object.freeze({ start, end }));\n if (x.end < y.end) i++;\n else j++;\n }\n return out.length ? new SpanSet(out) : SpanSet.empty;\n }\n\n /** Points in this set that are not in `other`. O(n + m). */\n subtract(other: SpanSetLike): SpanSet {\n const b = SpanSet.from(other).#spans;\n if (!b.length || this.isEmpty) return this;\n const out: Span[] = [];\n let j = 0;\n for (const x of this.#spans) {\n let start = x.start;\n while (j < b.length && b[j]!.end <= start) j++;\n let k = j;\n while (k < b.length && b[k]!.start < x.end) {\n const y = b[k]!;\n if (y.start > start) out.push(Object.freeze({ start, end: y.start }));\n start = Math.max(start, y.end);\n if (start >= x.end) break;\n k++;\n }\n if (start < x.end) out.push(start === x.start ? x : Object.freeze({ start, end: x.end }));\n }\n return out.length ? new SpanSet(out) : SpanSet.empty;\n }\n\n /** Points in exactly one of the two sets. */\n xor(other: SpanSetLike): SpanSet {\n const o = SpanSet.from(other);\n return this.subtract(o).union(o.subtract(this));\n }\n\n /** Everything inside `within` (default: the whole line) that is not in this set. */\n complement(within: SpanSetLike = SpanSet.all): SpanSet {\n return SpanSet.from(within).subtract(this);\n }\n\n /** The holes between consecutive spans (excludes the unbounded outside). */\n gaps(): SpanSet {\n const s = this.#spans;\n if (s.length < 2) return SpanSet.empty;\n const out: Span[] = [];\n for (let i = 1; i < s.length; i++) out.push(Object.freeze({ start: s[i - 1]!.end, end: s[i]!.start }));\n return new SpanSet(out);\n }\n\n /** Restricts the set to `within`. Alias of `intersect`. */\n clip(within: SpanSetLike): SpanSet {\n return this.intersect(within);\n }\n\n /**\n * Grows every span by `before` on the left and `after` on the right\n * (negative values shrink). Spans that grow into each other are merged;\n * spans that shrink to nothing are dropped.\n */\n expand(before: number, after: number = before): SpanSet {\n if (Number.isNaN(before) || Number.isNaN(after)) throw new TypeError(\"spanset: expand amounts must be numbers\");\n const out: Span[] = [];\n for (const s of this.#spans) {\n const start = s.start - before;\n const end = s.end + after;\n if (start < end) out.push(Object.freeze({ start, end }));\n }\n return out.length ? new SpanSet(normalize(out)) : SpanSet.empty;\n }\n\n /** Moves every span by `delta`. */\n shift(delta: number): SpanSet {\n if (delta === 0) return this;\n return new SpanSet(this.#spans.map((s) => Object.freeze({ start: s.start + delta, end: s.end + delta })));\n }\n\n /** Keeps only spans for which `predicate` returns true. */\n filter(predicate: (span: Span, index: number) => boolean): SpanSet {\n const out = this.#spans.filter(predicate);\n return out.length === this.#spans.length ? this : out.length ? new SpanSet(out) : SpanSet.empty;\n }\n\n /** Whether the two sets share at least one point. */\n overlaps(other: SpanSetLike): boolean {\n const a = this.#spans;\n const b = SpanSet.from(other).#spans;\n let i = 0;\n let j = 0;\n while (i < a.length && j < b.length) {\n const x = a[i]!;\n const y = b[j]!;\n if (x.start < y.end && y.start < x.end) return true;\n if (x.end <= y.end) i++;\n else j++;\n }\n return false;\n }\n\n /** Whether every point of `other` is in this set. */\n covers(other: SpanSetLike): boolean {\n return SpanSet.from(other).subtract(this).isEmpty;\n }\n\n /** Structural equality. */\n equals(other: SpanSetLike): boolean {\n const a = this.#spans;\n const b = SpanSet.from(other).#spans;\n if (a.length !== b.length) return false;\n for (let i = 0; i < a.length; i++) {\n if (a[i]!.start !== b[i]!.start || a[i]!.end !== b[i]!.end) return false;\n }\n return true;\n }\n\n /**\n * Free spans of at least `minLength` inside `within` — i.e. the complement\n * of this set, filtered by length. Handy for \"when is everyone free?\".\n */\n free(within: SpanSetLike, minLength = 0): SpanSet {\n const c = this.complement(within);\n return minLength > 0 ? c.filter((s) => s.end - s.start >= minLength) : c;\n }\n\n /**\n * The earliest span of exactly `length` inside `within` that does not\n * touch this set, or `undefined` if none exists.\n *\n * `options.step` aligns the slot start to multiples of `step`\n * (e.g. `15 * 60_000` for quarter hours), measured from `options.origin` (default 0).\n */\n findSlot(\n length: number,\n within: SpanSetLike,\n options: { step?: number; origin?: number } = {},\n ): Span | undefined {\n if (!(length > 0)) throw new RangeError(\"spanset: slot length must be > 0\");\n const { step, origin = 0 } = options;\n if (step !== undefined && !(step > 0)) throw new RangeError(\"spanset: step must be > 0\");\n for (const gap of this.complement(within).#spans) {\n let start = gap.start;\n if (step !== undefined && Number.isFinite(start)) {\n start = origin + Math.ceil((start - origin) / step) * step;\n }\n if (start + length <= gap.end && Number.isFinite(start)) {\n return Object.freeze({ start, end: start + length });\n }\n }\n return undefined;\n }\n\n /** Plain `[start, end]` tuples. */\n toArray(): [number, number][] {\n return this.#spans.map((s) => [s.start, s.end]);\n }\n\n /** Spans as Date objects. */\n toDates(): DateSpan[] {\n return this.#spans.map((s) => ({ start: new Date(s.start), end: new Date(s.end) }));\n }\n\n toJSON(): [number, number][] {\n return this.toArray();\n }\n\n toString(): string {\n return this.isEmpty ? \"∅\" : this.#spans.map((s) => `[${s.start}, ${s.end})`).join(\" ∪ \");\n }\n\n [Symbol.iterator](): Iterator<Span> {\n return this.#spans[Symbol.iterator]();\n }\n}\n\n/** Shorthand for `SpanSet.of(...)`. */\nexport function spans(...inputs: SpanInput[]): SpanSet {\n return SpanSet.from(inputs);\n}\n"],"mappings":"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","names":["spans"]}
|
package/dist/index.d.cts
ADDED
|
@@ -0,0 +1,105 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* spanset — immutable sets of half-open intervals `[start, end)`.
|
|
3
|
+
*
|
|
4
|
+
* Every SpanSet is kept in canonical form: spans are sorted, non-empty,
|
|
5
|
+
* and never overlap or touch. All operations return new instances.
|
|
6
|
+
*/
|
|
7
|
+
/** A point on the line. Dates are converted with `getTime()`. */
|
|
8
|
+
export type Bound = number | Date;
|
|
9
|
+
/** Anything that describes a single span. */
|
|
10
|
+
export type SpanInput = readonly [Bound, Bound] | {
|
|
11
|
+
readonly start: Bound;
|
|
12
|
+
readonly end: Bound;
|
|
13
|
+
};
|
|
14
|
+
/** Anything that describes a set of spans. */
|
|
15
|
+
export type SpanSetLike = SpanSet | SpanInput | readonly SpanInput[];
|
|
16
|
+
/** A normalized half-open span `[start, end)` with `start < end`. */
|
|
17
|
+
export interface Span {
|
|
18
|
+
readonly start: number;
|
|
19
|
+
readonly end: number;
|
|
20
|
+
}
|
|
21
|
+
/** A span expressed with Date objects. */
|
|
22
|
+
export interface DateSpan {
|
|
23
|
+
readonly start: Date;
|
|
24
|
+
readonly end: Date;
|
|
25
|
+
}
|
|
26
|
+
export declare class SpanSet implements Iterable<Span> {
|
|
27
|
+
#private;
|
|
28
|
+
private constructor();
|
|
29
|
+
/** The empty set. */
|
|
30
|
+
static readonly empty: SpanSet;
|
|
31
|
+
/** The set covering the whole number line. */
|
|
32
|
+
static readonly all: SpanSet;
|
|
33
|
+
/** Builds a set from any number of spans; overlapping spans are merged. */
|
|
34
|
+
static of(...inputs: SpanInput[]): SpanSet;
|
|
35
|
+
/** Builds a set from a SpanSet, a single span, or a list/iterable of spans. */
|
|
36
|
+
static from(input: SpanSetLike | Iterable<SpanInput>): SpanSet;
|
|
37
|
+
/** The canonical spans, sorted and disjoint. */
|
|
38
|
+
get spans(): readonly Span[];
|
|
39
|
+
/** Number of disjoint spans. */
|
|
40
|
+
get count(): number;
|
|
41
|
+
get isEmpty(): boolean;
|
|
42
|
+
/** Total length covered by the set (may be `Infinity`). */
|
|
43
|
+
get measure(): number;
|
|
44
|
+
/** The smallest single span containing the whole set, or `undefined` if empty. */
|
|
45
|
+
get bounds(): Span | undefined;
|
|
46
|
+
/** Whether `point` lies inside the set. */
|
|
47
|
+
has(point: Bound): boolean;
|
|
48
|
+
/** The span containing `point`, if any. */
|
|
49
|
+
spanAt(point: Bound): Span | undefined;
|
|
50
|
+
/** Union of this set and every argument. */
|
|
51
|
+
union(...others: SpanSetLike[]): SpanSet;
|
|
52
|
+
/** Points present in both sets. O(n + m). */
|
|
53
|
+
intersect(other: SpanSetLike): SpanSet;
|
|
54
|
+
/** Points in this set that are not in `other`. O(n + m). */
|
|
55
|
+
subtract(other: SpanSetLike): SpanSet;
|
|
56
|
+
/** Points in exactly one of the two sets. */
|
|
57
|
+
xor(other: SpanSetLike): SpanSet;
|
|
58
|
+
/** Everything inside `within` (default: the whole line) that is not in this set. */
|
|
59
|
+
complement(within?: SpanSetLike): SpanSet;
|
|
60
|
+
/** The holes between consecutive spans (excludes the unbounded outside). */
|
|
61
|
+
gaps(): SpanSet;
|
|
62
|
+
/** Restricts the set to `within`. Alias of `intersect`. */
|
|
63
|
+
clip(within: SpanSetLike): SpanSet;
|
|
64
|
+
/**
|
|
65
|
+
* Grows every span by `before` on the left and `after` on the right
|
|
66
|
+
* (negative values shrink). Spans that grow into each other are merged;
|
|
67
|
+
* spans that shrink to nothing are dropped.
|
|
68
|
+
*/
|
|
69
|
+
expand(before: number, after?: number): SpanSet;
|
|
70
|
+
/** Moves every span by `delta`. */
|
|
71
|
+
shift(delta: number): SpanSet;
|
|
72
|
+
/** Keeps only spans for which `predicate` returns true. */
|
|
73
|
+
filter(predicate: (span: Span, index: number) => boolean): SpanSet;
|
|
74
|
+
/** Whether the two sets share at least one point. */
|
|
75
|
+
overlaps(other: SpanSetLike): boolean;
|
|
76
|
+
/** Whether every point of `other` is in this set. */
|
|
77
|
+
covers(other: SpanSetLike): boolean;
|
|
78
|
+
/** Structural equality. */
|
|
79
|
+
equals(other: SpanSetLike): boolean;
|
|
80
|
+
/**
|
|
81
|
+
* Free spans of at least `minLength` inside `within` — i.e. the complement
|
|
82
|
+
* of this set, filtered by length. Handy for "when is everyone free?".
|
|
83
|
+
*/
|
|
84
|
+
free(within: SpanSetLike, minLength?: number): SpanSet;
|
|
85
|
+
/**
|
|
86
|
+
* The earliest span of exactly `length` inside `within` that does not
|
|
87
|
+
* touch this set, or `undefined` if none exists.
|
|
88
|
+
*
|
|
89
|
+
* `options.step` aligns the slot start to multiples of `step`
|
|
90
|
+
* (e.g. `15 * 60_000` for quarter hours), measured from `options.origin` (default 0).
|
|
91
|
+
*/
|
|
92
|
+
findSlot(length: number, within: SpanSetLike, options?: {
|
|
93
|
+
step?: number;
|
|
94
|
+
origin?: number;
|
|
95
|
+
}): Span | undefined;
|
|
96
|
+
/** Plain `[start, end]` tuples. */
|
|
97
|
+
toArray(): [number, number][];
|
|
98
|
+
/** Spans as Date objects. */
|
|
99
|
+
toDates(): DateSpan[];
|
|
100
|
+
toJSON(): [number, number][];
|
|
101
|
+
toString(): string;
|
|
102
|
+
[Symbol.iterator](): Iterator<Span>;
|
|
103
|
+
}
|
|
104
|
+
/** Shorthand for `SpanSet.of(...)`. */
|
|
105
|
+
export declare function spans(...inputs: SpanInput[]): SpanSet;
|
package/dist/index.d.ts
ADDED
|
@@ -0,0 +1,105 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* spanset — immutable sets of half-open intervals `[start, end)`.
|
|
3
|
+
*
|
|
4
|
+
* Every SpanSet is kept in canonical form: spans are sorted, non-empty,
|
|
5
|
+
* and never overlap or touch. All operations return new instances.
|
|
6
|
+
*/
|
|
7
|
+
/** A point on the line. Dates are converted with `getTime()`. */
|
|
8
|
+
export type Bound = number | Date;
|
|
9
|
+
/** Anything that describes a single span. */
|
|
10
|
+
export type SpanInput = readonly [Bound, Bound] | {
|
|
11
|
+
readonly start: Bound;
|
|
12
|
+
readonly end: Bound;
|
|
13
|
+
};
|
|
14
|
+
/** Anything that describes a set of spans. */
|
|
15
|
+
export type SpanSetLike = SpanSet | SpanInput | readonly SpanInput[];
|
|
16
|
+
/** A normalized half-open span `[start, end)` with `start < end`. */
|
|
17
|
+
export interface Span {
|
|
18
|
+
readonly start: number;
|
|
19
|
+
readonly end: number;
|
|
20
|
+
}
|
|
21
|
+
/** A span expressed with Date objects. */
|
|
22
|
+
export interface DateSpan {
|
|
23
|
+
readonly start: Date;
|
|
24
|
+
readonly end: Date;
|
|
25
|
+
}
|
|
26
|
+
export declare class SpanSet implements Iterable<Span> {
|
|
27
|
+
#private;
|
|
28
|
+
private constructor();
|
|
29
|
+
/** The empty set. */
|
|
30
|
+
static readonly empty: SpanSet;
|
|
31
|
+
/** The set covering the whole number line. */
|
|
32
|
+
static readonly all: SpanSet;
|
|
33
|
+
/** Builds a set from any number of spans; overlapping spans are merged. */
|
|
34
|
+
static of(...inputs: SpanInput[]): SpanSet;
|
|
35
|
+
/** Builds a set from a SpanSet, a single span, or a list/iterable of spans. */
|
|
36
|
+
static from(input: SpanSetLike | Iterable<SpanInput>): SpanSet;
|
|
37
|
+
/** The canonical spans, sorted and disjoint. */
|
|
38
|
+
get spans(): readonly Span[];
|
|
39
|
+
/** Number of disjoint spans. */
|
|
40
|
+
get count(): number;
|
|
41
|
+
get isEmpty(): boolean;
|
|
42
|
+
/** Total length covered by the set (may be `Infinity`). */
|
|
43
|
+
get measure(): number;
|
|
44
|
+
/** The smallest single span containing the whole set, or `undefined` if empty. */
|
|
45
|
+
get bounds(): Span | undefined;
|
|
46
|
+
/** Whether `point` lies inside the set. */
|
|
47
|
+
has(point: Bound): boolean;
|
|
48
|
+
/** The span containing `point`, if any. */
|
|
49
|
+
spanAt(point: Bound): Span | undefined;
|
|
50
|
+
/** Union of this set and every argument. */
|
|
51
|
+
union(...others: SpanSetLike[]): SpanSet;
|
|
52
|
+
/** Points present in both sets. O(n + m). */
|
|
53
|
+
intersect(other: SpanSetLike): SpanSet;
|
|
54
|
+
/** Points in this set that are not in `other`. O(n + m). */
|
|
55
|
+
subtract(other: SpanSetLike): SpanSet;
|
|
56
|
+
/** Points in exactly one of the two sets. */
|
|
57
|
+
xor(other: SpanSetLike): SpanSet;
|
|
58
|
+
/** Everything inside `within` (default: the whole line) that is not in this set. */
|
|
59
|
+
complement(within?: SpanSetLike): SpanSet;
|
|
60
|
+
/** The holes between consecutive spans (excludes the unbounded outside). */
|
|
61
|
+
gaps(): SpanSet;
|
|
62
|
+
/** Restricts the set to `within`. Alias of `intersect`. */
|
|
63
|
+
clip(within: SpanSetLike): SpanSet;
|
|
64
|
+
/**
|
|
65
|
+
* Grows every span by `before` on the left and `after` on the right
|
|
66
|
+
* (negative values shrink). Spans that grow into each other are merged;
|
|
67
|
+
* spans that shrink to nothing are dropped.
|
|
68
|
+
*/
|
|
69
|
+
expand(before: number, after?: number): SpanSet;
|
|
70
|
+
/** Moves every span by `delta`. */
|
|
71
|
+
shift(delta: number): SpanSet;
|
|
72
|
+
/** Keeps only spans for which `predicate` returns true. */
|
|
73
|
+
filter(predicate: (span: Span, index: number) => boolean): SpanSet;
|
|
74
|
+
/** Whether the two sets share at least one point. */
|
|
75
|
+
overlaps(other: SpanSetLike): boolean;
|
|
76
|
+
/** Whether every point of `other` is in this set. */
|
|
77
|
+
covers(other: SpanSetLike): boolean;
|
|
78
|
+
/** Structural equality. */
|
|
79
|
+
equals(other: SpanSetLike): boolean;
|
|
80
|
+
/**
|
|
81
|
+
* Free spans of at least `minLength` inside `within` — i.e. the complement
|
|
82
|
+
* of this set, filtered by length. Handy for "when is everyone free?".
|
|
83
|
+
*/
|
|
84
|
+
free(within: SpanSetLike, minLength?: number): SpanSet;
|
|
85
|
+
/**
|
|
86
|
+
* The earliest span of exactly `length` inside `within` that does not
|
|
87
|
+
* touch this set, or `undefined` if none exists.
|
|
88
|
+
*
|
|
89
|
+
* `options.step` aligns the slot start to multiples of `step`
|
|
90
|
+
* (e.g. `15 * 60_000` for quarter hours), measured from `options.origin` (default 0).
|
|
91
|
+
*/
|
|
92
|
+
findSlot(length: number, within: SpanSetLike, options?: {
|
|
93
|
+
step?: number;
|
|
94
|
+
origin?: number;
|
|
95
|
+
}): Span | undefined;
|
|
96
|
+
/** Plain `[start, end]` tuples. */
|
|
97
|
+
toArray(): [number, number][];
|
|
98
|
+
/** Spans as Date objects. */
|
|
99
|
+
toDates(): DateSpan[];
|
|
100
|
+
toJSON(): [number, number][];
|
|
101
|
+
toString(): string;
|
|
102
|
+
[Symbol.iterator](): Iterator<Span>;
|
|
103
|
+
}
|
|
104
|
+
/** Shorthand for `SpanSet.of(...)`. */
|
|
105
|
+
export declare function spans(...inputs: SpanInput[]): SpanSet;
|
package/dist/index.js
ADDED
|
@@ -0,0 +1,290 @@
|
|
|
1
|
+
// src/index.ts
|
|
2
|
+
function toNumber(b, what) {
|
|
3
|
+
const n = b instanceof Date ? b.getTime() : b;
|
|
4
|
+
if (typeof n !== "number" || Number.isNaN(n)) {
|
|
5
|
+
throw new TypeError(`spanset: ${what} must be a number or a valid Date, got ${String(b)}`);
|
|
6
|
+
}
|
|
7
|
+
return n;
|
|
8
|
+
}
|
|
9
|
+
function isBound(v) {
|
|
10
|
+
return typeof v === "number" || v instanceof Date;
|
|
11
|
+
}
|
|
12
|
+
function isSingleSpan(v) {
|
|
13
|
+
if (Array.isArray(v)) return v.length === 2 && isBound(v[0]) && isBound(v[1]);
|
|
14
|
+
return typeof v === "object" && v !== null && "start" in v && "end" in v;
|
|
15
|
+
}
|
|
16
|
+
function parseSpan(input) {
|
|
17
|
+
const [s, e] = Array.isArray(input) ? input : [input.start, input.end];
|
|
18
|
+
const start = toNumber(s, "start");
|
|
19
|
+
const end = toNumber(e, "end");
|
|
20
|
+
if (start > end) {
|
|
21
|
+
throw new RangeError(`spanset: start (${start}) must not be greater than end (${end})`);
|
|
22
|
+
}
|
|
23
|
+
return start === end ? null : Object.freeze({ start, end });
|
|
24
|
+
}
|
|
25
|
+
function normalize(spans2) {
|
|
26
|
+
if (spans2.length < 2) return spans2;
|
|
27
|
+
spans2.sort((a, b) => a.start - b.start || a.end - b.end);
|
|
28
|
+
const out = [spans2[0]];
|
|
29
|
+
for (let i = 1; i < spans2.length; i++) {
|
|
30
|
+
const cur = spans2[i];
|
|
31
|
+
const last = out[out.length - 1];
|
|
32
|
+
if (cur.start <= last.end) {
|
|
33
|
+
if (cur.end > last.end) out[out.length - 1] = Object.freeze({ start: last.start, end: cur.end });
|
|
34
|
+
} else {
|
|
35
|
+
out.push(cur);
|
|
36
|
+
}
|
|
37
|
+
}
|
|
38
|
+
return out;
|
|
39
|
+
}
|
|
40
|
+
var EMPTY_SPANS = Object.freeze([]);
|
|
41
|
+
var SpanSet = class _SpanSet {
|
|
42
|
+
#spans;
|
|
43
|
+
constructor(normalized) {
|
|
44
|
+
this.#spans = Object.freeze(normalized);
|
|
45
|
+
}
|
|
46
|
+
/** The empty set. */
|
|
47
|
+
static empty = new _SpanSet(EMPTY_SPANS);
|
|
48
|
+
/** The set covering the whole number line. */
|
|
49
|
+
static all = new _SpanSet([Object.freeze({ start: -Infinity, end: Infinity })]);
|
|
50
|
+
/** Builds a set from any number of spans; overlapping spans are merged. */
|
|
51
|
+
static of(...inputs) {
|
|
52
|
+
return _SpanSet.from(inputs);
|
|
53
|
+
}
|
|
54
|
+
/** Builds a set from a SpanSet, a single span, or a list/iterable of spans. */
|
|
55
|
+
static from(input) {
|
|
56
|
+
if (input instanceof _SpanSet) return input;
|
|
57
|
+
if (isSingleSpan(input)) {
|
|
58
|
+
const s = parseSpan(input);
|
|
59
|
+
return s ? new _SpanSet([s]) : _SpanSet.empty;
|
|
60
|
+
}
|
|
61
|
+
const spans2 = [];
|
|
62
|
+
for (const item of input) {
|
|
63
|
+
const s = parseSpan(item);
|
|
64
|
+
if (s) spans2.push(s);
|
|
65
|
+
}
|
|
66
|
+
return spans2.length ? new _SpanSet(normalize(spans2)) : _SpanSet.empty;
|
|
67
|
+
}
|
|
68
|
+
/** The canonical spans, sorted and disjoint. */
|
|
69
|
+
get spans() {
|
|
70
|
+
return this.#spans;
|
|
71
|
+
}
|
|
72
|
+
/** Number of disjoint spans. */
|
|
73
|
+
get count() {
|
|
74
|
+
return this.#spans.length;
|
|
75
|
+
}
|
|
76
|
+
get isEmpty() {
|
|
77
|
+
return this.#spans.length === 0;
|
|
78
|
+
}
|
|
79
|
+
/** Total length covered by the set (may be `Infinity`). */
|
|
80
|
+
get measure() {
|
|
81
|
+
let total = 0;
|
|
82
|
+
for (const s of this.#spans) total += s.end - s.start;
|
|
83
|
+
return total;
|
|
84
|
+
}
|
|
85
|
+
/** The smallest single span containing the whole set, or `undefined` if empty. */
|
|
86
|
+
get bounds() {
|
|
87
|
+
const s = this.#spans;
|
|
88
|
+
if (!s.length) return void 0;
|
|
89
|
+
return Object.freeze({ start: s[0].start, end: s[s.length - 1].end });
|
|
90
|
+
}
|
|
91
|
+
/** Index of the span containing `point`, or -1. Binary search, O(log n). */
|
|
92
|
+
#indexOf(point) {
|
|
93
|
+
const s = this.#spans;
|
|
94
|
+
let lo = 0;
|
|
95
|
+
let hi = s.length - 1;
|
|
96
|
+
while (lo <= hi) {
|
|
97
|
+
const mid = lo + hi >>> 1;
|
|
98
|
+
const span = s[mid];
|
|
99
|
+
if (point < span.start) hi = mid - 1;
|
|
100
|
+
else if (point >= span.end) lo = mid + 1;
|
|
101
|
+
else return mid;
|
|
102
|
+
}
|
|
103
|
+
return -1;
|
|
104
|
+
}
|
|
105
|
+
/** Whether `point` lies inside the set. */
|
|
106
|
+
has(point) {
|
|
107
|
+
return this.#indexOf(toNumber(point, "point")) !== -1;
|
|
108
|
+
}
|
|
109
|
+
/** The span containing `point`, if any. */
|
|
110
|
+
spanAt(point) {
|
|
111
|
+
const i = this.#indexOf(toNumber(point, "point"));
|
|
112
|
+
return i === -1 ? void 0 : this.#spans[i];
|
|
113
|
+
}
|
|
114
|
+
/** Union of this set and every argument. */
|
|
115
|
+
union(...others) {
|
|
116
|
+
if (!others.length) return this;
|
|
117
|
+
const all = [...this.#spans];
|
|
118
|
+
for (const o of others) all.push(..._SpanSet.from(o).#spans);
|
|
119
|
+
return all.length ? new _SpanSet(normalize(all)) : _SpanSet.empty;
|
|
120
|
+
}
|
|
121
|
+
/** Points present in both sets. O(n + m). */
|
|
122
|
+
intersect(other) {
|
|
123
|
+
const a = this.#spans;
|
|
124
|
+
const b = _SpanSet.from(other).#spans;
|
|
125
|
+
const out = [];
|
|
126
|
+
let i = 0;
|
|
127
|
+
let j = 0;
|
|
128
|
+
while (i < a.length && j < b.length) {
|
|
129
|
+
const x = a[i];
|
|
130
|
+
const y = b[j];
|
|
131
|
+
const start = Math.max(x.start, y.start);
|
|
132
|
+
const end = Math.min(x.end, y.end);
|
|
133
|
+
if (start < end) out.push(Object.freeze({ start, end }));
|
|
134
|
+
if (x.end < y.end) i++;
|
|
135
|
+
else j++;
|
|
136
|
+
}
|
|
137
|
+
return out.length ? new _SpanSet(out) : _SpanSet.empty;
|
|
138
|
+
}
|
|
139
|
+
/** Points in this set that are not in `other`. O(n + m). */
|
|
140
|
+
subtract(other) {
|
|
141
|
+
const b = _SpanSet.from(other).#spans;
|
|
142
|
+
if (!b.length || this.isEmpty) return this;
|
|
143
|
+
const out = [];
|
|
144
|
+
let j = 0;
|
|
145
|
+
for (const x of this.#spans) {
|
|
146
|
+
let start = x.start;
|
|
147
|
+
while (j < b.length && b[j].end <= start) j++;
|
|
148
|
+
let k = j;
|
|
149
|
+
while (k < b.length && b[k].start < x.end) {
|
|
150
|
+
const y = b[k];
|
|
151
|
+
if (y.start > start) out.push(Object.freeze({ start, end: y.start }));
|
|
152
|
+
start = Math.max(start, y.end);
|
|
153
|
+
if (start >= x.end) break;
|
|
154
|
+
k++;
|
|
155
|
+
}
|
|
156
|
+
if (start < x.end) out.push(start === x.start ? x : Object.freeze({ start, end: x.end }));
|
|
157
|
+
}
|
|
158
|
+
return out.length ? new _SpanSet(out) : _SpanSet.empty;
|
|
159
|
+
}
|
|
160
|
+
/** Points in exactly one of the two sets. */
|
|
161
|
+
xor(other) {
|
|
162
|
+
const o = _SpanSet.from(other);
|
|
163
|
+
return this.subtract(o).union(o.subtract(this));
|
|
164
|
+
}
|
|
165
|
+
/** Everything inside `within` (default: the whole line) that is not in this set. */
|
|
166
|
+
complement(within = _SpanSet.all) {
|
|
167
|
+
return _SpanSet.from(within).subtract(this);
|
|
168
|
+
}
|
|
169
|
+
/** The holes between consecutive spans (excludes the unbounded outside). */
|
|
170
|
+
gaps() {
|
|
171
|
+
const s = this.#spans;
|
|
172
|
+
if (s.length < 2) return _SpanSet.empty;
|
|
173
|
+
const out = [];
|
|
174
|
+
for (let i = 1; i < s.length; i++) out.push(Object.freeze({ start: s[i - 1].end, end: s[i].start }));
|
|
175
|
+
return new _SpanSet(out);
|
|
176
|
+
}
|
|
177
|
+
/** Restricts the set to `within`. Alias of `intersect`. */
|
|
178
|
+
clip(within) {
|
|
179
|
+
return this.intersect(within);
|
|
180
|
+
}
|
|
181
|
+
/**
|
|
182
|
+
* Grows every span by `before` on the left and `after` on the right
|
|
183
|
+
* (negative values shrink). Spans that grow into each other are merged;
|
|
184
|
+
* spans that shrink to nothing are dropped.
|
|
185
|
+
*/
|
|
186
|
+
expand(before, after = before) {
|
|
187
|
+
if (Number.isNaN(before) || Number.isNaN(after)) throw new TypeError("spanset: expand amounts must be numbers");
|
|
188
|
+
const out = [];
|
|
189
|
+
for (const s of this.#spans) {
|
|
190
|
+
const start = s.start - before;
|
|
191
|
+
const end = s.end + after;
|
|
192
|
+
if (start < end) out.push(Object.freeze({ start, end }));
|
|
193
|
+
}
|
|
194
|
+
return out.length ? new _SpanSet(normalize(out)) : _SpanSet.empty;
|
|
195
|
+
}
|
|
196
|
+
/** Moves every span by `delta`. */
|
|
197
|
+
shift(delta) {
|
|
198
|
+
if (delta === 0) return this;
|
|
199
|
+
return new _SpanSet(this.#spans.map((s) => Object.freeze({ start: s.start + delta, end: s.end + delta })));
|
|
200
|
+
}
|
|
201
|
+
/** Keeps only spans for which `predicate` returns true. */
|
|
202
|
+
filter(predicate) {
|
|
203
|
+
const out = this.#spans.filter(predicate);
|
|
204
|
+
return out.length === this.#spans.length ? this : out.length ? new _SpanSet(out) : _SpanSet.empty;
|
|
205
|
+
}
|
|
206
|
+
/** Whether the two sets share at least one point. */
|
|
207
|
+
overlaps(other) {
|
|
208
|
+
const a = this.#spans;
|
|
209
|
+
const b = _SpanSet.from(other).#spans;
|
|
210
|
+
let i = 0;
|
|
211
|
+
let j = 0;
|
|
212
|
+
while (i < a.length && j < b.length) {
|
|
213
|
+
const x = a[i];
|
|
214
|
+
const y = b[j];
|
|
215
|
+
if (x.start < y.end && y.start < x.end) return true;
|
|
216
|
+
if (x.end <= y.end) i++;
|
|
217
|
+
else j++;
|
|
218
|
+
}
|
|
219
|
+
return false;
|
|
220
|
+
}
|
|
221
|
+
/** Whether every point of `other` is in this set. */
|
|
222
|
+
covers(other) {
|
|
223
|
+
return _SpanSet.from(other).subtract(this).isEmpty;
|
|
224
|
+
}
|
|
225
|
+
/** Structural equality. */
|
|
226
|
+
equals(other) {
|
|
227
|
+
const a = this.#spans;
|
|
228
|
+
const b = _SpanSet.from(other).#spans;
|
|
229
|
+
if (a.length !== b.length) return false;
|
|
230
|
+
for (let i = 0; i < a.length; i++) {
|
|
231
|
+
if (a[i].start !== b[i].start || a[i].end !== b[i].end) return false;
|
|
232
|
+
}
|
|
233
|
+
return true;
|
|
234
|
+
}
|
|
235
|
+
/**
|
|
236
|
+
* Free spans of at least `minLength` inside `within` — i.e. the complement
|
|
237
|
+
* of this set, filtered by length. Handy for "when is everyone free?".
|
|
238
|
+
*/
|
|
239
|
+
free(within, minLength = 0) {
|
|
240
|
+
const c = this.complement(within);
|
|
241
|
+
return minLength > 0 ? c.filter((s) => s.end - s.start >= minLength) : c;
|
|
242
|
+
}
|
|
243
|
+
/**
|
|
244
|
+
* The earliest span of exactly `length` inside `within` that does not
|
|
245
|
+
* touch this set, or `undefined` if none exists.
|
|
246
|
+
*
|
|
247
|
+
* `options.step` aligns the slot start to multiples of `step`
|
|
248
|
+
* (e.g. `15 * 60_000` for quarter hours), measured from `options.origin` (default 0).
|
|
249
|
+
*/
|
|
250
|
+
findSlot(length, within, options = {}) {
|
|
251
|
+
if (!(length > 0)) throw new RangeError("spanset: slot length must be > 0");
|
|
252
|
+
const { step, origin = 0 } = options;
|
|
253
|
+
if (step !== void 0 && !(step > 0)) throw new RangeError("spanset: step must be > 0");
|
|
254
|
+
for (const gap of this.complement(within).#spans) {
|
|
255
|
+
let start = gap.start;
|
|
256
|
+
if (step !== void 0 && Number.isFinite(start)) {
|
|
257
|
+
start = origin + Math.ceil((start - origin) / step) * step;
|
|
258
|
+
}
|
|
259
|
+
if (start + length <= gap.end && Number.isFinite(start)) {
|
|
260
|
+
return Object.freeze({ start, end: start + length });
|
|
261
|
+
}
|
|
262
|
+
}
|
|
263
|
+
return void 0;
|
|
264
|
+
}
|
|
265
|
+
/** Plain `[start, end]` tuples. */
|
|
266
|
+
toArray() {
|
|
267
|
+
return this.#spans.map((s) => [s.start, s.end]);
|
|
268
|
+
}
|
|
269
|
+
/** Spans as Date objects. */
|
|
270
|
+
toDates() {
|
|
271
|
+
return this.#spans.map((s) => ({ start: new Date(s.start), end: new Date(s.end) }));
|
|
272
|
+
}
|
|
273
|
+
toJSON() {
|
|
274
|
+
return this.toArray();
|
|
275
|
+
}
|
|
276
|
+
toString() {
|
|
277
|
+
return this.isEmpty ? "\u2205" : this.#spans.map((s) => `[${s.start}, ${s.end})`).join(" \u222A ");
|
|
278
|
+
}
|
|
279
|
+
[Symbol.iterator]() {
|
|
280
|
+
return this.#spans[Symbol.iterator]();
|
|
281
|
+
}
|
|
282
|
+
};
|
|
283
|
+
function spans(...inputs) {
|
|
284
|
+
return SpanSet.from(inputs);
|
|
285
|
+
}
|
|
286
|
+
export {
|
|
287
|
+
SpanSet,
|
|
288
|
+
spans
|
|
289
|
+
};
|
|
290
|
+
//# sourceMappingURL=index.js.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * spanset — immutable sets of half-open intervals `[start, end)`.\n *\n * Every SpanSet is kept in canonical form: spans are sorted, non-empty,\n * and never overlap or touch. All operations return new instances.\n */\n\n/** A point on the line. Dates are converted with `getTime()`. */\nexport type Bound = number | Date;\n\n/** Anything that describes a single span. */\nexport type SpanInput = readonly [Bound, Bound] | { readonly start: Bound; readonly end: Bound };\n\n/** Anything that describes a set of spans. */\nexport type SpanSetLike = SpanSet | SpanInput | readonly SpanInput[];\n\n/** A normalized half-open span `[start, end)` with `start < end`. */\nexport interface Span {\n readonly start: number;\n readonly end: number;\n}\n\n/** A span expressed with Date objects. */\nexport interface DateSpan {\n readonly start: Date;\n readonly end: Date;\n}\n\nfunction toNumber(b: Bound, what: string): number {\n const n = b instanceof Date ? b.getTime() : b;\n if (typeof n !== \"number\" || Number.isNaN(n)) {\n throw new TypeError(`spanset: ${what} must be a number or a valid Date, got ${String(b)}`);\n }\n return n;\n}\n\nfunction isBound(v: unknown): v is Bound {\n return typeof v === \"number\" || v instanceof Date;\n}\n\nfunction isSingleSpan(v: unknown): v is SpanInput {\n if (Array.isArray(v)) return v.length === 2 && isBound(v[0]) && isBound(v[1]);\n return typeof v === \"object\" && v !== null && \"start\" in v && \"end\" in v;\n}\n\nfunction parseSpan(input: SpanInput): Span | null {\n const [s, e] = Array.isArray(input)\n ? (input as readonly [Bound, Bound])\n : [(input as { start: Bound }).start, (input as { end: Bound }).end];\n const start = toNumber(s, \"start\");\n const end = toNumber(e, \"end\");\n if (start > end) {\n throw new RangeError(`spanset: start (${start}) must not be greater than end (${end})`);\n }\n return start === end ? null : Object.freeze({ start, end });\n}\n\n/** Sorts and merges overlapping/adjacent spans. Takes ownership of `spans`. */\nfunction normalize(spans: Span[]): Span[] {\n if (spans.length < 2) return spans;\n spans.sort((a, b) => a.start - b.start || a.end - b.end);\n const out: Span[] = [spans[0]!];\n for (let i = 1; i < spans.length; i++) {\n const cur = spans[i]!;\n const last = out[out.length - 1]!;\n if (cur.start <= last.end) {\n if (cur.end > last.end) out[out.length - 1] = Object.freeze({ start: last.start, end: cur.end });\n } else {\n out.push(cur);\n }\n }\n return out;\n}\n\nconst EMPTY_SPANS: readonly Span[] = Object.freeze([]);\n\nexport class SpanSet implements Iterable<Span> {\n readonly #spans: readonly Span[];\n\n private constructor(normalized: readonly Span[]) {\n this.#spans = Object.freeze(normalized);\n }\n\n /** The empty set. */\n static readonly empty: SpanSet = new SpanSet(EMPTY_SPANS);\n\n /** The set covering the whole number line. */\n static readonly all: SpanSet = new SpanSet([Object.freeze({ start: -Infinity, end: Infinity })]);\n\n /** Builds a set from any number of spans; overlapping spans are merged. */\n static of(...inputs: SpanInput[]): SpanSet {\n return SpanSet.from(inputs);\n }\n\n /** Builds a set from a SpanSet, a single span, or a list/iterable of spans. */\n static from(input: SpanSetLike | Iterable<SpanInput>): SpanSet {\n if (input instanceof SpanSet) return input;\n if (isSingleSpan(input)) {\n const s = parseSpan(input);\n return s ? new SpanSet([s]) : SpanSet.empty;\n }\n const spans: Span[] = [];\n for (const item of input as Iterable<SpanInput>) {\n const s = parseSpan(item);\n if (s) spans.push(s);\n }\n return spans.length ? new SpanSet(normalize(spans)) : SpanSet.empty;\n }\n\n /** The canonical spans, sorted and disjoint. */\n get spans(): readonly Span[] {\n return this.#spans;\n }\n\n /** Number of disjoint spans. */\n get count(): number {\n return this.#spans.length;\n }\n\n get isEmpty(): boolean {\n return this.#spans.length === 0;\n }\n\n /** Total length covered by the set (may be `Infinity`). */\n get measure(): number {\n let total = 0;\n for (const s of this.#spans) total += s.end - s.start;\n return total;\n }\n\n /** The smallest single span containing the whole set, or `undefined` if empty. */\n get bounds(): Span | undefined {\n const s = this.#spans;\n if (!s.length) return undefined;\n return Object.freeze({ start: s[0]!.start, end: s[s.length - 1]!.end });\n }\n\n /** Index of the span containing `point`, or -1. Binary search, O(log n). */\n #indexOf(point: number): number {\n const s = this.#spans;\n let lo = 0;\n let hi = s.length - 1;\n while (lo <= hi) {\n const mid = (lo + hi) >>> 1;\n const span = s[mid]!;\n if (point < span.start) hi = mid - 1;\n else if (point >= span.end) lo = mid + 1;\n else return mid;\n }\n return -1;\n }\n\n /** Whether `point` lies inside the set. */\n has(point: Bound): boolean {\n return this.#indexOf(toNumber(point, \"point\")) !== -1;\n }\n\n /** The span containing `point`, if any. */\n spanAt(point: Bound): Span | undefined {\n const i = this.#indexOf(toNumber(point, \"point\"));\n return i === -1 ? undefined : this.#spans[i];\n }\n\n /** Union of this set and every argument. */\n union(...others: SpanSetLike[]): SpanSet {\n if (!others.length) return this;\n const all: Span[] = [...this.#spans];\n for (const o of others) all.push(...SpanSet.from(o).#spans);\n return all.length ? new SpanSet(normalize(all)) : SpanSet.empty;\n }\n\n /** Points present in both sets. O(n + m). */\n intersect(other: SpanSetLike): SpanSet {\n const a = this.#spans;\n const b = SpanSet.from(other).#spans;\n const out: Span[] = [];\n let i = 0;\n let j = 0;\n while (i < a.length && j < b.length) {\n const x = a[i]!;\n const y = b[j]!;\n const start = Math.max(x.start, y.start);\n const end = Math.min(x.end, y.end);\n if (start < end) out.push(Object.freeze({ start, end }));\n if (x.end < y.end) i++;\n else j++;\n }\n return out.length ? new SpanSet(out) : SpanSet.empty;\n }\n\n /** Points in this set that are not in `other`. O(n + m). */\n subtract(other: SpanSetLike): SpanSet {\n const b = SpanSet.from(other).#spans;\n if (!b.length || this.isEmpty) return this;\n const out: Span[] = [];\n let j = 0;\n for (const x of this.#spans) {\n let start = x.start;\n while (j < b.length && b[j]!.end <= start) j++;\n let k = j;\n while (k < b.length && b[k]!.start < x.end) {\n const y = b[k]!;\n if (y.start > start) out.push(Object.freeze({ start, end: y.start }));\n start = Math.max(start, y.end);\n if (start >= x.end) break;\n k++;\n }\n if (start < x.end) out.push(start === x.start ? x : Object.freeze({ start, end: x.end }));\n }\n return out.length ? new SpanSet(out) : SpanSet.empty;\n }\n\n /** Points in exactly one of the two sets. */\n xor(other: SpanSetLike): SpanSet {\n const o = SpanSet.from(other);\n return this.subtract(o).union(o.subtract(this));\n }\n\n /** Everything inside `within` (default: the whole line) that is not in this set. */\n complement(within: SpanSetLike = SpanSet.all): SpanSet {\n return SpanSet.from(within).subtract(this);\n }\n\n /** The holes between consecutive spans (excludes the unbounded outside). */\n gaps(): SpanSet {\n const s = this.#spans;\n if (s.length < 2) return SpanSet.empty;\n const out: Span[] = [];\n for (let i = 1; i < s.length; i++) out.push(Object.freeze({ start: s[i - 1]!.end, end: s[i]!.start }));\n return new SpanSet(out);\n }\n\n /** Restricts the set to `within`. Alias of `intersect`. */\n clip(within: SpanSetLike): SpanSet {\n return this.intersect(within);\n }\n\n /**\n * Grows every span by `before` on the left and `after` on the right\n * (negative values shrink). Spans that grow into each other are merged;\n * spans that shrink to nothing are dropped.\n */\n expand(before: number, after: number = before): SpanSet {\n if (Number.isNaN(before) || Number.isNaN(after)) throw new TypeError(\"spanset: expand amounts must be numbers\");\n const out: Span[] = [];\n for (const s of this.#spans) {\n const start = s.start - before;\n const end = s.end + after;\n if (start < end) out.push(Object.freeze({ start, end }));\n }\n return out.length ? new SpanSet(normalize(out)) : SpanSet.empty;\n }\n\n /** Moves every span by `delta`. */\n shift(delta: number): SpanSet {\n if (delta === 0) return this;\n return new SpanSet(this.#spans.map((s) => Object.freeze({ start: s.start + delta, end: s.end + delta })));\n }\n\n /** Keeps only spans for which `predicate` returns true. */\n filter(predicate: (span: Span, index: number) => boolean): SpanSet {\n const out = this.#spans.filter(predicate);\n return out.length === this.#spans.length ? this : out.length ? new SpanSet(out) : SpanSet.empty;\n }\n\n /** Whether the two sets share at least one point. */\n overlaps(other: SpanSetLike): boolean {\n const a = this.#spans;\n const b = SpanSet.from(other).#spans;\n let i = 0;\n let j = 0;\n while (i < a.length && j < b.length) {\n const x = a[i]!;\n const y = b[j]!;\n if (x.start < y.end && y.start < x.end) return true;\n if (x.end <= y.end) i++;\n else j++;\n }\n return false;\n }\n\n /** Whether every point of `other` is in this set. */\n covers(other: SpanSetLike): boolean {\n return SpanSet.from(other).subtract(this).isEmpty;\n }\n\n /** Structural equality. */\n equals(other: SpanSetLike): boolean {\n const a = this.#spans;\n const b = SpanSet.from(other).#spans;\n if (a.length !== b.length) return false;\n for (let i = 0; i < a.length; i++) {\n if (a[i]!.start !== b[i]!.start || a[i]!.end !== b[i]!.end) return false;\n }\n return true;\n }\n\n /**\n * Free spans of at least `minLength` inside `within` — i.e. the complement\n * of this set, filtered by length. Handy for \"when is everyone free?\".\n */\n free(within: SpanSetLike, minLength = 0): SpanSet {\n const c = this.complement(within);\n return minLength > 0 ? c.filter((s) => s.end - s.start >= minLength) : c;\n }\n\n /**\n * The earliest span of exactly `length` inside `within` that does not\n * touch this set, or `undefined` if none exists.\n *\n * `options.step` aligns the slot start to multiples of `step`\n * (e.g. `15 * 60_000` for quarter hours), measured from `options.origin` (default 0).\n */\n findSlot(\n length: number,\n within: SpanSetLike,\n options: { step?: number; origin?: number } = {},\n ): Span | undefined {\n if (!(length > 0)) throw new RangeError(\"spanset: slot length must be > 0\");\n const { step, origin = 0 } = options;\n if (step !== undefined && !(step > 0)) throw new RangeError(\"spanset: step must be > 0\");\n for (const gap of this.complement(within).#spans) {\n let start = gap.start;\n if (step !== undefined && Number.isFinite(start)) {\n start = origin + Math.ceil((start - origin) / step) * step;\n }\n if (start + length <= gap.end && Number.isFinite(start)) {\n return Object.freeze({ start, end: start + length });\n }\n }\n return undefined;\n }\n\n /** Plain `[start, end]` tuples. */\n toArray(): [number, number][] {\n return this.#spans.map((s) => [s.start, s.end]);\n }\n\n /** Spans as Date objects. */\n toDates(): DateSpan[] {\n return this.#spans.map((s) => ({ start: new Date(s.start), end: new Date(s.end) }));\n }\n\n toJSON(): [number, number][] {\n return this.toArray();\n }\n\n toString(): string {\n return this.isEmpty ? \"∅\" : this.#spans.map((s) => `[${s.start}, ${s.end})`).join(\" ∪ \");\n }\n\n [Symbol.iterator](): Iterator<Span> {\n return this.#spans[Symbol.iterator]();\n }\n}\n\n/** Shorthand for `SpanSet.of(...)`. */\nexport function spans(...inputs: SpanInput[]): SpanSet {\n return SpanSet.from(inputs);\n}\n"],"mappings":"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","names":["spans"]}
|
package/package.json
CHANGED
|
@@ -1,6 +1,63 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "spanset",
|
|
3
|
-
"version": "0.
|
|
4
|
-
"
|
|
5
|
-
"
|
|
6
|
-
|
|
3
|
+
"version": "0.1.0",
|
|
4
|
+
"description": "Immutable sets of half-open numeric/time intervals: union, intersect, subtract, gaps, and free-slot finding. Zero dependencies.",
|
|
5
|
+
"keywords": [
|
|
6
|
+
"interval",
|
|
7
|
+
"range",
|
|
8
|
+
"span",
|
|
9
|
+
"set",
|
|
10
|
+
"schedule",
|
|
11
|
+
"availability",
|
|
12
|
+
"free-busy",
|
|
13
|
+
"time-range",
|
|
14
|
+
"typescript"
|
|
15
|
+
],
|
|
16
|
+
"license": "MIT",
|
|
17
|
+
"author": "jihoo12",
|
|
18
|
+
"repository": {
|
|
19
|
+
"type": "git",
|
|
20
|
+
"url": "git+https://github.com/jihoo12/spanset.git"
|
|
21
|
+
},
|
|
22
|
+
"homepage": "https://github.com/jihoo12/spanset#readme",
|
|
23
|
+
"bugs": {
|
|
24
|
+
"url": "https://github.com/jihoo12/spanset/issues"
|
|
25
|
+
},
|
|
26
|
+
"type": "module",
|
|
27
|
+
"sideEffects": false,
|
|
28
|
+
"main": "./dist/index.cjs",
|
|
29
|
+
"module": "./dist/index.js",
|
|
30
|
+
"types": "./dist/index.d.ts",
|
|
31
|
+
"exports": {
|
|
32
|
+
".": {
|
|
33
|
+
"import": {
|
|
34
|
+
"types": "./dist/index.d.ts",
|
|
35
|
+
"default": "./dist/index.js"
|
|
36
|
+
},
|
|
37
|
+
"require": {
|
|
38
|
+
"types": "./dist/index.d.cts",
|
|
39
|
+
"default": "./dist/index.cjs"
|
|
40
|
+
}
|
|
41
|
+
}
|
|
42
|
+
},
|
|
43
|
+
"files": [
|
|
44
|
+
"dist",
|
|
45
|
+
"README.md",
|
|
46
|
+
"LICENSE"
|
|
47
|
+
],
|
|
48
|
+
"engines": {
|
|
49
|
+
"node": ">=18"
|
|
50
|
+
},
|
|
51
|
+
"scripts": {
|
|
52
|
+
"build": "tsup && tsc -p tsconfig.build.json && node -e \"require('fs').copyFileSync('dist/index.d.ts','dist/index.d.cts')\"",
|
|
53
|
+
"test": "vitest run",
|
|
54
|
+
"test:watch": "vitest",
|
|
55
|
+
"typecheck": "tsc --noEmit",
|
|
56
|
+
"prepublishOnly": "npm run typecheck && npm test && npm run build"
|
|
57
|
+
},
|
|
58
|
+
"devDependencies": {
|
|
59
|
+
"tsup": "^9.0.0",
|
|
60
|
+
"typescript": "^7.0.2",
|
|
61
|
+
"vitest": "^5.1.1"
|
|
62
|
+
}
|
|
63
|
+
}
|