@povio/ui 2.1.14 → 2.1.16

package/dist/radio.cva.js

@@ -0,0 +1,42 @@
+import { uiGroupOutlineClass } from "./outline.clsx.js";
+import { compoundMapper } from "./compoundMapper.js";
+import { cva } from "class-variance-authority";
+const radio = cva([
+	"flex items-center justify-center border-2",
+	"relative size-3-5 rounded-full p-1-5",
+	"before:absolute before:hidden before:size-1 before:rounded-full",
+	uiGroupOutlineClass
+], {
+	variants: { variant: { default: [
+		"border-interactive-outlined-secondary-on-idle",
+		"group-disabled:border-interactive-outlined-secondary-on-disabled",
+		"group-hover:border-interactive-outlined-secondary-on-hover",
+		"group-pressed:border-interactive-outlined-secondary-on-pressed",
+		"group-selected:border-interactive-contained-primary-idle",
+		"group-selected:bg-interactive-contained-primary-idle",
+		"group-selected:group-hover:bg-interactive-contained-primary-hover",
+		"group-selected:group-hover:border-interactive-contained-primary-hover",
+		"group-selected:group-pressed:bg-interactive-contained-primary-pressed",
+		"group-selected:group-pressed:border-interactive-contained-primary-pressed",
+		"group-selected:group-disabled:bg-interactive-contained-primary-disabled",
+		"group-selected:group-disabled:border-interactive-contained-primary-disabled",
+		"group-indeterminate:border-interactive-contained-primary-idle",
+		"group-indeterminate:bg-interactive-contained-primary-idle",
+		"group-indeterminate:group-hover:bg-interactive-contained-primary-hover",
+		"group-indeterminate:group-hover:border-interactive-contained-primary-hover",
+		"group-indeterminate:group-pressed:bg-interactive-contained-primary-pressed",
+		"group-indeterminate:group-pressed:border-interactive-contained-primary-pressed",
+		"group-invalid:border-interactive-outlined-error-on-idle",
+		"group-focus-visible:outline-interactive-contained-primary-focus",
+		"before:bg-interactive-contained-primary-on-idle",
+		"group-hover:before:bg-interactive-contained-primary-on-hover",
+		"group-selected:before:block"
+	] } },
+	defaultVariants: { variant: "default" }
+});
+const radioIndicatorClass = "group flex items-center gap-2";
+const radioTypography = compoundMapper({ default: {
+	size: "label-1",
+	variant: "default"
+} });
+export { radio, radioIndicatorClass, radioTypography };

package/dist/react.js

@@ -0,0 +1,6 @@
+import { __reExport } from "./rolldown_runtime.js";
+export * from "framer-motion";
+var react_exports = {};
+import * as import_framer_motion from "framer-motion";
+__reExport(react_exports, import_framer_motion);
+export { react_exports };

package/dist/rest-interceptor.js

@@ -0,0 +1,22 @@
+var RestInterceptor = class {
+	constructor(applyInterceptor) {
+		this.applyInterceptor = applyInterceptor;
+		this.interceptorIdMap = [];
+	}
+	addInterceptor(client, ...args) {
+		this.removeInterceptor(client);
+		const interceptorId = this.applyInterceptor(client, ...args);
+		this.interceptorIdMap.push({
+			client,
+			interceptorId
+		});
+	}
+	removeInterceptor(client) {
+		const interceptorId = this.interceptorIdMap.find((i) => i.client === client)?.interceptorId;
+		if (interceptorId != null) {
+			client.interceptors.request.eject(interceptorId);
+			this.interceptorIdMap = this.interceptorIdMap.filter((i) => i.client !== client);
+		}
+	}
+};
+export { RestInterceptor };

package/dist/rest.utils.js

@@ -0,0 +1,31 @@
+import axios from "axios";
+import { z } from "zod";
+let RestUtils;
+(function(_RestUtils) {
+	_RestUtils.extractServerResponseCode = (e) => {
+		if (e instanceof z.ZodError) return "validation-exception";
+		if (!axios.isAxiosError(e)) return null;
+		if (!e.response) return null;
+		const data = e.response.data;
+		if (typeof data?.code === "string") return data.code;
+		return null;
+	};
+	_RestUtils.doesServerErrorMessageContain = (e, text) => {
+		const message = extractServerErrorMessage(e);
+		if (message === null || message === void 0) return false;
+		return message.toLowerCase().includes(text.toLowerCase());
+	};
+	const extractServerErrorMessage = _RestUtils.extractServerErrorMessage = (e) => {
+		if (e instanceof z.ZodError) return e.message;
+		if (!axios.isAxiosError(e)) return null;
+		if (!e.response) return null;
+		const data = e.response.data;
+		if (typeof data?.message === "string") return data.message;
+		return null;
+	};
+	_RestUtils.extractContentDispositionFilename = (headers) => {
+		const contentDisposition = headers["content-disposition"];
+		return contentDisposition ? /filename=["']?([^"';]+)/i.exec(contentDisposition)?.[1] : void 0;
+	};
+})(RestUtils || (RestUtils = {}));
+export { RestUtils };

package/dist/rolldown_runtime.js

@@ -0,0 +1,16 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+export { __reExport };

package/dist/router.context.js

@@ -0,0 +1,37 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, use, useMemo } from "react";
+import { RouterProvider } from "react-aria";
+let UIRouter;
+(function(_UIRouter) {
+	const UIRouterContext = createContext(null);
+	_UIRouter.UIRouterProvider = ({ children, pathname, push, replace, searchString }) => {
+		const searchParams = useMemo(() => {
+			return new URLSearchParams(searchString);
+		}, [searchString]);
+		return /* @__PURE__ */ jsx(UIRouterContext, {
+			value: useMemo(() => ({
+				searchParams,
+				pathname,
+				push,
+				searchString,
+				replace
+			}), [
+				searchParams,
+				pathname,
+				push,
+				searchString,
+				replace
+			]),
+			children: /* @__PURE__ */ jsx(RouterProvider, {
+				navigate: push,
+				children
+			})
+		});
+	};
+	_UIRouter.useUIRouter = () => {
+		const context = use(UIRouterContext);
+		if (!context) throw new Error("useUIRouter must be used within a UIRouterContext");
+		return context;
+	};
+})(UIRouter || (UIRouter = {}));
+export { UIRouter };

package/dist/routing.utils.js

@@ -0,0 +1,9 @@
+let RoutingUtils;
+(function(_RoutingUtils) {
+	_RoutingUtils.addQueryParams = (path, params) => {
+		const sParams = new URLSearchParams();
+		for (const [key, value] of Object.entries(params)) if (value) sParams.append(key, value.toString());
+		return `${path}?${sParams.toString()}`;
+	};
+})(RoutingUtils || (RoutingUtils = {}));
+export { RoutingUtils };

package/dist/segment.cva.js

@@ -0,0 +1,25 @@
+import { cva } from "class-variance-authority";
+const segmentCva = cva([
+	"group/segment grid w-fit items-center gap-segmented-control-side-segmented-control p-segmented-control-side-segmented-control",
+	"bg-elevation-fill-default-3",
+	"rounded-segmented-control-rounding-segmented-control"
+]);
+const segmentItemCva = cva([
+	"flex items-center justify-center gap-segmented-control-gap-content-icon-to-text transition-all duration-200",
+	"border border-support-transparent-outline",
+	"py-segmented-control-height-segment",
+	"rounded-segmented-control-rounding-segment",
+	"text-interactive-subtle-secondary-on-idle",
+	"hover:border-interactive-subtle-secondary-hover hover:bg-interactive-subtle-secondary-hover hover:text-interactive-subtle-secondary-on-hover",
+	"pressed:border-interactive-subtle-secondary-pressed pressed:bg-interactive-subtle-secondary-pressed pressed:text-interactive-subtle-secondary-on-pressed",
+	"disabled:border-support-transparent-outline disabled:text-interactive-subtle-secondary-on-disabled",
+	"selected:border-interactive-subtle-secondary-toggled-idle selected:bg-interactive-subtle-secondary-toggled-idle selected:text-interactive-subtle-secondary-on-toggled-idle",
+	"selected:disabled:border-interactive-subtle-secondary-toggled-disabled selected:disabled:bg-interactive-subtle-secondary-toggled-disabled selected:disabled:text-interactive-subtle-secondary-on-toggled-disabled"
+], {
+	variants: { iconOnly: {
+		true: "px-segmented-control-height-segment",
+		false: "px-segmented-control-side-segment"
+	} },
+	defaultVariants: { iconOnly: false }
+});
+export { segmentCva, segmentItemCva };

package/dist/select.context.js

@@ -0,0 +1,190 @@
+import { NewItemId, useSelectItems } from "./useSelectItems.js";
+import { useDebounceCallback } from "./useDebounceCallback.js";
+import { jsx } from "react/jsx-runtime";
+import { createContext, use, useCallback, useEffect, useMemo, useRef, useState } from "react";
+let SelectContext;
+(function(_SelectContext) {
+	const Context = createContext({});
+	const defaultMapInitialToSelectItem = (item) => ({
+		id: item.id,
+		label: item.label ?? item.name ?? ""
+	});
+	_SelectContext.Provider = ({ items, onInputChange, onSearchChange, showSelectAllOption, showNewItemOption, newItemMinLength, onNewItemOption, isLoading, hasLoadMore, isClientSearchDisabled, children, mapInitialToSelectItem = defaultMapInitialToSelectItem,...props }) => {
+		const isMultiple = props.selectionMode === "multiple";
+		const initialSelectedItems = useMemo(() => {
+			if (!props.initialSelection) return null;
+			if (Array.isArray(props.initialSelection)) return props.initialSelection.map(mapInitialToSelectItem);
+			return mapInitialToSelectItem(props.initialSelection);
+		}, [props.initialSelection, mapInitialToSelectItem]);
+		const [isOpen, setIsOpen] = useState(false);
+		const [fieldState, setFieldState] = useState({
+			value: props.value ?? (isMultiple ? [] : null),
+			inputValue: "",
+			searchValue: ""
+		});
+		const { callback: onSearchChangeDebounced, isDebouncing } = useDebounceCallback(onSearchChange);
+		const [showAll, setShowAll] = useState(false);
+		const [cachedItems, setCachedItems] = useState(items);
+		const valueRef = useRef(initialSelectedItems);
+		useEffect(() => {
+			if (!isLoading) setCachedItems(items);
+		}, [isLoading, items]);
+		const { allItems, allListItems, listItems, selectableListItems } = useSelectItems({
+			initialSelectedItems,
+			selectedItems: valueRef.current,
+			cachedItems,
+			inputValue: fieldState.inputValue,
+			showAll,
+			isMultiple,
+			showSelectAllOption,
+			showNewItemOption,
+			newItemMinLength,
+			isLoading,
+			hasLoadMore,
+			isClientSearchDisabled
+		});
+		const selectedItems = useMemo(() => allItems.filter(({ id }) => Array.isArray(fieldState.value) ? fieldState.value.includes(id) : id === fieldState.value), [allItems, fieldState.value]);
+		const selectedIds = useMemo(() => selectedItems.map(({ id }) => id), [selectedItems]);
+		const getItem = useCallback((value$1) => allItems.find((item) => item && item.id === value$1) ?? null, [allItems]);
+		const updateValue = useCallback((value$1) => {
+			if (Array.isArray(value$1)) valueRef.current = value$1.map((id) => getItem(id)).filter((item) => item !== null);
+			else valueRef.current = getItem(value$1);
+		}, [getItem]);
+		const getValueIds = () => Array.isArray(valueRef.current) ? valueRef.current.map(({ id }) => id) : valueRef.current?.id ?? null;
+		const emitStateChanges = useCallback((changes, skipSelectionChange) => {
+			if (JSON.stringify(changes.value) !== JSON.stringify(getValueIds())) {
+				updateValue(changes.value);
+				if (!skipSelectionChange) if (isMultiple) props.onChange?.(changes.value);
+				else props.onChange?.(changes.value);
+			}
+			if (changes.inputValue !== fieldState.inputValue) onInputChange?.(changes.inputValue);
+			if (changes.searchValue !== fieldState.searchValue) onSearchChangeDebounced?.(changes.searchValue);
+		}, [
+			fieldState,
+			isMultiple,
+			props,
+			onInputChange,
+			onSearchChangeDebounced,
+			updateValue
+		]);
+		const syncFieldState = (value$1) => {
+			const newFieldState = {
+				value: value$1,
+				inputValue: isMultiple || Array.isArray(value$1) ? fieldState.inputValue : getItem(value$1)?.label ?? "",
+				searchValue: ""
+			};
+			setFieldState(newFieldState);
+			emitStateChanges(newFieldState, true);
+			if (!isMultiple) setShowAll(true);
+		};
+		useEffect(() => {
+			const value$1 = props.value ?? null;
+			if (JSON.stringify(value$1) !== JSON.stringify(fieldState.value)) syncFieldState(value$1);
+			else updateValue(value$1);
+		}, [props.value]);
+		useEffect(() => {
+			if (!isMultiple && fieldState.value && fieldState.inputValue === "" && getItem(fieldState.value)?.label) syncFieldState(fieldState.value);
+		}, [allListItems]);
+		const handleInputChange = useCallback((inputValue) => {
+			const newFieldState = {
+				value: isMultiple || inputValue !== "" ? fieldState.value : null,
+				inputValue,
+				searchValue: inputValue
+			};
+			setFieldState(newFieldState);
+			emitStateChanges(newFieldState);
+			setShowAll(false);
+			if (!isOpen && inputValue !== "" && props.isSearchable) setIsOpen(true);
+		}, [
+			emitStateChanges,
+			fieldState.value,
+			isMultiple
+		]);
+		const onChange = useCallback((value$1) => {
+			if (value$1 === "new-item-id") onNewItemOption?.(fieldState.inputValue);
+			else {
+				const newFieldState = {
+					value: value$1,
+					inputValue: isMultiple || Array.isArray(value$1) ? "" : getItem(value$1)?.label ?? "",
+					searchValue: ""
+				};
+				setFieldState(newFieldState);
+				emitStateChanges(newFieldState);
+			}
+			if (!isMultiple) {
+				setIsOpen(false);
+				setShowAll(true);
+			}
+		}, [
+			emitStateChanges,
+			onNewItemOption,
+			fieldState.inputValue,
+			getItem,
+			isMultiple
+		]);
+		const onClear = useCallback(() => {
+			if (!valueRef.current || Array.isArray(valueRef.current) && valueRef.current.length === 0) {
+				setFieldState((prev) => ({
+					...prev,
+					inputValue: ""
+				}));
+				return;
+			}
+			if (isMultiple) onChange([]);
+			else onChange(null);
+		}, [isMultiple, onChange]);
+		const onSelectAll = useCallback(() => {
+			onChange(selectableListItems.map(({ id }) => id));
+		}, [selectableListItems, onChange]);
+		const onRemove = useCallback((value$1) => {
+			if (isMultiple && Array.isArray(fieldState.value)) onChange(fieldState.value.filter((id) => id !== value$1));
+		}, [
+			isMultiple,
+			fieldState.value,
+			onChange
+		]);
+		const value = useMemo(() => ({
+			fieldState,
+			isOpen,
+			setIsOpen,
+			isDebouncing,
+			onInputChange: handleInputChange,
+			onChange,
+			onClear,
+			onSelectAll,
+			onRemove,
+			listItems,
+			selectableListItems,
+			selectedItems,
+			selectedIds,
+			isMultiple,
+			isLoading,
+			hasLoadMore
+		}), [
+			fieldState,
+			isOpen,
+			setIsOpen,
+			isDebouncing,
+			handleInputChange,
+			onChange,
+			onClear,
+			onSelectAll,
+			onRemove,
+			listItems,
+			selectableListItems,
+			selectedIds,
+			selectedItems,
+			isMultiple,
+			isLoading,
+			hasLoadMore
+		]);
+		return /* @__PURE__ */ jsx(Context.Provider, {
+			value,
+			children
+		});
+	};
+	_SelectContext.useSelect = () => {
+		return use(Context);
+	};
+})(SelectContext || (SelectContext = {}));
+export { SelectContext };

package/dist/status.cva.js

@@ -0,0 +1,57 @@
+import { cva } from "class-variance-authority";
+const statusIcon = cva("size-6 shrink-0", {
+	variants: {
+		variant: {
+			outlined: "",
+			contained: "text-text-inverted-1"
+		},
+		color: {
+			neutral: "",
+			success: "",
+			warning: "",
+			error: ""
+		}
+	},
+	compoundVariants: [
+		{
+			variant: "outlined",
+			color: "neutral",
+			class: "text-text-default-2"
+		},
+		{
+			variant: "outlined",
+			color: "success",
+			class: "text-text-success-1"
+		},
+		{
+			variant: "outlined",
+			color: "warning",
+			class: "text-text-warning-1"
+		},
+		{
+			variant: "outlined",
+			color: "error",
+			class: "text-text-error-1"
+		}
+	],
+	defaultVariants: {
+		variant: "outlined",
+		color: "neutral"
+	}
+});
+const statusSeparator = cva("h-px shrink-0 self-stretch md:h-auto md:w-px", {
+	variants: {
+		variant: {
+			outlined: "",
+			contained: "hidden"
+		},
+		color: {
+			neutral: "bg-elevation-outline-default-1",
+			success: "bg-elevation-outline-success-1",
+			warning: "bg-elevation-outline-warning-1",
+			error: "bg-elevation-outline-error-1"
+		}
+	},
+	defaultVariants: { color: "neutral" }
+});
+export { statusIcon, statusSeparator };

package/dist/string.utils.js

@@ -0,0 +1,10 @@
+let StringUtils;
+(function(_StringUtils) {
+	_StringUtils.containsCaseInsensitive = (str, substr) => {
+		return str.toLowerCase().includes(substr.toLowerCase());
+	};
+	_StringUtils.capitalize = (str) => {
+		return str.charAt(0).toUpperCase() + str.slice(1);
+	};
+})(StringUtils || (StringUtils = {}));
+export { StringUtils };

package/dist/table.cva.js

@@ -0,0 +1,35 @@
+import { cva } from "class-variance-authority";
+const tableRow = cva([
+	"h-9 max-h-12",
+	"hover:bg-elevation-fill-default-2",
+	"disabled:opacity-50",
+	"selected:bg-elevation-fill-default-2",
+	"hover:selected:bg-interactive-subtle-secondary-hover",
+	"data-clickable:cursor-pointer",
+	"focus-within:bg-elevation-fill-default-2"
+], { variants: { alternatingBackground: {
+	even: "even:bg-elevation-fill-inverted-4/5",
+	odd: "odd:bg-elevation-fill-inverted-4/5"
+} } });
+const tableHeadRow = cva(["h-8 w-full"]);
+const tableHeadData = cva(["border-b border-b-elevation-outline-default-1 border-solid bg-elevation-fill-default-1 px-table-header-cell-container-side-default py-table-header-cell-container-height-default text-left"], {
+	variants: { hasRightBorder: {
+		true: "border-l border-l-elevation-outline-default-1 border-solid",
+		false: ""
+	} },
+	defaultVariants: { hasRightBorder: true }
+});
+const tableData = cva([
+	"relative h-0-5 overflow-hidden text-ellipsis whitespace-nowrap border-t border-t-transparent px-2",
+	"border-b border-b-elevation-outline-default-1",
+	"has-[*>[data-hovered]:not([data-disabled])]:hover:border-b-input-outlined-outline-hover",
+	"has-[*>[data-invalid]]:border-b-input-outlined-outline-error!",
+	"has-[*>[data-focused]]:border-b-input-outlined-outline-active"
+], {
+	variants: { hasRightBorder: {
+		true: "border-l border-l-elevation-outline-default-1",
+		false: ""
+	} },
+	defaultVariants: { hasRightBorder: true }
+});
+export { tableData, tableHeadData, tableHeadRow, tableRow };

package/dist/tag.cva.js

@@ -0,0 +1,50 @@
+import { uiOutlineClass } from "./outline.clsx.js";
+import { cva } from "class-variance-authority";
+const tag = cva([
+	uiOutlineClass,
+	"inline-flex items-center gap-list-gap-icon-to-label",
+	"p-pill-height-default px-1-5",
+	"rounded-pill-rounding-default",
+	"overflow-hidden",
+	"disabled:cursor-default"
+], {
+	variants: { color: {
+		primary: [
+			"bg-interactive-subtle-primary-idle text-interactive-subtle-primary-on-idle",
+			"hover:bg-interactive-subtle-primary-hover hover:text-interactive-subtle-primary-on-hover",
+			"pressed:bg-interactive-subtle-primary-pressed pressed:text-interactive-subtle-primary-on-pressed",
+			"disabled:bg-interactive-subtle-primary-disabled disabled:text-interactive-subtle-primary-on-disabled",
+			"focus-visible:outline-interactive-contained-primary-focus"
+		],
+		secondary: [
+			"bg-interactive-subtle-secondary-idle text-interactive-subtle-secondary-on-idle",
+			"hover:bg-interactive-subtle-secondary-hover hover:text-interactive-subtle-secondary-on-hover",
+			"pressed:bg-interactive-subtle-secondary-pressed pressed:text-interactive-subtle-secondary-on-pressed",
+			"disabled:bg-interactive-subtle-secondary-disabled disabled:text-interactive-subtle-secondary-on-disabled",
+			"focus-visible:outline-interactive-contained-primary-focus"
+		],
+		success: [
+			"bg-interactive-subtle-success-idle text-interactive-subtle-success-on-idle",
+			"hover:bg-interactive-subtle-success-hover hover:text-interactive-subtle-success-on-hover",
+			"pressed:bg-interactive-subtle-success-pressed pressed:text-interactive-subtle-success-on-pressed",
+			"disabled:bg-interactive-subtle-success-disabled disabled:text-interactive-subtle-success-on-disabled",
+			"focus-visible:outline-interactive-contained-primary-focus"
+		],
+		warning: [
+			"bg-interactive-subtle-warning-idle text-interactive-subtle-warning-on-idle",
+			"hover:bg-interactive-subtle-warning-hover hover:text-interactive-subtle-warning-on-hover",
+			"pressed:bg-interactive-subtle-warning-pressed pressed:text-interactive-subtle-warning-on-pressed",
+			"disabled:bg-interactive-subtle-warning-disabled disabled:text-interactive-subtle-warning-on-disabled",
+			"focus-visible:outline-interactive-contained-primary-focus"
+		],
+		error: [
+			"bg-interactive-subtle-error-idle text-interactive-subtle-error-on-idle",
+			"hover:bg-interactive-subtle-error-hover hover:text-interactive-subtle-error-on-hover",
+			"pressed:bg-interactive-subtle-error-pressed pressed:text-interactive-subtle-error-on-pressed",
+			"disabled:bg-interactive-subtle-error-disabled disabled:text-interactive-subtle-error-on-disabled",
+			"focus-visible:outline-interactive-contained-primary-focus"
+		]
+	} },
+	defaultVariants: { color: "primary" }
+});
+export { tag };

package/dist/text-editor.js

@@ -1,4 +1,2 @@
-import { TextEditor } from "./components/inputs/TextEditor/TextEditor.js";
-export {
-  TextEditor
-};
+import { TextEditor } from "./TextEditor.js";
+export { TextEditor };

package/dist/textEditor.types.js

@@ -0,0 +1,38 @@
+const defaultColors = [
+	"#000000",
+	"#e60000",
+	"#ff9900",
+	"#ffff00",
+	"#008a00",
+	"#0066cc",
+	"#9933ff",
+	"#ffffff",
+	"#facccc",
+	"#ffebcc",
+	"#ffffcc",
+	"#cce8cc",
+	"#cce0f5",
+	"#ebd6ff",
+	"#bbbbbb",
+	"#f06666",
+	"#ffc266",
+	"#ffff66",
+	"#66b966",
+	"#66a3e0",
+	"#c285ff",
+	"#888888",
+	"#a10000",
+	"#b26b00",
+	"#b2b200",
+	"#006100",
+	"#0047b2",
+	"#6b24b2",
+	"#444444",
+	"#5c0000",
+	"#663d00",
+	"#666600",
+	"#003700",
+	"#002966",
+	"#3d1466"
+];
+export { defaultColors };

package/dist/theme.context.js

@@ -0,0 +1,65 @@
+import { useLocalStorage } from "./useLocalStorage.js";
+import { jsx } from "react/jsx-runtime";
+import { createContext, use, useCallback, useEffect, useMemo, useState } from "react";
+import { z } from "zod";
+let ThemeContext;
+(function(_ThemeContext) {
+	const DEFAULT_STORAGE_KEY = "theme";
+	const ThemeSchema = z.literal([
+		"light",
+		"dark",
+		"system"
+	]);
+	const ThemeContext$1 = createContext(null);
+	_ThemeContext.ThemeContextProvider = ({ children, storageKey = DEFAULT_STORAGE_KEY }) => {
+		const [systemTheme, setSystemTheme] = useState(() => {
+			if (typeof window === "undefined") return;
+			return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+		});
+		const { value: theme, set } = useLocalStorage({
+			key: storageKey,
+			schema: ThemeSchema
+		});
+		const updateTheme = useCallback((theme$1) => {
+			set(theme$1);
+		}, [set]);
+		useEffect(() => {
+			if (typeof window === "undefined") return;
+			const onChange = (event) => {
+				setSystemTheme(event.matches ? "dark" : "light");
+			};
+			const media = window.matchMedia("(prefers-color-scheme: dark)");
+			media.addEventListener("change", onChange);
+			return () => {
+				media.removeEventListener("change", onChange);
+			};
+		}, []);
+		useEffect(() => {
+			document.documentElement.classList.remove("dark");
+			if ((!theme || theme === "system") && systemTheme === "dark" || theme === "dark") {
+				document.documentElement.classList.add("dark");
+				document.documentElement.style.colorScheme = "dark";
+			} else if (theme === "light") {
+				document.documentElement.classList.add("light");
+				document.documentElement.style.colorScheme = "light";
+			} else document.documentElement.style.colorScheme = "light";
+		}, [theme, systemTheme]);
+		const contextValue = useMemo(() => ({
+			theme: theme ?? "system",
+			systemTheme,
+			updateTheme
+		}), [
+			theme,
+			systemTheme,
+			updateTheme
+		]);
+		return /* @__PURE__ */ jsx(ThemeContext$1.Provider, {
+			value: contextValue,
+			children
+		});
+	};
+	_ThemeContext.useTheme = () => {
+		return use(ThemeContext$1);
+	};
+})(ThemeContext || (ThemeContext = {}));
+export { ThemeContext };