@mono-lit/helper 0.0.0-stage → 0.0.2

package/dist/data/theme/presets.json.d.ts

@@ -0,0 +1,140 @@
+declare const _default: {
+  "$comment": [
+    "Source of truth for the colour presets: `one` (the default) and `basecoat` (Basecoat's own neutral palette). `scripts/theme-build.mjs` turns this into",
+    "generated/tokens.css, generated/presets.css and generated/legacy.css (run `pnpm theme:build`).",
+    "",
+    "Token names are Basecoat / shadcn's (camelCased): background, foreground, card, popover,",
+    "primary, secondary, muted, accent, destructive, border, input, ring, chart1-5, sidebar*,",
+    "plus mono's extension roles: success, warning, info, teal, purple, neutral, dark.",
+    "Colours are hex (or rgba() for translucent borders); the generator emits OKLCH.",
+    "",
+    "Missing keys are derived: *Foreground by WCAG contrast (white vs 87% black), card/popover",
+    "from surface, secondary/accent from muted, input from border, sidebar-* from card/primary,",
+    "chart1-5 as a lightness ramp on the primary hue. A missing `dark` block is derived with",
+    "Basecoat's own light->dark deltas and is marked for review in ui/color.md; `\"dark\": false` means the",
+    "preset has NO dark mode — under html.dark it keeps its light values (and light mode tokens).",
+    "",
+    "`legacy` holds the preset's pre-Basecoat `--theme-*` declarations VERBATIM. They ship in",
+    "generated/legacy.css until 3.0 so un-ported components and consumer CSS render exactly as",
+    "before. Do not edit them; they are history."
+  ],
+  "one": {
+    "displayName": "ONE",
+    "$comment": "EJI ONE design system v1.0 — light only: the guide defines no dark palette, so `dark: false` keeps ONE light under html.dark. See the legacy block's history in git for the WCAG notes.",
+    "light": {
+      "background": "#f4f6fb",
+      "foreground": "#1f2937",
+      "card": "#ffffff",
+      "muted": "#f7f8fc",
+      "mutedForeground": "#6b7280",
+      "border": "#e4e7ef",
+      "ring": "#1f2664",
+      "primary": "#1f2664",
+      "primaryForeground": "#ffffff",
+      "destructive": "#dc2626",
+      "success": "#15803d",
+      "warning": "#b45309",
+      "warningForeground": "#ffffff",
+      "info": "#375ba3",
+      "teal": "#0f7b6c",
+      "purple": "#1d3184",
+      "neutral": "#64748b",
+      "neutralForeground": "#ffffff",
+      "dark": "#0f172a",
+      "input": "#d7dbe5",
+      "accent": "#f0f3fd",
+      "chart1": "#1f2664",
+      "chart2": "#7c93d6",
+      "chart3": "#e0a030",
+      "chart4": "#e4e7ef"
+    },
+    "dark": false,
+    "legacy": {
+      "--theme-primary": "#1f2664",
+      "--theme-secondary": "#375ba3",
+      "--theme-accent": "#1f2664",
+      "--theme-background": "#f4f6fb",
+      "--theme-text": "#1f2937",
+      "--theme-border": "#e4e7ef",
+      "--theme-success": "#15803d",
+      "--theme-danger": "#dc2626",
+      "--theme-warning": "#b45309",
+      "--theme-info": "#375ba3",
+      "--theme-teal": "#0f7b6c",
+      "--theme-purple": "#1d3184",
+      "--theme-neutral": "#64748b",
+      "--theme-dark": "#0f172a",
+      "--theme-surface": "#ffffff",
+      "--theme-surface-soft": "#f7f8fc",
+      "--theme-primary-rgb": "31, 38, 100",
+      "--theme-secondary-rgb": "55, 91, 163",
+      "--theme-accent-rgb": "31, 38, 100",
+      "--theme-background-rgb": "244, 246, 251",
+      "--theme-text-rgb": "31, 41, 55",
+      "--theme-border-rgb": "228, 231, 239",
+      "--theme-success-rgb": "21, 128, 61",
+      "--theme-danger-rgb": "220, 38, 38",
+      "--theme-warning-rgb": "180, 83, 9",
+      "--theme-info-rgb": "55, 91, 163",
+      "--theme-teal-rgb": "15, 123, 108",
+      "--theme-purple-rgb": "29, 49, 132",
+      "--theme-neutral-rgb": "100, 116, 139",
+      "--theme-dark-rgb": "15, 23, 42",
+      "--theme-primary-light": "#3f5cc4",
+      "--theme-primary-dark": "#171d52",
+      "--theme-primary-contrast": "#ffffff",
+      "--theme-secondary-light": "#7288dd",
+      "--theme-secondary-dark": "#1d3184",
+      "--theme-secondary-contrast": "#ffffff",
+      "--theme-text-primary": "#1f2937",
+      "--theme-text-secondary": "#6b7280",
+      "--theme-text-disabled": "#8695ac",
+      "--theme-placeholder": "#68768c",
+      "--theme-background-default": "#f4f6fb",
+      "--theme-divider": "#e4e7ef",
+      "--theme-action-hover": "rgba(15, 23, 42, 0.04)",
+      "--theme-action-selected": "rgba(var(--theme-primary-rgb), 0.06)",
+      "--theme-success-dark": "#166534",
+      "--theme-danger-dark": "#b91c1c",
+      "--theme-warning-dark": "#92400e",
+      "--theme-warning-contrast": "#ffffff",
+      "--theme-teal-contrast": "#ffffff",
+      "--theme-neutral-contrast": "#ffffff",
+      "--theme-pillar-commercial": "#152568",
+      "--theme-pillar-operasional": "#2a44a8",
+      "--theme-pillar-fat": "#0f7b6c",
+      "--theme-pillar-budgeting": "#b7791f",
+      "--theme-pillar-distributor": "#1d3184"
+    }
+  },
+  "basecoat": {
+    "displayName": "Basecoat (neutral)",
+    "$comment": "Basecoat's own :root/.dark values, read VERBATIM from vendor/basecoat/base/base.css at build time; only the extension roles are authored here.",
+    "vendor": true,
+    "light": {
+      "success": "#16a34a",
+      "warning": "#ca8a04",
+      "warningForeground": "rgba(0, 0, 0, 0.87)",
+      "info": "#2563eb",
+      "teal": "#0d9488",
+      "purple": "#7c3aed",
+      "neutral": "#737373",
+      "dark": "#171717"
+    },
+    "dark": {
+      "success": "#4ade80",
+      "warning": "#facc15",
+      "info": "#60a5fa",
+      "teal": "#2dd4bf",
+      "purple": "#a78bfa",
+      "neutral": "#808080",
+      "neutralForeground": "#ffffff",
+      "dark": "#d4d4d4",
+      "darkForeground": "#171717"
+    },
+    "legacy": {}
+  }
+}
+;
+
+export default _default;

package/dist/data-source-controller-B_rgHCjw.js

@@ -0,0 +1,241 @@
+import { n as describeError, o as isCanceled } from "./normalize-error-Gcgmgh5i.js";
+//#region src/composables/data-source-controller.ts
+/**
+* Encapsulates the generic DataSource + incremental-loading logic shared by
+* `mono-select`, `mono-tag-input`, etc. The host owns the rendering and any
+* scroll/height ergonomics; this controller owns binding, event wiring, page
+* accumulation, and array-mode chunking.
+*
+* Every state mutation calls `host.requestUpdate()` so the host re-renders.
+*/
+var DataSourceController = class {
+	constructor(host, opts) {
+		this._dsItems = [];
+		this._dsLoading = false;
+		this._loadingMore = false;
+		this._isLastPage = false;
+		this._error = null;
+		this._hasLoaded = false;
+		this._retrying = false;
+		this._internalLoad = false;
+		this._bound = null;
+		this._onChanged = () => {
+			if (this._internalLoad) return;
+			this._markLoaded();
+			if (this.opts.getLoadMoreMode()) {
+				const ds = this._bound;
+				this._dsItems = ds ? [...ds.items?.() ?? []] : [];
+				this._isLastPage = ds?.isLastPage?.() ?? false;
+				this._dsLoading = ds?.isLoading?.() ?? false;
+				this._changed();
+				return;
+			}
+			this._sync();
+		};
+		this._onLoadingChanged = () => {
+			this._dsLoading = this._bound?.isLoading?.() ?? false;
+			this._changed();
+		};
+		this._onLoadError = (err) => {
+			this._dsLoading = this._bound?.isLoading?.() ?? false;
+			this.setError(err ?? /* @__PURE__ */ new Error("Request failed"));
+		};
+		this.host = host;
+		this.opts = opts;
+		this._visibleCount = opts.getPageSize();
+		host.addController(this);
+	}
+	hostConnected() {
+		const ds = this.opts.getDataSource();
+		if (ds && this._bound !== ds) this.bind(ds);
+	}
+	hostDisconnected() {
+		this._detach();
+	}
+	/** Attach/detach listeners for a (possibly new) DataSource and seed state. */
+	bind(ds) {
+		if (this._bound === ds) return;
+		this._detach();
+		this._bound = ds;
+		this._error = null;
+		this._retrying = false;
+		this._hasLoaded = !!ds && (ds.items?.() ?? []).length > 0;
+		if (!ds) {
+			this._dsItems = [];
+			this._dsLoading = false;
+			this._isLastPage = false;
+			this._changed();
+			return;
+		}
+		ds.on("changed", this._onChanged);
+		ds.on("loadingChanged", this._onLoadingChanged);
+		ds.on("loadError", this._onLoadError);
+		this._sync();
+		this.maybeImmediateLoad();
+	}
+	maybeImmediateLoad() {
+		const ds = this._bound;
+		if (!ds || !this.opts.getImmediate()) return;
+		const hasItems = (ds.items?.() ?? []).length > 0;
+		const loading = ds.isLoading?.() ?? false;
+		if (hasItems || loading) return;
+		this._loadFirstPage();
+	}
+	/** Call when the load-more mode changes; refreshes paging assumptions. */
+	onLoadMoreModeChange() {
+		if (!this.opts.getLoadMoreMode()) return;
+		this._bound?.paginate?.(true);
+		this._isLastPage = this._bound?.isLastPage?.() ?? false;
+		this._changed();
+	}
+	/** Reset array-mode paging to the first chunk. */
+	resetVisible() {
+		this._visibleCount = this.opts.getPageSize();
+		this._changed();
+	}
+	/** Load/reveal the next page and append it to the accumulated list. */
+	async loadMore() {
+		if (!this.opts.getLoadMoreMode() || this.atLastPage) return;
+		if (this.isArrayLoadMore) {
+			this._visibleCount = Math.min(this.opts.getItems().length, this._visibleCount + this.opts.getPageSize());
+			this._changed();
+			return;
+		}
+		const ds = this._bound;
+		if (!ds || this._loadingMore || this._dsLoading) return;
+		if (typeof ds.pageIndex !== "function") return;
+		const current = ds.pageIndex() ?? 0;
+		this._internalLoad = true;
+		this._loadingMore = true;
+		this._changed();
+		try {
+			ds.paginate?.(true);
+			ds.pageIndex(current + 1);
+			await Promise.resolve(ds.load());
+			this._dsItems = [...this._dsItems, ...ds.items?.() ?? []];
+			this._isLastPage = ds.isLastPage?.() ?? false;
+			this._error = null;
+		} catch (err) {
+			ds.pageIndex(current);
+			this.setError(err);
+		} finally {
+			this._loadingMore = false;
+			this._internalLoad = false;
+			this._changed();
+		}
+	}
+	/**
+	* Re-run the request after a failure. Reloads the source as it stands, so a
+	* failed search is retried with the same query. While it runs the field is
+	* {@link busy} again.
+	*
+	* `load` replaces the plain `ds.load()` — a host whose failed request was a
+	* search passes one that clears the query on the source and reloads.
+	*/
+	async retry(load) {
+		if (!this._bound) return;
+		this._error = null;
+		this._retrying = true;
+		this._changed();
+		try {
+			await this._loadFirstPage(load);
+		} finally {
+			this._retrying = false;
+			this._changed();
+		}
+	}
+	/**
+	* Record a failure from a request the host drove itself (e.g. a server
+	* select-all drain). Cancelled loads are ignored.
+	*/
+	setError(raw) {
+		if (isCanceled(raw)) return;
+		this._error = describeError(raw);
+		this._changed();
+	}
+	/** Raw source array: accumulated DataSource items, or the plain `items`. */
+	get sourceItems() {
+		return this._bound ? this._dsItems : this.opts.getItems();
+	}
+	/** Rows to actually render (array-mode reveals a slice; else everything). */
+	get visibleItems() {
+		if (this.isArrayLoadMore) return this.opts.getItems().slice(0, this._visibleCount);
+		return this.sourceItems;
+	}
+	get loading() {
+		return this._dsLoading;
+	}
+	get loadingMore() {
+		return this._loadingMore;
+	}
+	/**
+	* The field must be locked: the FIRST load (or a retry) is in flight. A
+	* search / filter reload after the source has answered once does not count —
+	* the person is typing into the field and it must stay usable.
+	*/
+	get busy() {
+		return !!this._bound && (this._dsLoading && !this._hasLoaded || this._retrying);
+	}
+	/** The last load failure, described for a person; null once a load succeeds. */
+	get error() {
+		return this._error;
+	}
+	/** load-more is driving a plain `items` array (no DataSource bound). */
+	get isArrayLoadMore() {
+		return !this.opts.getDataSource() && !!this.opts.getLoadMoreMode();
+	}
+	/** Whether there's nothing left to load/reveal. */
+	get atLastPage() {
+		if (this.isArrayLoadMore) return this._visibleCount >= this.opts.getItems().length;
+		return this._isLastPage;
+	}
+	/** A load answered: the source is usable and any earlier failure is over. */
+	_markLoaded() {
+		this._hasLoaded = true;
+		this._error = null;
+	}
+	_sync() {
+		const ds = this._bound;
+		this._dsItems = ds ? [...ds.items?.() ?? []] : [];
+		this._dsLoading = ds?.isLoading?.() ?? false;
+		this._isLastPage = ds?.isLastPage?.() ?? false;
+		this._changed();
+	}
+	/** Load the first page, replacing the accumulated list. */
+	async _loadFirstPage(load) {
+		const ds = this._bound;
+		if (!ds) return;
+		this._internalLoad = true;
+		this._dsLoading = true;
+		this._changed();
+		try {
+			if (this.opts.getLoadMoreMode()) {
+				ds.paginate?.(true);
+				ds.pageIndex?.(0);
+			}
+			await Promise.resolve(load ? load() : ds.load());
+			this._dsItems = [...ds.items?.() ?? []];
+			this._isLastPage = ds.isLastPage?.() ?? false;
+			this._markLoaded();
+		} catch (err) {
+			this.setError(err);
+		} finally {
+			this._dsLoading = ds.isLoading?.() ?? false;
+			this._internalLoad = false;
+			this._changed();
+		}
+	}
+	_detach() {
+		const ds = this._bound;
+		if (!ds) return;
+		ds.off("changed", this._onChanged);
+		ds.off("loadingChanged", this._onLoadingChanged);
+		ds.off("loadError", this._onLoadError);
+		this._bound = null;
+	}
+	_changed() {
+		this.host.requestUpdate();
+	}
+};
+//#endregion
+export { DataSourceController as t };

package/dist/data-source-controller-Dbb4fd8I.js

@@ -0,0 +1,241 @@
+import { a as describeError, l as isCanceled } from "./reactive-Di3mTMnV.js";
+//#region src/composables/data-source-controller.ts
+/**
+* Encapsulates the generic DataSource + incremental-loading logic shared by
+* `mono-select`, `mono-tag-input`, etc. The host owns the rendering and any
+* scroll/height ergonomics; this controller owns binding, event wiring, page
+* accumulation, and array-mode chunking.
+*
+* Every state mutation calls `host.requestUpdate()` so the host re-renders.
+*/
+var DataSourceController = class {
+	constructor(host, opts) {
+		this._dsItems = [];
+		this._dsLoading = false;
+		this._loadingMore = false;
+		this._isLastPage = false;
+		this._error = null;
+		this._hasLoaded = false;
+		this._retrying = false;
+		this._internalLoad = false;
+		this._bound = null;
+		this._onChanged = () => {
+			if (this._internalLoad) return;
+			this._markLoaded();
+			if (this.opts.getLoadMoreMode()) {
+				const ds = this._bound;
+				this._dsItems = ds ? [...ds.items?.() ?? []] : [];
+				this._isLastPage = ds?.isLastPage?.() ?? false;
+				this._dsLoading = ds?.isLoading?.() ?? false;
+				this._changed();
+				return;
+			}
+			this._sync();
+		};
+		this._onLoadingChanged = () => {
+			this._dsLoading = this._bound?.isLoading?.() ?? false;
+			this._changed();
+		};
+		this._onLoadError = (err) => {
+			this._dsLoading = this._bound?.isLoading?.() ?? false;
+			this.setError(err ?? /* @__PURE__ */ new Error("Request failed"));
+		};
+		this.host = host;
+		this.opts = opts;
+		this._visibleCount = opts.getPageSize();
+		host.addController(this);
+	}
+	hostConnected() {
+		const ds = this.opts.getDataSource();
+		if (ds && this._bound !== ds) this.bind(ds);
+	}
+	hostDisconnected() {
+		this._detach();
+	}
+	/** Attach/detach listeners for a (possibly new) DataSource and seed state. */
+	bind(ds) {
+		if (this._bound === ds) return;
+		this._detach();
+		this._bound = ds;
+		this._error = null;
+		this._retrying = false;
+		this._hasLoaded = !!ds && (ds.items?.() ?? []).length > 0;
+		if (!ds) {
+			this._dsItems = [];
+			this._dsLoading = false;
+			this._isLastPage = false;
+			this._changed();
+			return;
+		}
+		ds.on("changed", this._onChanged);
+		ds.on("loadingChanged", this._onLoadingChanged);
+		ds.on("loadError", this._onLoadError);
+		this._sync();
+		this.maybeImmediateLoad();
+	}
+	maybeImmediateLoad() {
+		const ds = this._bound;
+		if (!ds || !this.opts.getImmediate()) return;
+		const hasItems = (ds.items?.() ?? []).length > 0;
+		const loading = ds.isLoading?.() ?? false;
+		if (hasItems || loading) return;
+		this._loadFirstPage();
+	}
+	/** Call when the load-more mode changes; refreshes paging assumptions. */
+	onLoadMoreModeChange() {
+		if (!this.opts.getLoadMoreMode()) return;
+		this._bound?.paginate?.(true);
+		this._isLastPage = this._bound?.isLastPage?.() ?? false;
+		this._changed();
+	}
+	/** Reset array-mode paging to the first chunk. */
+	resetVisible() {
+		this._visibleCount = this.opts.getPageSize();
+		this._changed();
+	}
+	/** Load/reveal the next page and append it to the accumulated list. */
+	async loadMore() {
+		if (!this.opts.getLoadMoreMode() || this.atLastPage) return;
+		if (this.isArrayLoadMore) {
+			this._visibleCount = Math.min(this.opts.getItems().length, this._visibleCount + this.opts.getPageSize());
+			this._changed();
+			return;
+		}
+		const ds = this._bound;
+		if (!ds || this._loadingMore || this._dsLoading) return;
+		if (typeof ds.pageIndex !== "function") return;
+		const current = ds.pageIndex() ?? 0;
+		this._internalLoad = true;
+		this._loadingMore = true;
+		this._changed();
+		try {
+			ds.paginate?.(true);
+			ds.pageIndex(current + 1);
+			await Promise.resolve(ds.load());
+			this._dsItems = [...this._dsItems, ...ds.items?.() ?? []];
+			this._isLastPage = ds.isLastPage?.() ?? false;
+			this._error = null;
+		} catch (err) {
+			ds.pageIndex(current);
+			this.setError(err);
+		} finally {
+			this._loadingMore = false;
+			this._internalLoad = false;
+			this._changed();
+		}
+	}
+	/**
+	* Re-run the request after a failure. Reloads the source as it stands, so a
+	* failed search is retried with the same query. While it runs the field is
+	* {@link busy} again.
+	*
+	* `load` replaces the plain `ds.load()` — a host whose failed request was a
+	* search passes one that clears the query on the source and reloads.
+	*/
+	async retry(load) {
+		if (!this._bound) return;
+		this._error = null;
+		this._retrying = true;
+		this._changed();
+		try {
+			await this._loadFirstPage(load);
+		} finally {
+			this._retrying = false;
+			this._changed();
+		}
+	}
+	/**
+	* Record a failure from a request the host drove itself (e.g. a server
+	* select-all drain). Cancelled loads are ignored.
+	*/
+	setError(raw) {
+		if (isCanceled(raw)) return;
+		this._error = describeError(raw);
+		this._changed();
+	}
+	/** Raw source array: accumulated DataSource items, or the plain `items`. */
+	get sourceItems() {
+		return this._bound ? this._dsItems : this.opts.getItems();
+	}
+	/** Rows to actually render (array-mode reveals a slice; else everything). */
+	get visibleItems() {
+		if (this.isArrayLoadMore) return this.opts.getItems().slice(0, this._visibleCount);
+		return this.sourceItems;
+	}
+	get loading() {
+		return this._dsLoading;
+	}
+	get loadingMore() {
+		return this._loadingMore;
+	}
+	/**
+	* The field must be locked: the FIRST load (or a retry) is in flight. A
+	* search / filter reload after the source has answered once does not count —
+	* the person is typing into the field and it must stay usable.
+	*/
+	get busy() {
+		return !!this._bound && (this._dsLoading && !this._hasLoaded || this._retrying);
+	}
+	/** The last load failure, described for a person; null once a load succeeds. */
+	get error() {
+		return this._error;
+	}
+	/** load-more is driving a plain `items` array (no DataSource bound). */
+	get isArrayLoadMore() {
+		return !this.opts.getDataSource() && !!this.opts.getLoadMoreMode();
+	}
+	/** Whether there's nothing left to load/reveal. */
+	get atLastPage() {
+		if (this.isArrayLoadMore) return this._visibleCount >= this.opts.getItems().length;
+		return this._isLastPage;
+	}
+	/** A load answered: the source is usable and any earlier failure is over. */
+	_markLoaded() {
+		this._hasLoaded = true;
+		this._error = null;
+	}
+	_sync() {
+		const ds = this._bound;
+		this._dsItems = ds ? [...ds.items?.() ?? []] : [];
+		this._dsLoading = ds?.isLoading?.() ?? false;
+		this._isLastPage = ds?.isLastPage?.() ?? false;
+		this._changed();
+	}
+	/** Load the first page, replacing the accumulated list. */
+	async _loadFirstPage(load) {
+		const ds = this._bound;
+		if (!ds) return;
+		this._internalLoad = true;
+		this._dsLoading = true;
+		this._changed();
+		try {
+			if (this.opts.getLoadMoreMode()) {
+				ds.paginate?.(true);
+				ds.pageIndex?.(0);
+			}
+			await Promise.resolve(load ? load() : ds.load());
+			this._dsItems = [...ds.items?.() ?? []];
+			this._isLastPage = ds.isLastPage?.() ?? false;
+			this._markLoaded();
+		} catch (err) {
+			this.setError(err);
+		} finally {
+			this._dsLoading = ds.isLoading?.() ?? false;
+			this._internalLoad = false;
+			this._changed();
+		}
+	}
+	_detach() {
+		const ds = this._bound;
+		if (!ds) return;
+		ds.off("changed", this._onChanged);
+		ds.off("loadingChanged", this._onLoadingChanged);
+		ds.off("loadError", this._onLoadError);
+		this._bound = null;
+	}
+	_changed() {
+		this.host.requestUpdate();
+	}
+};
+//#endregion
+export { DataSourceController as t };