@mono-lit/helper 0.0.0-stage → 0.0.1

package/dist/mono-ui-CPV7rrdo.js

@@ -0,0 +1,358 @@
+//#region src/composables/mono-skeleton.ts
+/**
+* "Is there a DOM to render into?" — deliberately NOT lit's `isServer`. That flag is a
+* build-time constant of lit's node entry, so it is `true` wherever Node's export
+* conditions pick that build — including a jsdom test run, where this feature must work.
+* On a real server (`@lit-labs/ssr` + its dom shim) there is a `customElements` but no
+* `document`, which is exactly the distinction that matters here.
+*/
+var hasDom = typeof document !== "undefined" && typeof customElements !== "undefined";
+/**
+* ONE store per realm, on `globalThis` (same reasoning as `mono-ui.ts`): the light and
+* shadow builds are separate bundles and a pnpm peer fork can install two copies of the
+* package, yet all of them must agree on "active" and on the defaults.
+*/
+var STATE_KEY$1 = Symbol.for("mono-helper.skeleton");
+var state$1 = globalThis[STATE_KEY$1] ??= {
+	active: false,
+	disabled: false,
+	ssr: null,
+	ssrSniffed: null,
+	defaults: {},
+	watching: false,
+	createdBeforeActive: 0,
+	createdBeforeActiveTags: [],
+	warnedLate: false,
+	waiting: /* @__PURE__ */ new Set(),
+	holders: /* @__PURE__ */ new Set()
+};
+var PHANTOM_TAG = "phantom-ui";
+var DEFAULT_MAX_WAIT = 15e3;
+/** Per-element slots the Cores can read without depending on the mixin's class shape. */
+var TAG_DEFAULT = Symbol.for("mono-helper.skeleton.tagDefault");
+var PENDING_ACTIVE = Symbol.for("mono-helper.skeleton.active");
+var PENDING_GRACE = Symbol.for("mono-helper.skeleton.grace");
+var PENDING_PHANTOM = Symbol.for("mono-helper.skeleton.phantom");
+/** Where `applyMonoUIDefaults` parks a tag's `pending` default (not assigned to the prop). */
+var MONO_PENDING_TAG_DEFAULT = TAG_DEFAULT;
+function isActive() {
+	return state$1.active && !state$1.disabled;
+}
+/**
+* Start following the registry. Idempotent; a no-op on the server. Called by the mono
+* `customElement` decorator, so the watcher exists before any element constructs.
+*/
+function watchSkeletonActivation() {
+	if (!hasDom || state$1.watching) return;
+	state$1.watching = true;
+	const activate = () => {
+		state$1.active = true;
+		if (state$1.createdBeforeActive > 0 && !state$1.warnedLate) {
+			state$1.warnedLate = true;
+			const tags = state$1.createdBeforeActiveTags.slice(0, 5).join(", ");
+			console.warn(`[mono-skeleton] phantom-ui was defined after ${state$1.createdBeforeActive} mono element(s) had rendered (${tags}); their first paint had no skeleton. Load "@aejkatappaja/phantom-ui" before the app mounts (main.ts import, or let @mono-lit/helper/nuxt do it).`);
+		}
+	};
+	if (customElements.get(PHANTOM_TAG)) {
+		activate();
+		return;
+	}
+	customElements.whenDefined(PHANTOM_TAG).then(activate, () => {});
+}
+/**
+* Is this an SSR app? The explicit flag (`createMonoUI({ skeleton: { ssr } })`, which the
+* Nuxt module sets from `nuxt.options.ssr`) wins; otherwise the Nuxt payload marker is
+* sniffed once (`<script id="__NUXT_DATA__" data-ssr="true">`).
+*/
+function isMonoSsrApp() {
+	if (state$1.ssr !== null) return state$1.ssr;
+	if (state$1.ssrSniffed === null) state$1.ssrSniffed = hasDom && document.getElementById("__NUXT_DATA__")?.getAttribute("data-ssr") === "true";
+	return state$1.ssrSniffed;
+}
+/** Set the global defaults (`createMonoUI`'s `skeleton` key routes here). `false` disables the skeleton. */
+function setMonoSkeletonDefaults(defaults) {
+	if (defaults === false) {
+		state$1.disabled = true;
+		return;
+	}
+	state$1.disabled = false;
+	const { ssr, ...rest } = defaults ?? {};
+	state$1.ssr = typeof ssr === "boolean" ? ssr : null;
+	state$1.defaults = { ...rest };
+}
+function getMonoSkeletonStatus() {
+	return {
+		active: isActive(),
+		ssr: state$1.ssr,
+		createdBeforeActive: state$1.createdBeforeActive,
+		createdBeforeActiveTags: [...state$1.createdBeforeActiveTags]
+	};
+}
+/** Drop defaults / flag / counters (tests). `active` stays — an element cannot be undefined. */
+function resetMonoSkeleton() {
+	state$1.disabled = false;
+	state$1.ssr = null;
+	state$1.ssrSniffed = null;
+	state$1.defaults = {};
+	state$1.createdBeforeActive = 0;
+	state$1.createdBeforeActiveTags = [];
+	state$1.warnedLate = false;
+	state$1.waiting.clear();
+	state$1.holders.clear();
+}
+var PHANTOM_KEYS = [
+	"animation",
+	"mode",
+	"shimmerDirection",
+	"shimmerColor",
+	"backgroundColor",
+	"duration",
+	"stagger",
+	"reveal",
+	"count",
+	"countGap",
+	"fallbackRadius",
+	"loadingLabel",
+	"pierceShadow",
+	"debug"
+];
+var kebab = (name) => name.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+function isPendingObject(value) {
+	return !!value && typeof value === "object";
+}
+/** The boolean a `pending` value carries (`undefined` = auto). */
+function activeOf(value) {
+	if (typeof value === "boolean") return value;
+	if (isPendingObject(value)) return typeof value.active === "boolean" ? value.active : void 0;
+}
+/** Only the phantom options of a value (an object), as a plain record. */
+function phantomOf(value) {
+	const out = {};
+	if (!isPendingObject(value)) return out;
+	for (const key of PHANTOM_KEYS) {
+		const v = value[key];
+		if (v !== void 0) out[key] = v;
+	}
+	return out;
+}
+function shallowEqual(a, b) {
+	const ka = Object.keys(a);
+	const kb = Object.keys(b);
+	if (ka.length !== kb.length) return false;
+	for (const k of ka) if (a[k] !== b[k]) return false;
+	return true;
+}
+/** `hasChanged` for the property: booleans by value, objects shallowly. */
+function pendingChanged(next, prev) {
+	if (isPendingObject(next) && isPendingObject(prev)) return !shallowEqual(next, prev);
+	return next !== prev;
+}
+/**
+* The attribute converter. The attribute form is boolean-only: `pending`,
+* `pending="true"` → true; `pending="false"` → false; absent or `pending="auto"` → auto.
+* A real boolean is accepted too (what a server renderer hands over).
+*/
+var pendingConverter = {
+	fromAttribute(value) {
+		if (value === null || value === void 0) return void 0;
+		if (typeof value === "boolean") return value;
+		const s = String(value).trim().toLowerCase();
+		if (s === "auto") return void 0;
+		return s === "" || s === "true";
+	},
+	toAttribute() {
+		return null;
+	}
+};
+/**
+* Register the `pending` property on a registered element class. Called by the mono
+* `customElement` decorator BEFORE `customElements.define`, so the attribute lands in
+* Lit's attribute map when `observedAttributes` is read.
+*/
+function registerPendingProperty(cls) {
+	cls.createProperty("pending", {
+		attribute: "pending",
+		reflect: false,
+		converter: pendingConverter,
+		hasChanged: pendingChanged
+	});
+}
+/** Whether `pending` currently resolves to true for `el` (set before each render). */
+function monoPendingActive(el) {
+	return !!el[PENDING_ACTIVE];
+}
+/**
+* True once one macrotask has passed since the element first resolved pending — lets a
+* `'data'` Core say "no controller / source after one tick → nothing to wait for" without
+* releasing before a binding made in the consumer's `onMounted`.
+*/
+function monoPendingGrace(el) {
+	return !!el[PENDING_GRACE];
+}
+/**
+* The phantom options resolved for `el` while pending (element object over tag default
+* over global default), camelCase keys. Empty while not pending. For `'custom'` Cores
+* that render their own `<phantom-ui>` and want a value in the template (e.g. `count`).
+*/
+function monoPhantomOptions(el) {
+	return el[PENDING_PHANTOM] ?? {};
+}
+/**
+* Apply the resolved phantom options to a `<phantom-ui>` element as attributes (used by
+* the mixin for its wrapper, and by `'custom'` Cores for the phantom they render).
+* Diffed against what was last applied to that element, so unchanged values cost nothing.
+*/
+function monoApplyPhantomOptions(el, target) {
+	if (!target) return;
+	const next = el[PENDING_PHANTOM] ?? {};
+	const store = target;
+	const prev = store[PENDING_PHANTOM] ?? {};
+	if (shallowEqual(next, prev)) return;
+	for (const key of new Set([...Object.keys(prev), ...Object.keys(next)])) {
+		const value = next[key];
+		const attr = kebab(key);
+		if (value === void 0 || value === null || value === false) target.removeAttribute(attr);
+		else if (value === true) target.setAttribute(attr, "");
+		else target.setAttribute(attr, String(value));
+	}
+	store[PENDING_PHANTOM] = { ...next };
+}
+/** @internal */
+var monoSkeletonInternals = {
+	hasDom,
+	isActive,
+	state: state$1,
+	slots: {
+		TAG_DEFAULT,
+		PENDING_ACTIVE,
+		PENDING_GRACE,
+		PENDING_PHANTOM
+	},
+	activeOf,
+	phantomOf,
+	PHANTOM_TAG,
+	DEFAULT_MAX_WAIT
+};
+/** The `<phantom-ui>` wrapper the skeleton mixin renders around an element's content. */
+function isMonoSkeletonWrapper(node) {
+	return !!node && node.nodeType === 1 && node.localName === PHANTOM_TAG && node.hasAttribute("mono-skeleton");
+}
+/** `Array.from(host.childNodes)` minus the skeleton wrapper. */
+function monoHostChildNodes(host) {
+	return Array.from(host.childNodes).filter((n) => !isMonoSkeletonWrapper(n));
+}
+/** `Array.from(host.children)` minus the skeleton wrapper. */
+function monoHostChildren(host) {
+	return Array.from(host.children).filter((n) => !isMonoSkeletonWrapper(n));
+}
+//#endregion
+//#region src/composables/mono-ui.ts
+var STATE_KEY = Symbol.for("mono-helper.ui");
+var state = globalThis[STATE_KEY] ??= {
+	store: null,
+	createdTotal: 0,
+	createdTags: [],
+	createdBeforeConfig: 0,
+	createdBeforeConfigTags: [],
+	warned: /* @__PURE__ */ new Set()
+};
+var SHADOW_PREFIX = "mono-shadow-";
+function warnOnce(key, message) {
+	if (state.warned.has(key)) return;
+	state.warned.add(key);
+	console.warn(`[mono-ui] ${message}`);
+}
+var camel = (name) => name.replace(/-([a-z0-9])/g, (_m, c) => c.toUpperCase());
+/** Arrays and plain objects are copied per element, so one element cannot mutate the shared config. */
+function fresh(value) {
+	if (Array.isArray(value)) return [...value];
+	if (value && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) return { ...value };
+	return value;
+}
+/**
+* Set the app-wide default props. Call once, first — usually in `main.ts`:
+*
+* ```ts
+* app.use(createMonoUI({ 'mono-button': { size: 'xs' } }))
+* // or simply
+* createMonoUI({ 'mono-button': { size: 'xs' } })
+* ```
+*
+* A later call replaces the previous config for elements created afterwards.
+*/
+function createMonoUI(config = {}) {
+	const next = {};
+	setMonoSkeletonDefaults(config.skeleton);
+	for (const [tag, props] of Object.entries(config)) {
+		if (tag === "skeleton") continue;
+		if (!/^mono-[a-z0-9-]+$/.test(tag)) {
+			warnOnce(`tag:${tag}`, `"${tag}" is not a mono component tag — expected "mono-<name>". Ignored.`);
+			continue;
+		}
+		if (!props || typeof props !== "object") continue;
+		next[tag] = { ...props };
+	}
+	state.createdBeforeConfig = state.createdTotal;
+	state.createdBeforeConfigTags = [...state.createdTags];
+	if (state.createdTotal > 0 && typeof document !== "undefined") {
+		const tags = state.createdTags.slice(0, 5).join(", ") + (state.createdTags.length > 5 ? ", …" : "");
+		console.warn(`[mono-ui] createMonoUI() ran after ${state.createdTotal} mono element${state.createdTotal === 1 ? " was" : "s were"} created (${tags}); ${state.createdTotal === 1 ? "it keeps its" : "those keep their"} built-in defaults. Call createMonoUI() first in main.ts, before app.mount().`);
+	}
+	state.store = next;
+	return {
+		config: { ...next },
+		install() {}
+	};
+}
+/** The current config, or `null` when `createMonoUI` has not been called. */
+function getMonoUI() {
+	return state.store;
+}
+/** Whether the config is set, and how many elements were created before it was. */
+function getMonoUIStatus() {
+	return {
+		configured: state.store !== null,
+		createdBefore: state.store ? state.createdBeforeConfig : state.createdTotal,
+		createdBeforeTags: state.store ? [...state.createdBeforeConfigTags] : [...state.createdTags]
+	};
+}
+/** Drop the config (tests, or reconfiguring before mount). Elements created afterwards get built-in defaults. */
+function resetMonoUI() {
+	resetMonoSkeleton();
+	state.store = null;
+	state.createdTotal = 0;
+	state.createdTags.length = 0;
+	state.createdBeforeConfig = 0;
+	state.createdBeforeConfigTags = [];
+	state.warned.clear();
+}
+/**
+* Apply the configured defaults to a freshly constructed element. Called by the
+* mono `customElement` decorator at the end of construction — not public API.
+* @internal
+*/
+function applyMonoUIDefaults(el, tag) {
+	state.createdTotal++;
+	if (!state.createdTags.includes(tag)) state.createdTags.push(tag);
+	if (!state.store) return;
+	const base = tag.startsWith(SHADOW_PREFIX) ? `mono-${tag.slice(12)}` : tag;
+	const props = {
+		...state.store[base] ?? {},
+		...base !== tag ? state.store[tag] ?? {} : {}
+	};
+	for (const [key, value] of Object.entries(props)) {
+		if (value === void 0) continue;
+		const prop = camel(key);
+		if (prop === "pending") {
+			el[MONO_PENDING_TAG_DEFAULT] = fresh(value);
+			continue;
+		}
+		if (!(prop in el)) {
+			warnOnce(`prop:${base}:${prop}`, `<${base}> has no prop "${key}". Ignored.`);
+			continue;
+		}
+		el[prop] = fresh(value);
+	}
+}
+//#endregion
+export { watchSkeletonActivation as _, resetMonoUI as a, monoApplyPhantomOptions as c, monoPendingActive as d, monoPendingGrace as f, resetMonoSkeleton as g, registerPendingProperty as h, getMonoUIStatus as i, monoHostChildNodes as l, monoSkeletonInternals as m, createMonoUI as n, getMonoSkeletonStatus as o, monoPhantomOptions as p, getMonoUI as r, isMonoSsrApp as s, applyMonoUIDefaults as t, monoHostChildren as u };

package/dist/notifier-CE4yxMUQ.js

@@ -0,0 +1,88 @@
+/**
+* The coalesced notifier every mono controller uses.
+*
+* Notifications are queued on a microtask and de-duplicated, so several state
+* changes in one tick produce a single callback. That coalescing is not a
+* nicety: a synchronous subscriber that re-renders the consumer's Vue tree would
+* reenter an in-flight patch and corrupt the DOM. When `queueMicrotask` is
+* unavailable (older SSR runtimes) it degrades to a synchronous flush.
+*
+* This was copy-pasted into `monoDataGrid`, `monoDataDropdown`, `monoForm` and
+* `monoChart` — identical logic and, in two of them, identical comments. One
+* implementation means one place to fix if the scheduling ever needs to change.
+*/
+function createNotifier(options = {}) {
+	const subscribers = /* @__PURE__ */ new Set();
+	let queued = false;
+	let chain = 0;
+	let probe;
+	let tripped = false;
+	let pending = false;
+	/** Reported once per notifier: a loop that keeps going re-trips every task, and one line says it. */
+	let reported = false;
+	function armProbe() {
+		if (probe !== void 0 || typeof setTimeout !== "function") return;
+		probe = setTimeout(() => {
+			probe = void 0;
+			chain = 0;
+			if (tripped) {
+				tripped = false;
+				if (pending) {
+					pending = false;
+					flush();
+				}
+			}
+		}, 0);
+	}
+	function trip() {
+		tripped = true;
+		pending = true;
+		if (reported) return;
+		reported = true;
+		const extra = options.detail ? options.detail() : "";
+		console.error(`[mono] ${options.name ?? "controller"} notified ${chain} times without yielding to the event loop — a feedback loop (something writing back into it on every change, e.g. a watch() on its state ref that calls setProp / setValue). Notifications are paused until the next task.` + (extra ? ` ${extra}` : ""));
+	}
+	function flush() {
+		if (typeof setTimeout === "function") {
+			chain++;
+			armProbe();
+		}
+		if (chain > 200) {
+			if (!tripped) trip();
+			pending = true;
+			return;
+		}
+		options.onFlush?.();
+		subscribers.forEach((cb) => cb());
+	}
+	return {
+		subscribe(cb) {
+			subscribers.add(cb);
+			return () => subscribers.delete(cb);
+		},
+		notify() {
+			if (typeof queueMicrotask !== "function") {
+				flush();
+				return;
+			}
+			if (tripped) {
+				pending = true;
+				return;
+			}
+			if (queued) return;
+			queued = true;
+			queueMicrotask(() => {
+				queued = false;
+				flush();
+			});
+		},
+		clear() {
+			subscribers.clear();
+		},
+		get size() {
+			return subscribers.size;
+		}
+	};
+}
+//#endregion
+export { createNotifier as t };

package/dist/nuxt.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/nuxt.js

@@ -0,0 +1,130 @@
+import { t as monoSsr } from "./vite-C5iUK7so.js";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { addPluginTemplate, addVitePlugin, defineNuxtModule, extendViteConfig, hasNuxtModule, installModule, tryResolveModule, useLogger } from "@nuxt/kit";
+//#region src/nuxt/index.ts
+/** The optional peer the automatic skeleton (`pending`) renders with. */
+var PHANTOM_UI = "@aejkatappaja/phantom-ui";
+/** One lit instance, shared with the shadow build and @lit-labs/ssr. */
+var LIT_DEDUPE = [
+	"lit",
+	"lit-html",
+	"lit-element",
+	"@lit/reactive-element"
+];
+/** Reached only from federated routes, so Vite won't find it in its entry scan. */
+var DEFAULT_OPTIMIZE_INCLUDE = ["@mono-lit/devextreme"];
+var monoHelperModule = defineNuxtModule({
+	meta: {
+		name: "@mono-lit/helper",
+		configKey: "mono"
+	},
+	async setup(options, nuxt) {
+		const helper = options.helper ?? {};
+		const prefix = helper.prefix ?? "mono-";
+		const logger = useLogger("@mono-lit/helper");
+		const ssrApp = nuxt.options.ssr !== false;
+		const clientOnlyWrap = helper.clientOnly ?? ssrApp;
+		const appAnchor = pathToFileURL(join(nuxt.options.rootDir, "index.js")).href;
+		const phantom = helper.skeleton === false ? null : await tryResolveModule(PHANTOM_UI, appAnchor);
+		if (!phantom && helper.skeleton !== false) logger.debug(`skeleton: "${PHANTOM_UI}" is not installed in the app — \`pending\` stays a no-op. Install it to turn the automatic skeleton on.`);
+		let litWrapper = false;
+		if (helper.ssr !== false && !ssrApp) logger.debug("ssr:false — skipping nuxt-ssr-lit; shadow builds render client-side as plain custom elements.");
+		else if (helper.ssr !== false) if (hasNuxtModule("nuxt-ssr-lit")) logger.info("nuxt-ssr-lit is configured by the host — using legacy manual SSR wiring (litElementPrefix). Remove that module entry to enable @mono-lit/helper auto-wrap, or set mono.helper.ssr:false to silence.");
+		else try {
+			await installModule(await tryResolveModule("nuxt-ssr-lit", import.meta.url) ?? "nuxt-ssr-lit", { litElementPrefix: [] });
+			litWrapper = true;
+		} catch {
+			logger.info("nuxt-ssr-lit could not be loaded — mono shadow components fall back to client-only. It ships as a @mono-lit/helper dependency, so this usually means a broken or deduped install; try reinstalling, or set mono.helper.ssr:false to silence.");
+		}
+		if (ssrApp || clientOnlyWrap) {
+			for (const plugin of monoSsr({
+				prefix,
+				wrapper: helper.wrapper,
+				ssrStubPrefix: helper.ssrStubPrefix,
+				exclude: helper.exclude,
+				lightWrap: clientOnlyWrap,
+				litWrapper,
+				shadowOverride: helper.shadow
+			})) addVitePlugin(plugin);
+			if (!clientOnlyWrap) logger.debug("mono.helper.clientOnly:false — light <mono-*> are not wrapped in <ClientOnly>; the server stub and the shadow <LitWrapper> wrap stay on.");
+		} else logger.debug("ssr:false — <mono-*> are not wrapped in <ClientOnly> (nothing renders on the server). Set mono.helper.clientOnly:true to force it.");
+		if (helper.css !== false) {
+			nuxt.options.css ||= [];
+			if (!nuxt.options.css.includes("@mono-lit/helper/ui/index.css")) nuxt.options.css.push("@mono-lit/helper/ui/index.css");
+		}
+		if (helper.customElement !== false) {
+			const vue = nuxt.options.vue ||= {};
+			vue.compilerOptions ||= {};
+			const prev = vue.compilerOptions.isCustomElement;
+			vue.compilerOptions.isCustomElement = (tag) => typeof prev === "function" && prev(tag) || tag.startsWith(prefix);
+		}
+		const uiConfig = { ...helper.ui && typeof helper.ui === "object" ? helper.ui : {} };
+		if (phantom) uiConfig.skeleton = {
+			ssr: ssrApp,
+			...typeof helper.skeleton === "object" ? helper.skeleton : {}
+		};
+		if (Object.keys(uiConfig).length) addPluginTemplate({
+			filename: "mono-ui.mjs",
+			order: -50,
+			getContents: () => [
+				"import { createMonoUI } from '@mono-lit/helper'",
+				"export default defineNuxtPlugin({",
+				"  name: '@mono-lit/helper:ui',",
+				"  enforce: 'pre',",
+				"  setup() {",
+				`    createMonoUI(${JSON.stringify(uiConfig)})`,
+				"  },",
+				"})"
+			].join("\n")
+		});
+		if (phantom) addPluginTemplate({
+			filename: "mono-skeleton.client.mjs",
+			mode: "client",
+			getContents: () => [
+				"export default defineNuxtPlugin({",
+				"  name: '@mono-lit/helper:skeleton',",
+				"  async setup() {",
+				`    await import('${PHANTOM_UI}')`,
+				"  },",
+				"})"
+			].join("\n")
+		});
+		const tooltip = helper.tooltip === true ? {} : helper.tooltip;
+		if (tooltip && typeof tooltip === "object") addPluginTemplate({
+			filename: "mono-tooltip.client.mjs",
+			mode: "client",
+			getContents: () => [
+				"import { createMonoTooltip } from '@mono-lit/helper/tooltip'",
+				"export default defineNuxtPlugin({",
+				"  name: '@mono-lit/helper:tooltip',",
+				"  setup() {",
+				`    createMonoTooltip(${JSON.stringify(tooltip)})`,
+				"  },",
+				"})"
+			].join("\n")
+		});
+		const dedupe = helper.dedupe === false ? [] : helper.dedupe ?? LIT_DEDUPE;
+		const wanted = [...helper.optimizeInclude === false ? [] : helper.optimizeInclude ?? DEFAULT_OPTIMIZE_INCLUDE, ...tooltip ? ["@floating-ui/dom"] : []];
+		const exclude = phantom ? [PHANTOM_UI] : [];
+		const include = [];
+		for (const id of wanted) if (await tryResolveModule(id, appAnchor)) include.push(id);
+		else logger.debug(`optimizeDeps: skipping "${id}" — not resolvable from the app.`);
+		if (dedupe.length || include.length || exclude.length) extendViteConfig((config) => {
+			if (dedupe.length) {
+				config.resolve ||= {};
+				config.resolve.dedupe = [...new Set([...config.resolve.dedupe ?? [], ...dedupe])];
+			}
+			if (include.length) {
+				config.optimizeDeps ||= {};
+				config.optimizeDeps.include = [...new Set([...config.optimizeDeps.include ?? [], ...include])];
+			}
+			if (exclude.length) {
+				config.optimizeDeps ||= {};
+				config.optimizeDeps.exclude = [...new Set([...config.optimizeDeps.exclude ?? [], ...exclude])];
+			}
+		});
+	}
+});
+//#endregion
+export { monoHelperModule as default };