foldkit 0.18.0 → 0.20.0

package/dist/task/index.d.ts

@@ -1,109 +1,8 @@
-import { DateTime, Duration, Effect } from 'effect';
-/**
- * Creates a command that gets the current UTC time and passes it to a message constructor.
- * This is similar to Elm's `Task.perform` with `Time.now`.
- *
- * @example
- * ```typescript
- * Task.getTime(utc => GotTime({ utc }))
- * ```
- */
-export declare const getTime: <Message>(f: (utc: DateTime.Utc) => Message) => Effect.Effect<Message>;
-/**
- * Creates a command that gets the system timezone and passes it to a message constructor.
- * This is similar to Elm's `Task.perform` with `Time.here`.
- *
- * @example
- * ```typescript
- * Task.getTimeZone(zone => GotTimeZone({ zone }))
- * ```
- */
-export declare const getTimeZone: <Message>(f: (zone: DateTime.TimeZone) => Message) => Effect.Effect<Message>;
-/**
- * Creates a command that gets the current time in the system timezone and passes it to a message constructor.
- * This combines both time and timezone in a single task.
- *
- * @example
- * ```typescript
- * Task.getZonedTime(zoned => GotTime({ zoned }))
- * ```
- */
-export declare const getZonedTime: <Message>(f: (zoned: DateTime.Zoned) => Message) => Effect.Effect<Message>;
-/**
- * Creates a command that gets the current time in a specific timezone and passes it to a message constructor.
- * If the timezone is invalid, the effect will fail with an error string.
- *
- * @example
- * ```typescript
- * Task.getZonedTimeIn('America/New_York', zoned => GotNYTime({ zoned }))
- * ```
- */
-export declare const getZonedTimeIn: <Message>(zoneId: string, f: (zoned: DateTime.Zoned) => Message) => Effect.Effect<Message, string>;
-/**
- * Creates a command that focuses an element by selector and passes the result to a message constructor.
- * Passes true if the element was found and focused, false otherwise.
- * Uses requestAnimationFrame to ensure the DOM tree is updated and nodes exist before attempting to focus.
- * This follows the same approach as Elm's Browser.Dom.focus.
- *
- * @example
- * ```typescript
- * Task.focus('#email-input', success => InputFocused({ success }))
- * ```
- */
-export declare const focus: <Message>(selector: string, f: (success: boolean) => Message) => Effect.Effect<Message>;
-/**
- * Creates a command that opens a dialog element as a modal using `showModal()`.
- * Passes true if the element was found and opened, false otherwise.
- * Uses requestAnimationFrame to ensure the DOM tree is updated and nodes exist before attempting to show.
- *
- * @example
- * ```typescript
- * Task.showModal('#my-dialog', success => ModalOpened({ success }))
- * ```
- */
-export declare const showModal: <Message>(selector: string, f: (success: boolean) => Message) => Effect.Effect<Message>;
-/**
- * Creates a command that closes a dialog element using `.close()`.
- * Passes true if the element was found and closed, false otherwise.
- * Uses requestAnimationFrame to ensure the DOM tree is updated and nodes exist before attempting to close.
- *
- * @example
- * ```typescript
- * Task.closeModal('#my-dialog', success => ModalClosed({ success }))
- * ```
- */
-export declare const closeModal: <Message>(selector: string, f: (success: boolean) => Message) => Effect.Effect<Message>;
-/**
- * Creates a command that resolves to a message after a delay.
- * Useful for debouncing, such as clearing a typeahead search query.
- *
- * @example
- * ```typescript
- * Task.delay(350, () => SearchCleared({ version: model.searchVersion }))
- * Task.delay(Duration.seconds(1), () => TimedOut())
- * ```
- */
-export declare const delay: <Message>(duration: Duration.DurationInput, f: () => Message) => Effect.Effect<Message>;
-/**
- * Creates a command that generates a random integer between min (inclusive) and max (exclusive)
- * and passes it to a message constructor.
- *
- * @example
- * ```typescript
- * Task.randomInt(0, 100, value => GotRandom({ value }))
- * ```
- */
-/**
- * Creates a command that scrolls an element into view by selector and passes the result to a message constructor.
- * Passes true if the element was found and scrolled, false otherwise.
- * Uses requestAnimationFrame to ensure the DOM tree is updated and nodes exist before attempting to scroll.
- * Uses `{ block: 'nearest' }` to avoid unnecessary scrolling when the element is already visible.
- *
- * @example
- * ```typescript
- * Task.scrollIntoView('#active-item', success => ItemScrolled({ success }))
- * ```
- */
-export declare const scrollIntoView: <Message>(selector: string, f: (success: boolean) => Message) => Effect.Effect<Message>;
-export declare const randomInt: <Message>(min: number, max: number, f: (value: number) => Message) => Effect.Effect<Message>;
+export { ElementNotFound, TimeZoneError } from './error';
+export { getTime, getTimeZone, getZonedTime, getZonedTimeIn } from './time';
+export { focus, showModal, closeModal, clickElement, scrollIntoView, } from './dom';
+export { delay, nextFrame, waitForTransitions } from './timing';
+export { randomInt } from './random';
+export { lockScroll, unlockScroll } from './scrollLock';
+export { inertOthers, restoreInert } from './inert';
 //# sourceMappingURL=index.d.ts.map

package/dist/task/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/task/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAA;AAE3D;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,GAAI,OAAO,EAC7B,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC,GAAG,KAAK,OAAO,KAChC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAgC,CAAA;AAExD;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,EACjC,GAAG,CAAC,IAAI,EAAE,QAAQ,CAAC,QAAQ,KAAK,OAAO,KACtC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAmD,CAAA;AAE3E;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,GAAI,OAAO,EAClC,GAAG,CAAC,KAAK,EAAE,QAAQ,CAAC,KAAK,KAAK,OAAO,KACpC,MAAM,CAAC,MAAM,CAAC,OAAO,CAMpB,CAAA;AAEJ;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,EACpC,QAAQ,MAAM,EACd,GAAG,CAAC,KAAK,EAAE,QAAQ,CAAC,KAAK,KAAK,OAAO,KACpC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAS5B,CAAA;AAEJ;;;;;;;;;;GAUG;AACH,eAAO,MAAM,KAAK,GAAI,OAAO,EAC3B,UAAU,MAAM,EAChB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,KAC/B,MAAM,CAAC,MAAM,CAAC,OAAO,CAWpB,CAAA;AAEJ;;;;;;;;;GASG;AACH,eAAO,MAAM,SAAS,GAAI,OAAO,EAC/B,UAAU,MAAM,EAChB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,KAC/B,MAAM,CAAC,MAAM,CAAC,OAAO,CAWpB,CAAA;AAEJ;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,EAChC,UAAU,MAAM,EAChB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,KAC/B,MAAM,CAAC,MAAM,CAAC,OAAO,CAWpB,CAAA;AAEJ;;;;;;;;;GASG;AACH,eAAO,MAAM,KAAK,GAAI,OAAO,EAC3B,UAAU,QAAQ,CAAC,aAAa,EAChC,GAAG,MAAM,OAAO,KACf,MAAM,CAAC,MAAM,CAAC,OAAO,CAIpB,CAAA;AAEJ;;;;;;;;GAQG;AACH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,EACpC,UAAU,MAAM,EAChB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,KAC/B,MAAM,CAAC,MAAM,CAAC,OAAO,CAWpB,CAAA;AAEJ,eAAO,MAAM,SAAS,GAAI,OAAO,EAC/B,KAAK,MAAM,EACX,KAAK,MAAM,EACX,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,KAC5B,MAAM,CAAC,MAAM,CAAC,OAAO,CAC6C,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/task/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AACxD,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AAC3E,OAAO,EACL,KAAK,EACL,SAAS,EACT,UAAU,EACV,YAAY,EACZ,cAAc,GACf,MAAM,OAAO,CAAA;AACd,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AACpC,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AACvD,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA"}

package/dist/task/index.js

@@ -1,168 +1,7 @@
-import { DateTime, Effect, Option } from 'effect';
-/**
- * Creates a command that gets the current UTC time and passes it to a message constructor.
- * This is similar to Elm's `Task.perform` with `Time.now`.
- *
- * @example
- * ```typescript
- * Task.getTime(utc => GotTime({ utc }))
- * ```
- */
-export const getTime = (f) => Effect.map(DateTime.now, f);
-/**
- * Creates a command that gets the system timezone and passes it to a message constructor.
- * This is similar to Elm's `Task.perform` with `Time.here`.
- *
- * @example
- * ```typescript
- * Task.getTimeZone(zone => GotTimeZone({ zone }))
- * ```
- */
-export const getTimeZone = (f) => Effect.sync(() => f(DateTime.zoneMakeLocal()));
-/**
- * Creates a command that gets the current time in the system timezone and passes it to a message constructor.
- * This combines both time and timezone in a single task.
- *
- * @example
- * ```typescript
- * Task.getZonedTime(zoned => GotTime({ zoned }))
- * ```
- */
-export const getZonedTime = (f) => Effect.gen(function* () {
-    const utc = yield* DateTime.now;
-    const zone = DateTime.zoneMakeLocal();
-    const zoned = DateTime.setZone(utc, zone);
-    return f(zoned);
-});
-/**
- * Creates a command that gets the current time in a specific timezone and passes it to a message constructor.
- * If the timezone is invalid, the effect will fail with an error string.
- *
- * @example
- * ```typescript
- * Task.getZonedTimeIn('America/New_York', zoned => GotNYTime({ zoned }))
- * ```
- */
-export const getZonedTimeIn = (zoneId, f) => Effect.gen(function* () {
-    const utc = yield* DateTime.now;
-    const maybeZone = DateTime.zoneMakeNamed(zoneId);
-    if (Option.isNone(maybeZone)) {
-        return yield* Effect.fail(`Invalid timezone: ${zoneId}`);
-    }
-    const zoned = DateTime.setZone(utc, maybeZone.value);
-    return f(zoned);
-});
-/**
- * Creates a command that focuses an element by selector and passes the result to a message constructor.
- * Passes true if the element was found and focused, false otherwise.
- * Uses requestAnimationFrame to ensure the DOM tree is updated and nodes exist before attempting to focus.
- * This follows the same approach as Elm's Browser.Dom.focus.
- *
- * @example
- * ```typescript
- * Task.focus('#email-input', success => InputFocused({ success }))
- * ```
- */
-export const focus = (selector, f) => Effect.async((resume) => {
-    requestAnimationFrame(() => {
-        const element = document.querySelector(selector);
-        if (element instanceof HTMLElement) {
-            element.focus();
-            resume(Effect.succeed(f(true)));
-        }
-        else {
-            resume(Effect.succeed(f(false)));
-        }
-    });
-});
-/**
- * Creates a command that opens a dialog element as a modal using `showModal()`.
- * Passes true if the element was found and opened, false otherwise.
- * Uses requestAnimationFrame to ensure the DOM tree is updated and nodes exist before attempting to show.
- *
- * @example
- * ```typescript
- * Task.showModal('#my-dialog', success => ModalOpened({ success }))
- * ```
- */
-export const showModal = (selector, f) => Effect.async((resume) => {
-    requestAnimationFrame(() => {
-        const element = document.querySelector(selector);
-        if (element instanceof HTMLDialogElement) {
-            element.showModal();
-            resume(Effect.succeed(f(true)));
-        }
-        else {
-            resume(Effect.succeed(f(false)));
-        }
-    });
-});
-/**
- * Creates a command that closes a dialog element using `.close()`.
- * Passes true if the element was found and closed, false otherwise.
- * Uses requestAnimationFrame to ensure the DOM tree is updated and nodes exist before attempting to close.
- *
- * @example
- * ```typescript
- * Task.closeModal('#my-dialog', success => ModalClosed({ success }))
- * ```
- */
-export const closeModal = (selector, f) => Effect.async((resume) => {
-    requestAnimationFrame(() => {
-        const element = document.querySelector(selector);
-        if (element instanceof HTMLDialogElement) {
-            element.close();
-            resume(Effect.succeed(f(true)));
-        }
-        else {
-            resume(Effect.succeed(f(false)));
-        }
-    });
-});
-/**
- * Creates a command that resolves to a message after a delay.
- * Useful for debouncing, such as clearing a typeahead search query.
- *
- * @example
- * ```typescript
- * Task.delay(350, () => SearchCleared({ version: model.searchVersion }))
- * Task.delay(Duration.seconds(1), () => TimedOut())
- * ```
- */
-export const delay = (duration, f) => Effect.gen(function* () {
-    yield* Effect.sleep(duration);
-    return f();
-});
-/**
- * Creates a command that generates a random integer between min (inclusive) and max (exclusive)
- * and passes it to a message constructor.
- *
- * @example
- * ```typescript
- * Task.randomInt(0, 100, value => GotRandom({ value }))
- * ```
- */
-/**
- * Creates a command that scrolls an element into view by selector and passes the result to a message constructor.
- * Passes true if the element was found and scrolled, false otherwise.
- * Uses requestAnimationFrame to ensure the DOM tree is updated and nodes exist before attempting to scroll.
- * Uses `{ block: 'nearest' }` to avoid unnecessary scrolling when the element is already visible.
- *
- * @example
- * ```typescript
- * Task.scrollIntoView('#active-item', success => ItemScrolled({ success }))
- * ```
- */
-export const scrollIntoView = (selector, f) => Effect.async((resume) => {
-    requestAnimationFrame(() => {
-        const element = document.querySelector(selector);
-        if (element instanceof HTMLElement) {
-            element.scrollIntoView({ block: 'nearest' });
-            resume(Effect.succeed(f(true)));
-        }
-        else {
-            resume(Effect.succeed(f(false)));
-        }
-    });
-});
-export const randomInt = (min, max, f) => Effect.sync(() => f(Math.floor(Math.random() * (max - min)) + min));
+export { ElementNotFound, TimeZoneError } from './error';
+export { getTime, getTimeZone, getZonedTime, getZonedTimeIn } from './time';
+export { focus, showModal, closeModal, clickElement, scrollIntoView, } from './dom';
+export { delay, nextFrame, waitForTransitions } from './timing';
+export { randomInt } from './random';
+export { lockScroll, unlockScroll } from './scrollLock';
+export { inertOthers, restoreInert } from './inert';

package/dist/task/inert.d.ts

@@ -0,0 +1,26 @@
+import { Effect } from 'effect';
+/**
+ * Marks all DOM elements outside the given selectors as `inert` and
+ * `aria-hidden="true"`. Walks each allowed element up to `document.body`,
+ * marking siblings that don't contain an allowed element. Uses reference
+ * counting so nested calls are safe.
+ *
+ * @example
+ * ```typescript
+ * Task.inertOthers('my-menu', ['#menu-button', '#menu-items']).pipe(
+ *   Effect.as(NoOp()),
+ * )
+ * ```
+ */
+export declare const inertOthers: (id: string, allowedSelectors: ReadonlyArray<string>) => Effect.Effect<void>;
+/**
+ * Restores all elements previously marked inert by `inertOthers` for the
+ * given ID. Safe to call without a preceding `inertOthers` — acts as a no-op.
+ *
+ * @example
+ * ```typescript
+ * Task.restoreInert('my-menu').pipe(Effect.as(NoOp()))
+ * ```
+ */
+export declare const restoreInert: (id: string) => Effect.Effect<void>;
+//# sourceMappingURL=inert.d.ts.map

package/dist/task/inert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inert.d.ts","sourceRoot":"","sources":["../../src/task/inert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAmC,MAAM,QAAQ,CAAA;AAoFvE;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,WAAW,GACtB,IAAI,MAAM,EACV,kBAAkB,aAAa,CAAC,MAAM,CAAC,KACtC,MAAM,CAAC,MAAM,CAAC,IAAI,CAajB,CAAA;AAEJ;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,GAAI,IAAI,MAAM,KAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAQxD,CAAA"}

package/dist/task/inert.js

@@ -0,0 +1,87 @@
+import { Array, Effect, Number, Option, Predicate, pipe } from 'effect';
+const inertState = {
+    originals: new Map(),
+    counts: new Map(),
+    cleanups: new Map(),
+};
+const markInert = (element) => {
+    const count = inertState.counts.get(element) ?? 0;
+    inertState.counts.set(element, Number.increment(count));
+    if (count === 0) {
+        inertState.originals.set(element, {
+            ariaHidden: element.getAttribute('aria-hidden'),
+            inert: element.inert,
+        });
+        element.setAttribute('aria-hidden', 'true');
+        element.inert = true;
+    }
+    return () => markNotInert(element);
+};
+const markNotInert = (element) => {
+    const count = inertState.counts.get(element) ?? 1;
+    if (count === 1) {
+        const original = inertState.originals.get(element);
+        if (original) {
+            if (Predicate.isNull(original.ariaHidden)) {
+                element.removeAttribute('aria-hidden');
+            }
+            else {
+                element.setAttribute('aria-hidden', original.ariaHidden);
+            }
+            element.inert = original.inert;
+            inertState.originals.delete(element);
+        }
+        inertState.counts.delete(element);
+    }
+    else {
+        inertState.counts.set(element, Number.decrement(count));
+    }
+};
+const resolveElements = (selectors) => Array.filterMap(selectors, selector => {
+    const element = document.querySelector(selector);
+    return element instanceof HTMLElement ? Option.some(element) : Option.none();
+});
+const ancestorsUpToBody = (element) => Array.unfold(element.parentElement, current => Predicate.isNotNull(current)
+    ? Option.some([
+        current,
+        current === document.body ? null : current.parentElement,
+    ])
+    : Option.none());
+const inertableSiblings = (parent, allowedElements) => pipe(parent.children, Array.fromIterable, Array.filterMap(child => child instanceof HTMLElement &&
+    !Array.some(allowedElements, allowed => child.contains(allowed))
+    ? Option.some(child)
+    : Option.none()));
+/**
+ * Marks all DOM elements outside the given selectors as `inert` and
+ * `aria-hidden="true"`. Walks each allowed element up to `document.body`,
+ * marking siblings that don't contain an allowed element. Uses reference
+ * counting so nested calls are safe.
+ *
+ * @example
+ * ```typescript
+ * Task.inertOthers('my-menu', ['#menu-button', '#menu-items']).pipe(
+ *   Effect.as(NoOp()),
+ * )
+ * ```
+ */
+export const inertOthers = (id, allowedSelectors) => Effect.sync(() => {
+    const allowedElements = resolveElements(allowedSelectors);
+    const cleanupFunctions = pipe(allowedElements, Array.flatMap(ancestorsUpToBody), Array.flatMap(ancestor => Array.map(inertableSiblings(ancestor, allowedElements), markInert)));
+    inertState.cleanups.set(id, cleanupFunctions);
+});
+/**
+ * Restores all elements previously marked inert by `inertOthers` for the
+ * given ID. Safe to call without a preceding `inertOthers` — acts as a no-op.
+ *
+ * @example
+ * ```typescript
+ * Task.restoreInert('my-menu').pipe(Effect.as(NoOp()))
+ * ```
+ */
+export const restoreInert = (id) => Effect.sync(() => {
+    const cleanupFunctions = inertState.cleanups.get(id);
+    if (cleanupFunctions) {
+        Array.forEach(cleanupFunctions, cleanup => cleanup());
+        inertState.cleanups.delete(id);
+    }
+});

package/dist/task/public.d.ts

@@ -1,2 +1,2 @@
-export { getTime, getTimeZone, getZonedTime, getZonedTimeIn, focus, showModal, closeModal, delay, scrollIntoView, randomInt, } from './index';
+export { ElementNotFound, TimeZoneError, getTime, getTimeZone, getZonedTime, getZonedTimeIn, focus, showModal, closeModal, clickElement, delay, scrollIntoView, randomInt, nextFrame, waitForTransitions, } from './index';
 //# sourceMappingURL=public.d.ts.map

package/dist/task/public.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../src/task/public.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,WAAW,EACX,YAAY,EACZ,cAAc,EACd,KAAK,EACL,SAAS,EACT,UAAU,EACV,KAAK,EACL,cAAc,EACd,SAAS,GACV,MAAM,SAAS,CAAA"}
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../src/task/public.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,aAAa,EACb,OAAO,EACP,WAAW,EACX,YAAY,EACZ,cAAc,EACd,KAAK,EACL,SAAS,EACT,UAAU,EACV,YAAY,EACZ,KAAK,EACL,cAAc,EACd,SAAS,EACT,SAAS,EACT,kBAAkB,GACnB,MAAM,SAAS,CAAA"}

package/dist/task/public.js

@@ -1 +1 @@
-export { getTime, getTimeZone, getZonedTime, getZonedTimeIn, focus, showModal, closeModal, delay, scrollIntoView, randomInt, } from './index';
+export { ElementNotFound, TimeZoneError, getTime, getTimeZone, getZonedTime, getZonedTimeIn, focus, showModal, closeModal, clickElement, delay, scrollIntoView, randomInt, nextFrame, waitForTransitions, } from './index';

package/dist/task/random.d.ts

@@ -0,0 +1,11 @@
+import { Effect } from 'effect';
+/**
+ * Generates a random integer between min (inclusive) and max (exclusive).
+ *
+ * @example
+ * ```typescript
+ * Task.randomInt(1, 7).pipe(Effect.map(value => GotDiceRoll({ value })))
+ * ```
+ */
+export declare const randomInt: (min: number, max: number) => Effect.Effect<number>;
+//# sourceMappingURL=random.d.ts.map

package/dist/task/random.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random.d.ts","sourceRoot":"","sources":["../../src/task/random.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE/B;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,GAAI,KAAK,MAAM,EAAE,KAAK,MAAM,KAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CACP,CAAA"}

package/dist/task/random.js

@@ -0,0 +1,10 @@
+import { Effect } from 'effect';
+/**
+ * Generates a random integer between min (inclusive) and max (exclusive).
+ *
+ * @example
+ * ```typescript
+ * Task.randomInt(1, 7).pipe(Effect.map(value => GotDiceRoll({ value })))
+ * ```
+ */
+export const randomInt = (min, max) => Effect.sync(() => Math.floor(Math.random() * (max - min)) + min);

package/dist/task/scrollLock.d.ts

@@ -0,0 +1,24 @@
+import { Effect } from 'effect';
+/**
+ * Locks page scroll by setting `overflow: hidden` on the document element.
+ * Compensates for scrollbar width with padding to prevent layout shift.
+ * Uses reference counting so nested locks are safe — the page only unlocks
+ * when every lock has been released.
+ *
+ * @example
+ * ```typescript
+ * Task.lockScroll.pipe(Effect.as(NoOp()))
+ * ```
+ */
+export declare const lockScroll: Effect.Effect<void>;
+/**
+ * Releases one scroll lock. When the last lock is released, restores the
+ * original `overflow` and `padding-right` on the document element.
+ *
+ * @example
+ * ```typescript
+ * Task.unlockScroll.pipe(Effect.as(NoOp()))
+ * ```
+ */
+export declare const unlockScroll: Effect.Effect<void>;
+//# sourceMappingURL=scrollLock.d.ts.map

package/dist/task/scrollLock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scrollLock.d.ts","sourceRoot":"","sources":["../../src/task/scrollLock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAA;AAQvC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAkBzC,CAAA;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAU3C,CAAA"}

package/dist/task/scrollLock.js

@@ -0,0 +1,46 @@
+import { Effect, Number } from 'effect';
+const scrollLockState = {
+    count: 0,
+    overflow: '',
+    paddingRight: '',
+};
+/**
+ * Locks page scroll by setting `overflow: hidden` on the document element.
+ * Compensates for scrollbar width with padding to prevent layout shift.
+ * Uses reference counting so nested locks are safe — the page only unlocks
+ * when every lock has been released.
+ *
+ * @example
+ * ```typescript
+ * Task.lockScroll.pipe(Effect.as(NoOp()))
+ * ```
+ */
+export const lockScroll = Effect.sync(() => {
+    const { documentElement, documentElement: { style }, } = document;
+    if (scrollLockState.count === 0) {
+        scrollLockState.overflow = style.overflow;
+        scrollLockState.paddingRight = style.paddingRight;
+        const scrollbarWidth = window.innerWidth - documentElement.clientWidth;
+        style.overflow = 'hidden';
+        style.paddingRight =
+            scrollbarWidth > 0 ? `${scrollbarWidth}px` : style.paddingRight;
+    }
+    scrollLockState.count++;
+});
+/**
+ * Releases one scroll lock. When the last lock is released, restores the
+ * original `overflow` and `padding-right` on the document element.
+ *
+ * @example
+ * ```typescript
+ * Task.unlockScroll.pipe(Effect.as(NoOp()))
+ * ```
+ */
+export const unlockScroll = Effect.sync(() => {
+    scrollLockState.count = Math.max(0, Number.decrement(scrollLockState.count));
+    if (scrollLockState.count === 0) {
+        const { documentElement: { style }, } = document;
+        style.overflow = scrollLockState.overflow;
+        style.paddingRight = scrollLockState.paddingRight;
+    }
+});

package/dist/task/time.d.ts

@@ -0,0 +1,43 @@
+import { DateTime, Effect } from 'effect';
+import { TimeZoneError } from './error';
+/**
+ * Gets the current UTC time.
+ *
+ * @example
+ * ```typescript
+ * Task.getTime.pipe(Effect.map(utc => GotTime({ utc })))
+ * ```
+ */
+export declare const getTime: Effect.Effect<DateTime.Utc>;
+/**
+ * Gets the system timezone.
+ *
+ * @example
+ * ```typescript
+ * Task.getTimeZone.pipe(Effect.map(zone => GotTimeZone({ zone })))
+ * ```
+ */
+export declare const getTimeZone: Effect.Effect<DateTime.TimeZone>;
+/**
+ * Gets the current time in the system timezone.
+ *
+ * @example
+ * ```typescript
+ * Task.getZonedTime.pipe(Effect.map(zoned => GotTime({ zoned })))
+ * ```
+ */
+export declare const getZonedTime: Effect.Effect<DateTime.Zoned>;
+/**
+ * Gets the current time in a specific timezone.
+ * Fails with `TimeZoneError` if the timezone ID is invalid.
+ *
+ * @example
+ * ```typescript
+ * Task.getZonedTimeIn('America/New_York').pipe(
+ *   Effect.map(zoned => GotNYTime({ zoned })),
+ *   Effect.catchAll(() => Effect.succeed(FailedTimeZone())),
+ * )
+ * ```
+ */
+export declare const getZonedTimeIn: (zoneId: string) => Effect.Effect<DateTime.Zoned, TimeZoneError>;
+//# sourceMappingURL=time.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["../../src/task/time.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAA;AAEjD,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAEvC;;;;;;;GAOG;AACH,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAgB,CAAA;AAEhE;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAExD,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAMtD,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,GACzB,QAAQ,MAAM,KACb,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAQ1C,CAAA"}

package/dist/task/time.js

@@ -0,0 +1,53 @@
+import { DateTime, Effect, Option } from 'effect';
+import { TimeZoneError } from './error';
+/**
+ * Gets the current UTC time.
+ *
+ * @example
+ * ```typescript
+ * Task.getTime.pipe(Effect.map(utc => GotTime({ utc })))
+ * ```
+ */
+export const getTime = DateTime.now;
+/**
+ * Gets the system timezone.
+ *
+ * @example
+ * ```typescript
+ * Task.getTimeZone.pipe(Effect.map(zone => GotTimeZone({ zone })))
+ * ```
+ */
+export const getTimeZone = Effect.sync(() => DateTime.zoneMakeLocal());
+/**
+ * Gets the current time in the system timezone.
+ *
+ * @example
+ * ```typescript
+ * Task.getZonedTime.pipe(Effect.map(zoned => GotTime({ zoned })))
+ * ```
+ */
+export const getZonedTime = Effect.gen(function* () {
+    const utc = yield* DateTime.now;
+    const zone = DateTime.zoneMakeLocal();
+    return DateTime.setZone(utc, zone);
+});
+/**
+ * Gets the current time in a specific timezone.
+ * Fails with `TimeZoneError` if the timezone ID is invalid.
+ *
+ * @example
+ * ```typescript
+ * Task.getZonedTimeIn('America/New_York').pipe(
+ *   Effect.map(zoned => GotNYTime({ zoned })),
+ *   Effect.catchAll(() => Effect.succeed(FailedTimeZone())),
+ * )
+ * ```
+ */
+export const getZonedTimeIn = (zoneId) => Effect.gen(function* () {
+    const utc = yield* DateTime.now;
+    const maybeZone = DateTime.zoneMakeNamed(zoneId);
+    if (Option.isNone(maybeZone)) {
+        return yield* Effect.fail(new TimeZoneError({ zoneId }));
+    }
+    return DateTime.setZone(utc, maybeZone.value);
+});