@pyck/react 0.0.1

package/dist/featured-icon-DPysOpSf.js

@@ -0,0 +1,35 @@
+import { ark } from "@ark-ui/react/factory";
+import { styled } from "@pyck/styled-system/jsx";
+import { icon } from "@pyck/styled-system/recipes";
+import { cva } from "@pyck/styled-system/css";
+
+//#region src/components/icon/icon.tsx
+const Icon = styled(ark.svg, icon, { defaultProps: { asChild: true } });
+
+//#endregion
+//#region src/components/icon/featured-icon.tsx
+const IconWrapper = styled("div", cva({
+	base: {
+		alignItems: "center",
+		background: "gray.surface.bg",
+		borderWidth: "1px",
+		boxSize: "12",
+		color: "gray.surface.fg",
+		display: "flex",
+		justifyContent: "center"
+	},
+	variants: { variant: { embedded: {
+		boxSize: "49px",
+		color: "gray.surface.fg/80",
+		transform: "translate(-1px, -1px)"
+	} } }
+}));
+const FeaturedIcon = (props) => {
+	const { children, ...rest } = props;
+	return <IconWrapper {...rest}>
+      <Icon>{children}</Icon>
+    </IconWrapper>;
+};
+
+//#endregion
+export { Icon as n, FeaturedIcon as t };

package/dist/function-DOGwA2sm.js

@@ -0,0 +1,7 @@
+//#region src/utils/function.ts
+const isFunction = (v) => typeof v === "function";
+const isString = (v) => typeof v === "string";
+const runIfFn = (valueOrFn, ...args) => isFunction(valueOrFn) ? valueOrFn(...args) : valueOrFn;
+
+//#endregion
+export { isString as n, runIfFn as r, isFunction as t };

package/dist/show-IaI-36v9.js

@@ -0,0 +1,12 @@
+import { isValidElement } from "react";
+
+//#region src/components/show/show.tsx
+function Show(props) {
+	const { when, fallback, children } = props;
+	if (!when) return fallback ?? null;
+	const result = typeof children === "function" ? children(when) : children;
+	return isValidElement(result) ? result : <>{result}</>;
+}
+
+//#endregion
+export { Show as t };

package/dist/span-DWZSA3mH.js

@@ -0,0 +1,7 @@
+import { styled } from "@pyck/styled-system/jsx";
+
+//#region src/components/span/span.tsx
+const Span = styled("span");
+
+//#endregion
+export { Span as t };

package/dist/types/index.d.ts

@@ -0,0 +1,17 @@
+import { Optional } from "@ark-ui/react";
+
+//#region src/types/index.d.ts
+/**
+ * Extracts the element type from an array type T.
+ */
+type ElementType<T> = T extends (infer U)[] ? U : T;
+/**
+ * A dictionary type with string keys and values of type T.
+ */
+type Dict<T = unknown> = Record<string, T>;
+/**
+ * A type representing any function.
+ */
+type AnyFunction = (...args: never[]) => unknown;
+//#endregion
+export { AnyFunction, Dict, ElementType, type Optional };

package/dist/utils/index.d.ts

@@ -0,0 +1,206 @@
+import { GridCollection, createGridCollection, useAsyncList } from "@ark-ui/react/collection";
+import { createContext } from "@ark-ui/react/utils";
+import { useDebounce } from "ahooks";
+import { z } from "zod";
+import { DateValue } from "@ark-ui/react/date-picker";
+import * as react from "react";
+import { Dispatch, EffectCallback, Ref, SetStateAction } from "react";
+import { Dict } from "@pyck/react/types";
+
+//#region src/utils/capitalize.d.ts
+declare const capitalize: (s: string) => string;
+//#endregion
+//#region src/utils/compose-refs.d.ts
+type PossibleRef<T> = Ref<T | null> | undefined;
+declare function composeRefs<T>(...refs: PossibleRef<T>[]): (node: T | null) => void;
+//#endregion
+//#region src/utils/data-attr.d.ts
+declare const dataAttr: (condition: boolean | string | undefined | null) => string | undefined;
+//#endregion
+//#region src/utils/date-formatter.d.ts
+type DateInput = string | Date | null | undefined;
+type Locale = 'en-US' | 'en-GB' | 'de-DE';
+declare const getDateFormats: (locale: Locale) => {
+  SHORT_DATE: string;
+  LONG_DATE: string;
+  TIME: string;
+  TIME_12H: string;
+  DATETIME: string;
+  MONTH_DAY: string;
+  DAY_YEAR: string;
+};
+declare function formatDate(date: DateInput, formatStr?: string, locale?: Locale): string | null | undefined;
+declare function formatDateTime(date: DateInput, type?: 'date' | 'time' | 'datetime' | 'relative', locale?: Locale): string | null | undefined;
+declare function formatDateRange(start: DateInput, end: DateInput, locale?: Locale): string | null | undefined;
+//#endregion
+//#region src/utils/function.d.ts
+declare const isFunction: <T extends (...args: never[]) => unknown>(v: unknown) => v is T;
+declare const isString: (v: unknown) => v is string;
+declare const runIfFn: <T, Args extends unknown[]>(valueOrFn: T | ((...args: Args) => T), ...args: Args) => T;
+//#endregion
+//#region src/utils/is-empty.d.ts
+declare const isEmpty: <T>(value: string | null | undefined | T[] | readonly T[]) => value is null | undefined | "";
+declare const isNotEmpty: <T>(value: string | null | undefined | T[] | readonly T[]) => value is string | T[];
+//#endregion
+//#region src/utils/json-schema.d.ts
+type StringSchema = {
+  type: 'string';
+  title?: string;
+  description?: string;
+  enum?: readonly string[];
+  minLength?: number;
+  maxLength?: number;
+  format?: 'email' | 'date' | 'date-time';
+};
+type NumberSchema = {
+  type: 'number';
+  title?: string;
+  description?: string;
+  format?: 'currency';
+  minimum?: number;
+  maximum?: number;
+};
+type IntegerSchema = {
+  type: 'integer';
+  title?: string;
+  description?: string;
+  minimum?: number;
+  maximum?: number;
+};
+type BooleanSchema = {
+  type: 'boolean';
+  title?: string;
+  description?: string;
+};
+type ArraySchema = {
+  type: 'array';
+  title?: string;
+  description?: string;
+  items: JsonSchema;
+  minItems?: number;
+  maxItems?: number;
+};
+type ObjectSchema = {
+  type: 'object';
+  title?: string;
+  description?: string;
+  properties?: Record<string, JsonSchema>;
+  required?: string[];
+  additionalProperties?: boolean | JsonSchema;
+};
+type JsonSchema = StringSchema | NumberSchema | IntegerSchema | BooleanSchema | ArraySchema | ObjectSchema;
+declare const jsonSchema: z.ZodType<JsonSchema>;
+interface FieldDefinitionBase<TValue, TSchema extends JsonSchema> {
+  value: TValue;
+  schema: TSchema;
+  required?: boolean;
+}
+type FieldDefinition = FieldDefinitionBase<string, StringSchema> | FieldDefinitionBase<number, NumberSchema> | FieldDefinitionBase<number, IntegerSchema> | FieldDefinitionBase<boolean, BooleanSchema> | FieldDefinitionBase<unknown, ArraySchema> | FieldDefinitionBase<unknown, ObjectSchema>;
+type FieldDefinitions = Record<string, FieldDefinition>;
+declare const createFieldDefinition: (schema: JsonSchema, value: unknown, required?: boolean) => FieldDefinition;
+declare const createFieldDefinitions: (schema: JsonSchema, data: Dict) => FieldDefinitions;
+//#endregion
+//#region src/utils/json-schema-types.d.ts
+/**
+ * JSON Schema type definitions
+ * Based on JSON Schema Draft 7 specification
+ */
+interface JSONSchemaProperty {
+  type?: 'string' | 'number' | 'boolean' | 'object' | 'array' | 'null';
+  enum?: string[];
+  properties?: Record<string, JSONSchemaProperty>;
+  items?: JSONSchemaProperty;
+  required?: string[];
+  description?: string;
+  title?: string;
+  format?: 'date' | 'date-time' | 'time' | 'email' | 'uuid' | 'uri' | 'ipv4' | 'ipv6';
+  default?: unknown;
+  minLength?: number;
+  maxLength?: number;
+  minimum?: number;
+  maximum?: number;
+  pattern?: string;
+  minItems?: number;
+  maxItems?: number;
+  uniqueItems?: boolean;
+}
+interface JSONSchema {
+  type?: 'object';
+  properties?: Record<string, JSONSchemaProperty>;
+  required?: string[];
+  title?: string;
+  description?: string;
+  additionalProperties?: boolean | JSONSchemaProperty;
+}
+//#endregion
+//#region src/utils/omit.d.ts
+declare const omit: <T extends object, K extends keyof T>(object: T, keysToOmit?: readonly K[]) => Omit<T, K>;
+//#endregion
+//#region src/utils/parse-date.d.ts
+/**
+ * Custom parseDate wrapper that handles our timestamp formats
+ *
+ * Ark UI's parseDate only accepts:
+ * - Date objects
+ * - Date-only strings: "2024-11-25"
+ * - NOT timestamps with time components
+ *
+ * This utility handles:
+ * - Date objects
+ * - ISO date strings: "2024-11-25"
+ * - Timestamps: "2024-11-25T15:17:45Z" (extracts date part)
+ * - Timestamps with milliseconds: "2024-11-25T15:17:45.000Z" (extracts date part)
+ *
+ * @param value - The date value to parse (string or Date)
+ * @returns DateValue object compatible with Ark UI date picker
+ * @throws Error if the value cannot be parsed
+ */
+declare function parseDate(value: string | Date): DateValue;
+//#endregion
+//#region src/utils/partition.d.ts
+declare const partition: <T>(arr: T[], predicate: (item: T) => boolean) => [T[], T[]];
+//#endregion
+//#region src/utils/use-auto-focus.d.ts
+declare const useAutoFocus: (shouldFocus?: boolean) => react.RefObject<HTMLInputElement | null>;
+//#endregion
+//#region src/utils/use-effect-once.d.ts
+declare const useEffectOnce: (cb: EffectCallback) => void;
+//#endregion
+//#region src/utils/use-history-state.d.ts
+/**
+ * Configuration options for the useHistoryState hook.
+ */
+interface HistoryStateOptions {
+  /**
+   * Maximum number of history entries to keep.
+   * When exceeded, oldest entries are removed.
+   * @default 10
+   */
+  limit?: number;
+}
+/**
+ * A React hook that provides state management with undo/redo history.
+ *
+ * @template T - The type of the state value
+ * @param options - Configuration options for the history state
+ *
+ * @returns An object containing the current state, setState function, and undo/redo controls
+ *
+ * @example
+ * ```tsx
+ * const { state, setState, undo, redo, canUndo, canRedo } = useHistoryState(0, { limit: 50 })
+ * ```
+ */
+declare function useHistoryState<T>(initialValue: T, options?: HistoryStateOptions): {
+  state: T;
+  setState: Dispatch<SetStateAction<T>>;
+  canUndo: () => boolean;
+  undo: () => void;
+  canRedo: () => boolean;
+  redo: () => void;
+};
+//#endregion
+//#region src/utils/use-hotkey.d.ts
+declare const useHotkey: (setOpen: (open: boolean) => void) => void;
+//#endregion
+export { type DateInput, type FieldDefinition, type GridCollection, type JSONSchema, type JSONSchemaProperty, type JsonSchema, type Locale, capitalize, composeRefs, createContext, createFieldDefinition, createFieldDefinitions, createGridCollection, dataAttr, formatDate, formatDateRange, formatDateTime, getDateFormats, isEmpty, isFunction, isNotEmpty, isString, jsonSchema, omit, parseDate, partition, runIfFn, useAsyncList, useAutoFocus, useDebounce, useEffectOnce, useHistoryState, useHotkey };

package/dist/utils/index.js

@@ -0,0 +1,377 @@
+import { n as isString, r as runIfFn, t as isFunction } from "../function-DOGwA2sm.js";
+import { createGridCollection, useAsyncList } from "@ark-ui/react/collection";
+import { createContext } from "@ark-ui/react/utils";
+import { useDebounce } from "ahooks";
+import { format, isToday, isValid, parseISO } from "date-fns";
+import { de, enGB, enUS } from "date-fns/locale";
+import { match } from "ts-pattern";
+import { z } from "zod";
+import { parseDate as parseDate$1 } from "@ark-ui/react/date-picker";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useEnvironmentContext } from "@ark-ui/react/environment";
+
+//#region src/utils/capitalize.ts
+const capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+
+//#endregion
+//#region src/utils/compose-refs.ts
+function composeRefs(...refs) {
+	return (node) => {
+		const cleanUps = [];
+		for (const ref of refs) if (typeof ref === "function") {
+			const cb = ref(node);
+			if (typeof cb === "function") cleanUps.push(cb);
+		} else if (ref) ref.current = node;
+		if (cleanUps.length) return () => {
+			for (const cleanUp of cleanUps) cleanUp();
+		};
+	};
+}
+
+//#endregion
+//#region src/utils/data-attr.ts
+const dataAttr = (condition) => {
+	if (!condition && condition !== "") return void 0;
+	return isString(condition) ? condition : "";
+};
+
+//#endregion
+//#region src/utils/date-formatter.ts
+const DEFAULT_LOCALE = "en-US";
+const localeMap = {
+	"en-US": enUS,
+	"en-GB": enGB,
+	"de-DE": de
+};
+const getDateFormats = (locale) => {
+	return match(locale).with("en-US", () => ({
+		SHORT_DATE: "MMM d, yyyy",
+		LONG_DATE: "MMM dd, yyyy",
+		TIME: "HH:mm",
+		TIME_12H: "h:mma",
+		DATETIME: "MMM dd, yyyy HH:mm",
+		MONTH_DAY: "MMM d",
+		DAY_YEAR: "d, yyyy"
+	})).with("en-GB", () => ({
+		SHORT_DATE: "d MMM yyyy",
+		LONG_DATE: "dd MMM yyyy",
+		TIME: "HH:mm",
+		TIME_12H: "h:mma",
+		DATETIME: "dd MMM yyyy HH:mm",
+		MONTH_DAY: "d MMM",
+		DAY_YEAR: "d, yyyy"
+	})).with("de-DE", () => ({
+		SHORT_DATE: "d. MMM yyyy",
+		LONG_DATE: "dd. MMM yyyy",
+		TIME: "HH:mm",
+		TIME_12H: "HH:mm",
+		DATETIME: "dd. MMM yyyy HH:mm",
+		MONTH_DAY: "d. MMM",
+		DAY_YEAR: "d, yyyy"
+	})).exhaustive();
+};
+function formatDate(date, formatStr, locale = DEFAULT_LOCALE) {
+	if (!date) return date === null ? null : void 0;
+	const dateObj = date instanceof Date ? date : parseISO(date);
+	if (!isValid(dateObj)) return null;
+	const dateFormats = getDateFormats(locale);
+	return format(dateObj, formatStr || dateFormats.LONG_DATE, { locale: localeMap[locale] });
+}
+function formatDateTime(date, type = "date", locale = DEFAULT_LOCALE) {
+	if (!date) return date === null ? null : void 0;
+	const dateObj = date instanceof Date ? date : parseISO(date);
+	if (!isValid(dateObj)) return null;
+	const dateFormats = getDateFormats(locale);
+	const localeObj = localeMap[locale];
+	return match(type).with("time", () => format(dateObj, dateFormats.TIME, { locale: localeObj })).with("datetime", () => format(dateObj, dateFormats.DATETIME, { locale: localeObj })).with("relative", () => {
+		if (isToday(dateObj)) return format(dateObj, dateFormats.TIME, { locale: localeObj });
+		return format(dateObj, dateFormats.LONG_DATE, { locale: localeObj });
+	}).with("date", () => format(dateObj, dateFormats.LONG_DATE, { locale: localeObj })).exhaustive();
+}
+function formatDateRange(start, end, locale = DEFAULT_LOCALE) {
+	if (!start || !end) return start === null || end === null ? null : void 0;
+	const startDate = start instanceof Date ? start : parseISO(start);
+	const endDate = end instanceof Date ? end : parseISO(end);
+	if (!isValid(startDate) || !isValid(endDate)) return null;
+	const dateFormats = getDateFormats(locale);
+	const localeObj = localeMap[locale];
+	const sameYear = startDate.getFullYear() === endDate.getFullYear();
+	const sameMonth = sameYear && startDate.getMonth() === endDate.getMonth();
+	const startFormat = sameMonth ? dateFormats.MONTH_DAY : sameYear ? dateFormats.MONTH_DAY : dateFormats.SHORT_DATE;
+	const endFormat = sameMonth ? dateFormats.DAY_YEAR : dateFormats.SHORT_DATE;
+	return `${format(startDate, startFormat, { locale: localeObj })} – ${format(endDate, endFormat, { locale: localeObj })}`;
+}
+
+//#endregion
+//#region src/utils/is-empty.ts
+const isEmpty = (value) => {
+	if (value == null) return true;
+	if (isString(value)) return value.trim().length === 0;
+	if (Array.isArray(value)) return value.length === 0;
+	return false;
+};
+const isNotEmpty = (value) => {
+	return !isEmpty(value);
+};
+
+//#endregion
+//#region src/utils/json-schema.ts
+const jsonSchema = z.lazy(() => jsonSchemaUnion);
+const stringSchema = z.object({
+	type: z.literal("string"),
+	title: z.string().optional(),
+	description: z.string().optional(),
+	enum: z.array(z.string()).readonly().optional(),
+	minLength: z.number().optional(),
+	maxLength: z.number().optional(),
+	format: z.enum([
+		"email",
+		"date",
+		"date-time"
+	]).optional()
+}).strict();
+const numberSchema = z.object({
+	type: z.literal("number"),
+	title: z.string().optional(),
+	description: z.string().optional(),
+	format: z.enum(["currency"]).optional(),
+	minimum: z.number().optional(),
+	maximum: z.number().optional()
+}).strict();
+const integerSchema = z.object({
+	type: z.literal("integer"),
+	title: z.string().optional(),
+	description: z.string().optional(),
+	minimum: z.number().optional(),
+	maximum: z.number().optional()
+}).strict();
+const booleanSchema = z.object({
+	type: z.literal("boolean"),
+	title: z.string().optional(),
+	description: z.string().optional()
+}).strict();
+const arraySchema = z.object({
+	type: z.literal("array"),
+	title: z.string().optional(),
+	description: z.string().optional(),
+	items: jsonSchema,
+	minItems: z.number().optional(),
+	maxItems: z.number().optional()
+}).strict();
+const objectSchema = z.object({
+	type: z.literal("object"),
+	title: z.string().optional(),
+	description: z.string().optional(),
+	properties: z.record(z.string(), jsonSchema).optional(),
+	required: z.array(z.string()).optional(),
+	additionalProperties: z.union([z.boolean(), jsonSchema]).optional()
+}).strict();
+const jsonSchemaUnion = z.union([
+	stringSchema,
+	numberSchema,
+	integerSchema,
+	booleanSchema,
+	arraySchema,
+	objectSchema
+]);
+const createFieldDefinition = (schema, value, required) => match(schema).with({ type: "string" }, (s) => ({
+	schema: s,
+	value,
+	required
+})).with({ type: "number" }, (s) => ({
+	schema: s,
+	value,
+	required
+})).with({ type: "integer" }, (s) => ({
+	schema: s,
+	value,
+	required
+})).with({ type: "boolean" }, (s) => ({
+	schema: s,
+	value,
+	required
+})).with({ type: "array" }, (s) => ({
+	schema: s,
+	value,
+	required
+})).with({ type: "object" }, (s) => ({
+	schema: s,
+	value,
+	required
+})).exhaustive();
+const createFieldDefinitions = (schema, data) => {
+	if (schema.type !== "object" || !schema.properties) throw new Error("Schema must be an object type with properties");
+	const required = new Set(schema.required);
+	return Object.fromEntries(Object.entries(schema.properties).map(([key, s]) => [key, createFieldDefinition(s, data[key], required.has(key))]));
+};
+
+//#endregion
+//#region src/utils/omit.ts
+const omit = (object, keysToOmit = []) => Object.fromEntries(Object.entries(object).filter(([key]) => !keysToOmit.includes(key)));
+
+//#endregion
+//#region src/utils/parse-date.ts
+/**
+* Custom parseDate wrapper that handles our timestamp formats
+*
+* Ark UI's parseDate only accepts:
+* - Date objects
+* - Date-only strings: "2024-11-25"
+* - NOT timestamps with time components
+*
+* This utility handles:
+* - Date objects
+* - ISO date strings: "2024-11-25"
+* - Timestamps: "2024-11-25T15:17:45Z" (extracts date part)
+* - Timestamps with milliseconds: "2024-11-25T15:17:45.000Z" (extracts date part)
+*
+* @param value - The date value to parse (string or Date)
+* @returns DateValue object compatible with Ark UI date picker
+* @throws Error if the value cannot be parsed
+*/
+function parseDate(value) {
+	if (value instanceof Date) return parseDate$1(value);
+	if (typeof value !== "string") throw new Error(`Invalid date value type: ${typeof value}`);
+	try {
+		return parseDate$1(value);
+	} catch {
+		const dateOnlyMatch = value.match(/^(\d{4}-\d{2}-\d{2})/);
+		if (dateOnlyMatch?.[1]) return parseDate$1(dateOnlyMatch[1]);
+		try {
+			const date = new Date(value);
+			if (!Number.isNaN(date.getTime())) return parseDate$1(date);
+		} catch (error) {
+			console.debug("Failed to parse date as Date object:", error);
+		}
+		throw new Error(`Cannot parse date value: ${value}`);
+	}
+}
+
+//#endregion
+//#region src/utils/partition.ts
+const partition = (arr, predicate) => arr.reduce(([pass, fail], item) => predicate(item) ? [[...pass, item], fail] : [pass, [...fail, item]], [[], []]);
+
+//#endregion
+//#region src/utils/use-auto-focus.ts
+const useAutoFocus = (shouldFocus = true) => {
+	const ref = useRef(null);
+	useEffect(() => {
+		if (shouldFocus) setTimeout(() => {
+			ref.current?.focus();
+		}, 0);
+	}, [shouldFocus]);
+	return ref;
+};
+
+//#endregion
+//#region src/utils/use-effect-once.ts
+const useEffectOnce = (cb) => {
+	const savedCallback = useRef(cb);
+	const effectGuard = useRef(false);
+	useEffect(() => {
+		savedCallback.current = cb;
+	});
+	useEffect(() => {
+		if (effectGuard.current !== true) {
+			effectGuard.current = true;
+			savedCallback.current();
+		}
+	}, []);
+};
+
+//#endregion
+//#region src/utils/use-history-state.ts
+function isSetStateFunction(value) {
+	return typeof value === "function";
+}
+/**
+* A React hook that provides state management with undo/redo history.
+*
+* @template T - The type of the state value
+* @param options - Configuration options for the history state
+*
+* @returns An object containing the current state, setState function, and undo/redo controls
+*
+* @example
+* ```tsx
+* const { state, setState, undo, redo, canUndo, canRedo } = useHistoryState(0, { limit: 50 })
+* ```
+*/
+function useHistoryState(initialValue, options) {
+	const limit = options?.limit ?? 10;
+	const [{ history, index }, setHistoryState] = useState({
+		history: [initialValue],
+		index: 0
+	});
+	if (index >= history.length || index < 0) throw Error(`Impossible State reached: ${index} | ${history.length}`);
+	const state = history[index];
+	/**
+	* Sets a new state value and adds it to the history.
+	* If called after undo operations, discards any "future" states.
+	*/
+	const setState = (setStateFnOrValue) => setHistoryState((prev) => {
+		const currentState = prev.history[prev.index];
+		const newState = isSetStateFunction(setStateFnOrValue) ? setStateFnOrValue(currentState) : setStateFnOrValue;
+		if (prev.index !== prev.history.length - 1) return {
+			history: [...prev.history.slice(0, prev.index + 1), newState],
+			index: prev.index + 1
+		};
+		if (prev.history.length >= limit) return {
+			history: [...prev.history.slice(1), newState],
+			index: prev.index
+		};
+		return {
+			history: [...prev.history, newState],
+			index: prev.index + 1
+		};
+	});
+	/**
+	* Returns whether there are previous states available to undo to.
+	*/
+	const canUndo = useCallback(() => index > 0, [index]);
+	/**
+	* Returns whether there are future states available to redo to.
+	*/
+	const canRedo = useCallback(() => index < history.length - 1, [index, history.length]);
+	return {
+		state,
+		setState,
+		canUndo,
+		undo: useCallback(() => {
+			setHistoryState((prev) => ({
+				...prev,
+				index: Math.max(0, prev.index - 1)
+			}));
+		}, []),
+		canRedo,
+		redo: useCallback(() => {
+			setHistoryState((prev) => ({
+				...prev,
+				index: Math.min(prev.history.length - 1, prev.index + 1)
+			}));
+		}, [])
+	};
+}
+
+//#endregion
+//#region src/utils/use-hotkey.ts
+const useHotkey = (setOpen) => {
+	const env = useEnvironmentContext();
+	useEffect(() => {
+		const document = env.getDocument();
+		const hotkey = /(Mac|iPhone|iPod|iPad)/i.test(navigator?.platform) ? "metaKey" : "ctrlKey";
+		const handleKeydown = (event) => {
+			if (event.key?.toLowerCase() === "k" && event[hotkey]) {
+				event.preventDefault();
+				setOpen(true);
+			}
+		};
+		document.addEventListener("keydown", handleKeydown, true);
+		return () => {
+			document.removeEventListener("keydown", handleKeydown, true);
+		};
+	}, [env, setOpen]);
+};
+
+//#endregion
+export { capitalize, composeRefs, createContext, createFieldDefinition, createFieldDefinitions, createGridCollection, dataAttr, formatDate, formatDateRange, formatDateTime, getDateFormats, isEmpty, isFunction, isNotEmpty, isString, jsonSchema, omit, parseDate, partition, runIfFn, useAsyncList, useAutoFocus, useDebounce, useEffectOnce, useHistoryState, useHotkey };