@maanlamp/react-web-ui 0.0.0-stage → 0.1.1

package/dist/lib/iso-zoned.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iso-zoned.d.ts","sourceRoot":"","sources":["../../src/lib/iso-zoned.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAgB7C;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,QACzB,MAAM,YACD,MAAM,KACd,QAAQ,CAAC,aAAa,GAAG,IAS3B,CAAC"}

package/dist/lib/iso-zoned.js

@@ -0,0 +1,19 @@
+import { Temporal } from "temporal-polyfill";
+// src/lib/iso-zoned.ts
+var ISO_PARSERS = [(iso, timeZone) => Temporal.Instant.from(iso).toZonedDateTimeISO(timeZone), (iso, timeZone) => Temporal.PlainDateTime.from(iso).toZonedDateTime(timeZone)];
+/**
+* The moment an ISO-8601 instant or plain date-time denotes in `timeZone`, or
+* `null` when it parses as neither.
+*
+* @example
+* isoToZonedDateTime("2026-05-26T22:30:00Z", "Europe/Amsterdam"); // 2026-05-27T00:30+02:00
+*/
+var isoToZonedDateTime = (iso, timeZone) => {
+	for (const parse of ISO_PARSERS) try {
+		return parse(iso, timeZone);
+	} catch {
+		continue;
+	}
+	return null;
+};
+export { isoToZonedDateTime };

package/dist/lib/password-strength/password-strength.d.ts

@@ -0,0 +1,39 @@
+import type { OptionsDictionary, Score, TranslationKeys } from "@zxcvbn-ts/core";
+/** A zxcvbn language pack: its dictionaries, and its feedback in that language. */
+export type ZxcvbnLanguagePack = Readonly<{
+    dictionary: OptionsDictionary;
+    translations: TranslationKeys;
+}>;
+/** Loads a zxcvbn language pack, such as `() => import("@zxcvbn-ts/language-de")`. */
+export type ZxcvbnLanguageLoader = () => Promise<ZxcvbnLanguagePack>;
+/** zxcvbn language pack loaders by lowercase language tag, such as `de` or `nl-be`. */
+export type ZxcvbnLanguages = Readonly<Record<string, ZxcvbnLanguageLoader>>;
+/** How strong a password is, as zxcvbn judged it. */
+export type PasswordStrengthResult = Readonly<{
+    /** zxcvbn's 0–4 band. */
+    score: Score;
+    /** zxcvbn's own warning, in the language pack's language. */
+    warning: string;
+    /** zxcvbn's own suggestions, in the language pack's language. */
+    suggestions: readonly string[];
+}>;
+/**
+ * The language pack that serves a locale, with its tag: the locale itself,
+ * then its language, then any regional pack of that language. It throws when
+ * none does.
+ *
+ * @example
+ * const [tag, load] = resolvePasswordLanguage("nl-NL", { en: loadEn, "nl-be": loadNlBe }); // tag "nl-be"
+ */
+export declare const resolvePasswordLanguage: (locale: string, languages: ZxcvbnLanguages) => readonly [string, ZxcvbnLanguageLoader];
+/**
+ * The strength of a password in a locale, or `null` while it is empty. It
+ * suspends while the locale's dictionaries load, each language in a chunk of
+ * its own; `languages` adds packs to the kit's English and Dutch ones. The
+ * first loader a language tag is checked with is the one kept.
+ *
+ * @example
+ * const strength = usePasswordStrength(password, useLocale(), { de: () => import("@zxcvbn-ts/language-de") });
+ */
+export declare const usePasswordStrength: (password: string, locale: string, languages?: ZxcvbnLanguages) => PasswordStrengthResult | null;
+//# sourceMappingURL=password-strength.d.ts.map

package/dist/lib/password-strength/password-strength.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"password-strength.d.ts","sourceRoot":"","sources":["../../../src/lib/password-strength/password-strength.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,iBAAiB,EACjB,KAAK,EACL,eAAe,EACf,MAAM,iBAAiB,CAAC;AAGzB,mFAAmF;AACnF,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC;IACzC,UAAU,EAAE,iBAAiB,CAAC;IAC9B,YAAY,EAAE,eAAe,CAAC;CAC9B,CAAC,CAAC;AAEH,sFAAsF;AACtF,MAAM,MAAM,oBAAoB,GAC/B,MAAM,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAEnC,uFAAuF;AACvF,MAAM,MAAM,eAAe,GAAG,QAAQ,CACrC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CACpC,CAAC;AAEF,qDAAqD;AACrD,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;IAC7C,yBAAyB;IACzB,KAAK,EAAE,KAAK,CAAC;IACb,6DAA6D;IAC7D,OAAO,EAAE,MAAM,CAAC;IAChB,iEAAiE;IACjE,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CAC/B,CAAC,CAAC;AAoDH;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,WAC3B,MAAM,aACH,eAAe,KACxB,SAAS,CAAC,MAAM,EAAE,oBAAoB,CAcxC,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,aACrB,MAAM,UACR,MAAM,cACH,eAAe,KACxB,sBAAsB,GAAG,IAO3B,CAAC"}

package/dist/lib/password-strength/password-strength.js

@@ -0,0 +1,72 @@
+import { use } from "react";
+// src/lib/password-strength/password-strength.ts
+var BUILT_IN_LANGUAGES = {
+	en: () => import("@zxcvbn-ts/language-en"),
+	"nl-be": () => import("@zxcvbn-ts/language-nl-be")
+};
+var checks = /* @__PURE__ */ new Map();
+var createCheck = async (load) => {
+	const [{ ZxcvbnFactory }, common, pack] = await Promise.all([
+		import("@zxcvbn-ts/core"),
+		import("@zxcvbn-ts/language-common"),
+		load()
+	]);
+	const zxcvbn = new ZxcvbnFactory({
+		dictionary: {
+			...common.dictionary,
+			...pack.dictionary
+		},
+		graphs: common.adjacencyGraphs,
+		translations: pack.translations,
+		useLevenshteinDistance: true
+	});
+	return (password) => {
+		const { score, feedback } = zxcvbn.check(password);
+		return {
+			score,
+			warning: feedback.warning ?? "",
+			suggestions: feedback.suggestions
+		};
+	};
+};
+var checkFor = (tag, load) => {
+	const existing = checks.get(tag);
+	if (existing !== void 0) return existing;
+	const loading = createCheck(load);
+	checks.set(tag, loading);
+	return loading;
+};
+/**
+* The language pack that serves a locale, with its tag: the locale itself,
+* then its language, then any regional pack of that language. It throws when
+* none does.
+*
+* @example
+* const [tag, load] = resolvePasswordLanguage("nl-NL", { en: loadEn, "nl-be": loadNlBe }); // tag "nl-be"
+*/
+var resolvePasswordLanguage = (locale, languages) => {
+	const exact = locale.toLowerCase();
+	const [language = exact] = exact.split("-");
+	const packs = Object.entries(languages);
+	const match = packs.find(([tag]) => tag === exact) ?? packs.find(([tag]) => tag === language) ?? packs.find(([tag]) => tag.startsWith(`${language}-`));
+	if (match === void 0) throw new Error(`There is no zxcvbn language pack for "${locale}". Pass one to PasswordStrength's \`languages\`.`);
+	return match;
+};
+/**
+* The strength of a password in a locale, or `null` while it is empty. It
+* suspends while the locale's dictionaries load, each language in a chunk of
+* its own; `languages` adds packs to the kit's English and Dutch ones. The
+* first loader a language tag is checked with is the one kept.
+*
+* @example
+* const strength = usePasswordStrength(password, useLocale(), { de: () => import("@zxcvbn-ts/language-de") });
+*/
+var usePasswordStrength = (password, locale, languages = {}) => {
+	const [tag, load] = resolvePasswordLanguage(locale, {
+		...BUILT_IN_LANGUAGES,
+		...languages
+	});
+	const check = use(checkFor(tag, load));
+	return password === "" ? null : check(password);
+};
+export { resolvePasswordLanguage, usePasswordStrength };

package/dist/lib/popup-edge-padding.d.ts

@@ -0,0 +1,21 @@
+import { type RefCallback } from "react";
+/** What {@link usePopupEdgePadding} hands a positioner. */
+export type PopupEdgePadding = Readonly<{
+    /** The positioner's ref, which reads the padding once it mounts. */
+    ref: RefCallback<HTMLElement>;
+    /** The space to keep from the viewport's edges, in pixels. */
+    collisionPadding: number;
+}>;
+/**
+ * Reads a positioned popup's collision padding at runtime from the
+ * `--popup-edge-padding` knob, resolved to pixels on the positioner by the
+ * `popup.edge-padding` mixin. `0` until the positioner mounts.
+ *
+ * @example
+ * <BasePopover.Positioner
+ * 	{...usePopupEdgePadding()}
+ * 	className={styles.positioner}
+ * />
+ */
+export declare const usePopupEdgePadding: () => PopupEdgePadding;
+//# sourceMappingURL=popup-edge-padding.d.ts.map

package/dist/lib/popup-edge-padding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"popup-edge-padding.d.ts","sourceRoot":"","sources":["../../src/lib/popup-edge-padding.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAY,MAAM,OAAO,CAAC;AAInD,2DAA2D;AAC3D,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IACvC,oEAAoE;IACpE,GAAG,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC;IAC9B,8DAA8D;IAC9D,gBAAgB,EAAE,MAAM,CAAC;CACzB,CAAC,CAAC;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,QAAO,gBAkBtC,CAAC"}

package/dist/lib/popup-edge-padding.js

@@ -0,0 +1,41 @@
+import { c } from "react/compiler-runtime";
+import { useState } from "react";
+// src/lib/popup-edge-padding.ts
+var RESOLVED_PROPERTY = "--_popup-edge-padding";
+/**
+* Reads a positioned popup's collision padding at runtime from the
+* `--popup-edge-padding` knob, resolved to pixels on the positioner by the
+* `popup.edge-padding` mixin. `0` until the positioner mounts.
+*
+* @example
+* <BasePopover.Positioner
+* 	{...usePopupEdgePadding()}
+* 	className={styles.positioner}
+* />
+*/
+var usePopupEdgePadding = () => {
+	const $ = c(3);
+	const [collisionPadding, setCollisionPadding] = useState(0);
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = (element) => {
+			if (element) {
+				const resolved = Number.parseFloat(getComputedStyle(element).getPropertyValue(RESOLVED_PROPERTY));
+				setCollisionPadding(Number.isFinite(resolved) ? resolved : 0);
+			}
+		};
+		$[0] = t0;
+	} else t0 = $[0];
+	const ref = t0;
+	let t1;
+	if ($[1] !== collisionPadding) {
+		t1 = {
+			ref,
+			collisionPadding
+		};
+		$[1] = collisionPadding;
+		$[2] = t1;
+	} else t1 = $[2];
+	return t1;
+};
+export { usePopupEdgePadding };

package/dist/lib/sliding-indicator/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./use-sliding-indicator.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/sliding-indicator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/sliding-indicator/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC"}

package/dist/lib/sliding-indicator/use-sliding-indicator.d.ts

@@ -0,0 +1,28 @@
+import { type RefCallback } from "react";
+/** What {@link useSlidingIndicator} measures and where it writes. */
+export type SlidingIndicatorOptions = Readonly<{
+    /** Matches the active item inside the indicator's parent, such as `"[data-pressed]"`. */
+    active: string;
+    /** The custom-property prefix the indicator's styles read. @default "--active-item" */
+    prefix?: string;
+    /**
+     * Which element carries the custom properties: the indicator, or its parent,
+     * where the indicator and its siblings inherit them. @default "indicator"
+     */
+    publishOn?: "indicator" | "parent";
+}>;
+/**
+ * Moves a sliding indicator onto the active item of its parent, which must be
+ * positioned. Writes `<prefix>-left`, `-top`, `-width` and `-height` on the
+ * indicator (or on its parent, with `publishOn: "parent"`), sets `data-empty`
+ * on the indicator while nothing is active and `data-jump` when it arrives from
+ * nothing, and re-measures whenever the parent resizes or anything inside it
+ * changes. It starts tracking whenever the indicator mounts. Style it with the
+ * `sliding-indicator.scss` mixins.
+ *
+ * @example
+ * const ref = useSlidingIndicator<HTMLSpanElement>({ active: '[aria-current="page"]' });
+ * <span ref={ref} aria-hidden="true" className={style.indicator} />
+ */
+export declare const useSlidingIndicator: <TElement extends HTMLElement>({ active, prefix, publishOn, }: SlidingIndicatorOptions) => RefCallback<TElement>;
+//# sourceMappingURL=use-sliding-indicator.d.ts.map

package/dist/lib/sliding-indicator/use-sliding-indicator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-sliding-indicator.d.ts","sourceRoot":"","sources":["../../../src/lib/sliding-indicator/use-sliding-indicator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAe,MAAM,OAAO,CAAC;AAEtD,qEAAqE;AACrE,MAAM,MAAM,uBAAuB,GAAG,QAAQ,CAAC;IAC9C,yFAAyF;IACzF,MAAM,EAAE,MAAM,CAAC;IACf,uFAAuF;IACvF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,SAAS,CAAC,EAAE,WAAW,GAAG,QAAQ,CAAC;CACnC,CAAC,CAAC;AA+FH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,mBAAmB,GAC/B,QAAQ,SAAS,WAAW,kCAK1B,uBAAuB,KAAG,WAAW,CAAC,QAAQ,CAO/C,CAAC"}

package/dist/lib/sliding-indicator/use-sliding-indicator.js

@@ -0,0 +1,84 @@
+import { c } from "react/compiler-runtime";
+// src/lib/sliding-indicator/use-sliding-indicator.ts
+var offsetWithin = (element, container) => {
+	let left = 0;
+	let top = 0;
+	let node = element;
+	while (node instanceof HTMLElement && node !== container) {
+		left += node.offsetLeft;
+		top += node.offsetTop;
+		node = node.offsetParent;
+	}
+	return {
+		left,
+		top
+	};
+};
+var publish = (carrier, property, value) => {
+	if (carrier.style.getPropertyValue(property) !== value) carrier.style.setProperty(property, value);
+};
+var track = (indicator, active, prefix, publishOn) => {
+	const container = indicator.parentElement;
+	if (container === null) return () => void 0;
+	const carrier = publishOn === "parent" ? container : indicator;
+	let wasActive = false;
+	const measure = () => {
+		const target = container.querySelector(active);
+		indicator.toggleAttribute("data-empty", target === null);
+		if (target === null) {
+			wasActive = false;
+			return;
+		}
+		indicator.toggleAttribute("data-jump", !wasActive);
+		wasActive = true;
+		const { left, top } = offsetWithin(target, container);
+		publish(carrier, `${prefix}-left`, `${left}px`);
+		publish(carrier, `${prefix}-top`, `${top}px`);
+		publish(carrier, `${prefix}-width`, `${target.offsetWidth}px`);
+		publish(carrier, `${prefix}-height`, `${target.offsetHeight}px`);
+	};
+	measure();
+	const resizes = new ResizeObserver(measure);
+	resizes.observe(container);
+	const mutations = new MutationObserver((records) => {
+		if (records.some((record) => !indicator.contains(record.target))) measure();
+	});
+	mutations.observe(container, {
+		attributes: true,
+		childList: true,
+		subtree: true
+	});
+	return () => {
+		resizes.disconnect();
+		mutations.disconnect();
+	};
+};
+/**
+* Moves a sliding indicator onto the active item of its parent, which must be
+* positioned. Writes `<prefix>-left`, `-top`, `-width` and `-height` on the
+* indicator (or on its parent, with `publishOn: "parent"`), sets `data-empty`
+* on the indicator while nothing is active and `data-jump` when it arrives from
+* nothing, and re-measures whenever the parent resizes or anything inside it
+* changes. It starts tracking whenever the indicator mounts. Style it with the
+* `sliding-indicator.scss` mixins.
+*
+* @example
+* const ref = useSlidingIndicator<HTMLSpanElement>({ active: '[aria-current="page"]' });
+* <span ref={ref} aria-hidden="true" className={style.indicator} />
+*/
+var useSlidingIndicator = (t0) => {
+	const $ = c(4);
+	const { active, prefix: t1, publishOn: t2 } = t0;
+	const prefix = t1 === void 0 ? "--active-item" : t1;
+	const publishOn = t2 === void 0 ? "indicator" : t2;
+	let t3;
+	if ($[0] !== active || $[1] !== prefix || $[2] !== publishOn) {
+		t3 = (indicator) => indicator === null ? void 0 : track(indicator, active, prefix, publishOn);
+		$[0] = active;
+		$[1] = prefix;
+		$[2] = publishOn;
+		$[3] = t3;
+	} else t3 = $[3];
+	return t3;
+};
+export { useSlidingIndicator };

package/dist/lib/storage.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A synchronous key-value store the app hands the kit for anything it
+ * persists. It is synchronous so a preference can be read during the first
+ * render. It owns serialisation and swallows access errors: a read that fails
+ * reports `undefined`, and a write or remove that fails is dropped.
+ *
+ * @example
+ * const { preference } = useTheme({ storage: localStorageAdapter, key: "theme" });
+ */
+export type StorageAdapter = Readonly<{
+    /** The value stored under `key`, or `undefined` when there is none. */
+    read: (key: string) => unknown;
+    write: (key: string, value: unknown) => void;
+    remove: (key: string) => void;
+    /**
+     * Calls `listener` whenever the value under `key` may have changed, in this
+     * tab or another, writes through this adapter included. Returns the
+     * unsubscribe.
+     */
+    subscribe: (key: string, listener: () => void) => () => void;
+}>;
+//# sourceMappingURL=storage.d.ts.map

package/dist/lib/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../src/lib/storage.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IACrC,uEAAuE;IACvE,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;IAC/B,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAC7C,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9B;;;;OAIG;IACH,SAAS,EAAE,CACV,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,IAAI,KAChB,MAAM,IAAI,CAAC;CAChB,CAAC,CAAC"}

package/dist/lib/table-storage.d.ts

@@ -0,0 +1,44 @@
+import type { StandardSchemaV1 } from "@tanstack/react-form";
+import type { StorageAdapter } from "./storage.ts";
+/** One persisted value, checked by its validator on every read and write. */
+export type StoredValue<T> = Readonly<{
+    /**
+     * The stored value, or the fallback when nothing is stored or the stored
+     * value no longer passes the validator.
+     */
+    read: () => T;
+    /** Stores `value`. Throws, storing nothing, when it fails the validator. */
+    write: (value: T) => void;
+    /** Forgets the stored value, so the next read returns the fallback. */
+    clear: () => void;
+    /** Calls `listener` whenever the value may have changed. Returns the unsubscribe. */
+    subscribe: (listener: () => void) => () => void;
+}>;
+/** What a stored value is checked against, and what it reads as when nothing valid is stored. */
+export type StoredValueShape<T> = Readonly<{
+    /** A synchronous Standard Schema validator; an asynchronous result counts as a failure. */
+    schema: StandardSchemaV1<unknown, T>;
+    fallback: T;
+}>;
+/**
+ * A value one table instance remembers across reloads, stored in `storage`
+ * under its `tableId` and `name`.
+ *
+ * @example
+ * const filters = tableStoredValue(
+ * 	"declarations",
+ * 	"filters",
+ * 	{ schema: z.object({ status: z.array(z.string()) }), fallback: { status: [] } },
+ * 	localStorageAdapter,
+ * );
+ */
+export declare const tableStoredValue: <T>(tableId: string, name: string, { schema, fallback }: StoredValueShape<T>, storage: StorageAdapter) => StoredValue<T>;
+/**
+ * The page size a table remembers: one of its `options`, or `fallback` when
+ * none is stored.
+ *
+ * @example
+ * storedPageSize("nza-rates", [10, 25, 50, 100], 10, localStorageAdapter).read(); // 50, or 10
+ */
+export declare const storedPageSize: (tableId: string, options: readonly number[], fallback: number, storage: StorageAdapter) => StoredValue<number>;
+//# sourceMappingURL=table-storage.d.ts.map

package/dist/lib/table-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-storage.d.ts","sourceRoot":"","sources":["../../src/lib/table-storage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD,6EAA6E;AAC7E,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,QAAQ,CAAC;IACrC;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC,CAAC;IACd,4EAA4E;IAC5E,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IAC1B,uEAAuE;IACvE,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,qFAAqF;IACrF,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAC;CAChD,CAAC,CAAC;AAEH,iGAAiG;AACjG,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,QAAQ,CAAC;IAC1C,2FAA2F;IAC3F,MAAM,EAAE,gBAAgB,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IACrC,QAAQ,EAAE,CAAC,CAAC;CACZ,CAAC,CAAC;AA2BH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,WACxB,MAAM,QACT,MAAM,wBACU,gBAAgB,CAAC,CAAC,CAAC,WAChC,cAAc,KACrB,WAAW,CAAC,CAAC,CAqBf,CAAC;AAqBF;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,YACjB,MAAM,WACN,SAAS,MAAM,EAAE,YAChB,MAAM,WACP,cAAc,KACrB,WAAW,CAAC,MAAM,CAMnB,CAAC"}

package/dist/lib/table-storage.js

@@ -0,0 +1,62 @@
+// src/lib/table-storage.ts
+var check = (schema, value) => {
+	const result = schema["~standard"].validate(value);
+	if (result instanceof Promise) return {
+		ok: false,
+		reason: "the validator is asynchronous"
+	};
+	return result.issues === void 0 ? {
+		ok: true,
+		value: result.value
+	} : {
+		ok: false,
+		reason: result.issues.map((issue) => issue.message).join("; ")
+	};
+};
+/**
+* A value one table instance remembers across reloads, stored in `storage`
+* under its `tableId` and `name`.
+*
+* @example
+* const filters = tableStoredValue(
+* 	"declarations",
+* 	"filters",
+* 	{ schema: z.object({ status: z.array(z.string()) }), fallback: { status: [] } },
+* 	localStorageAdapter,
+* );
+*/
+var tableStoredValue = (tableId, name, { schema, fallback }, storage) => {
+	const key = `table:${tableId}:${name}`;
+	return {
+		read: () => {
+			const stored = check(schema, storage.read(key));
+			return stored.ok ? stored.value : fallback;
+		},
+		write: (value) => {
+			const checked = check(schema, value);
+			if (!checked.ok) throw new Error(`Refusing to store ${key}: ${checked.reason}`);
+			storage.write(key, checked.value);
+		},
+		clear: () => {
+			storage.remove(key);
+		},
+		subscribe: (listener) => storage.subscribe(key, listener)
+	};
+};
+var pageSizeSchema = (options) => ({ "~standard": {
+	version: 1,
+	vendor: "react-web-ui",
+	validate: (value) => typeof value === "number" && options.includes(value) ? { value } : { issues: [{ message: `expected one of ${options.join(", ")}` }] }
+} });
+/**
+* The page size a table remembers: one of its `options`, or `fallback` when
+* none is stored.
+*
+* @example
+* storedPageSize("nza-rates", [10, 25, 50, 100], 10, localStorageAdapter).read(); // 50, or 10
+*/
+var storedPageSize = (tableId, options, fallback, storage) => tableStoredValue(tableId, "page-size", {
+	schema: pageSizeSchema(options),
+	fallback
+}, storage);
+export { storedPageSize, tableStoredValue };

package/dist/lib/text-length.d.ts

@@ -0,0 +1,11 @@
+/** How a `length / maxLength` counter reads against its maximum. */
+export type LengthTone = "normal" | "warning" | "error";
+/**
+ * The tone a length counter shows: `warning` from 90% of the maximum, `error`
+ * past it.
+ *
+ * @example
+ * lengthTone(1900, 2000); // "warning"
+ */
+export declare const lengthTone: (length: number, maxLength: number) => LengthTone;
+//# sourceMappingURL=text-length.d.ts.map

package/dist/lib/text-length.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-length.d.ts","sourceRoot":"","sources":["../../src/lib/text-length.ts"],"names":[],"mappings":"AAAA,oEAAoE;AACpE,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,CAAC;AAIxD;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,WACd,MAAM,aACH,MAAM,KACf,UAMF,CAAC"}

package/dist/lib/text-length.js

@@ -0,0 +1,15 @@
+// src/lib/text-length.ts
+var WARNING_RATIO = .9;
+/**
+* The tone a length counter shows: `warning` from 90% of the maximum, `error`
+* past it.
+*
+* @example
+* lengthTone(1900, 2000); // "warning"
+*/
+var lengthTone = (length, maxLength) => {
+	const ratio = length / maxLength;
+	if (ratio > 1) return "error";
+	return ratio >= WARNING_RATIO ? "warning" : "normal";
+};
+export { lengthTone };

package/dist/lib/tone.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A status colour role, shared by every leaf that carries one.
+ *
+ * @example
+ * const tone: Tone = "warning";
+ */
+export type Tone = "neutral" | "info" | "success" | "warning" | "error";
+/**
+ * How a toned leaf fills: a tint, the tone's ink as a fill, or an outline.
+ *
+ * @example
+ * <Badge tone="info" variant="solid">3</Badge>
+ */
+export type ToneVariant = "subtle" | "solid" | "outline";
+//# sourceMappingURL=tone.d.ts.map

package/dist/lib/tone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tone.d.ts","sourceRoot":"","sources":["../../src/lib/tone.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,IAAI,GACb,SAAS,GACT,MAAM,GACN,SAAS,GACT,SAAS,GACT,OAAO,CAAC;AAEX;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,OAAO,GAAG,SAAS,CAAC"}

package/dist/lib/unsaved-changes/before-unload.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Asks the browser to confirm a reload, a close or a navigation away from the
+ * app while `when`.
+ *
+ * @example
+ * useBeforeUnload(form.state.isDirty);
+ */
+export declare const useBeforeUnload: (when: boolean) => void;
+//# sourceMappingURL=before-unload.d.ts.map

package/dist/lib/unsaved-changes/before-unload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"before-unload.d.ts","sourceRoot":"","sources":["../../../src/lib/unsaved-changes/before-unload.ts"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,SAAU,OAAO,KAAG,IAY/C,CAAC"}

package/dist/lib/unsaved-changes/before-unload.js

@@ -0,0 +1,37 @@
+import { c } from "react/compiler-runtime";
+import { useEffect } from "react";
+// src/lib/unsaved-changes/before-unload.ts
+var holdUnload = (event) => {
+	event.preventDefault();
+};
+/**
+* Asks the browser to confirm a reload, a close or a navigation away from the
+* app while `when`.
+*
+* @example
+* useBeforeUnload(form.state.isDirty);
+*/
+var useBeforeUnload = (when) => {
+	const $ = c(3);
+	let t0;
+	let t1;
+	if ($[0] !== when) {
+		t0 = () => {
+			if (!when) return;
+			window.addEventListener("beforeunload", holdUnload);
+			return _temp;
+		};
+		t1 = [when];
+		$[0] = when;
+		$[1] = t0;
+		$[2] = t1;
+	} else {
+		t0 = $[1];
+		t1 = $[2];
+	}
+	useEffect(t0, t1);
+};
+function _temp() {
+	return window.removeEventListener("beforeunload", holdUnload);
+}
+export { useBeforeUnload };

package/dist/lib/unsaved-changes/index.d.ts

@@ -0,0 +1,5 @@
+export { useBeforeUnload } from "./before-unload.ts";
+export { type LeaveGuard, LeaveGuardDialog, type LeaveGuardDialogProps, useLeaveGuard, } from "./leave-guard.tsx";
+export { type LeaveGuardPolicy, never, whenDirty, } from "./policy.ts";
+export { useReportUnsavedChanges, useUnsavedChanges, } from "./registry.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/unsaved-changes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/unsaved-changes/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EACN,KAAK,UAAU,EACf,gBAAgB,EAChB,KAAK,qBAAqB,EAC1B,aAAa,GACb,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACN,KAAK,gBAAgB,EACrB,KAAK,EACL,SAAS,GACT,MAAM,aAAa,CAAC;AACrB,OAAO,EACN,uBAAuB,EACvB,iBAAiB,GACjB,MAAM,eAAe,CAAC"}