@tulip-systems/core 0.8.2 → 0.9.0

package/dist/src/modules/inline/components/inputs/select.client.mjs

@@ -0,0 +1,64 @@
+"use client";
+
+import { cn } from "../../../../lib/utils/cn.mjs";
+import { useIndicator } from "../../../../lib/hooks/use-indicator.mjs";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "../../../../components/ui/select.client.mjs";
+import { useInlineState } from "../../hooks/inline-state.client.mjs";
+import { useInlineAccess, useInlineMutation, useInlineStrategy } from "../../hooks/use-inline.client.mjs";
+import { inlineEditVariants } from "../../lib/variants.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/modules/inline/components/inputs/select.client.tsx
+function InlineSelect({ initialValue, variables, mutation, permission, strategy, disabled, onValueChange, ...props }) {
+	const state = useInlineState(initialValue);
+	const access = useInlineAccess({
+		permission,
+		disabled
+	});
+	const { handleTrigger } = useInlineStrategy({
+		strategy,
+		state,
+		mutations: useInlineMutation({
+			variables,
+			mutation,
+			access,
+			state
+		}),
+		parser: {
+			decode: (value) => value,
+			encode: (value) => value
+		}
+	});
+	return /* @__PURE__ */ jsx(Select, {
+		...props,
+		disabled: access.isDisabled,
+		value: state.value ?? void 0,
+		onValueChange: (nextValue) => {
+			handleTrigger("commit", nextValue ? nextValue : null);
+			onValueChange?.(nextValue);
+		}
+	});
+}
+function InlineSelectTrigger({ variant, className, ...props }) {
+	const { status } = useIndicator();
+	return /* @__PURE__ */ jsx(SelectTrigger, {
+		...props,
+		"data-inline-input": "select",
+		className: cn(inlineEditVariants({
+			variant,
+			status
+		}), className)
+	});
+}
+function InlineSelectContent(props) {
+	return /* @__PURE__ */ jsx(SelectContent, { ...props });
+}
+function InlineSelectValue(props) {
+	return /* @__PURE__ */ jsx(SelectValue, { ...props });
+}
+function InlineSelectItem(props) {
+	return /* @__PURE__ */ jsx(SelectItem, { ...props });
+}
+
+//#endregion
+export { InlineSelect, InlineSelectContent, InlineSelectItem, InlineSelectTrigger, InlineSelectValue };

package/dist/src/modules/inline/components/inputs/switch.client.d.mts

@@ -0,0 +1,21 @@
+import { Switch } from "../../../../components/ui/switch.client.mjs";
+import { useInlineEditOptions } from "../../hooks/use-inline.client.mjs";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { ComponentProps } from "react";
+import { z as z$1 } from "zod";
+import { DefaultError } from "@tanstack/react-query";
+
+//#region src/modules/inline/components/inputs/switch.client.d.ts
+type SwitchInlineTrigger = "commit";
+type InlineSwitchProps<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = ComponentProps<typeof Switch> & useInlineEditOptions<SwitchInlineTrigger, z$1.ZodBoolean | z$1.ZodNullable<z$1.ZodBoolean>, TData, TError, TVariables, TOnMutateResult>;
+declare function InlineSwitch<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown>({
+  initialValue,
+  variables,
+  mutation,
+  permission,
+  strategy,
+  disabled,
+  ...props
+}: InlineSwitchProps<TData, TError, TVariables, TOnMutateResult>): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { InlineSwitch };

package/dist/src/modules/inline/components/inputs/switch.client.mjs

@@ -0,0 +1,42 @@
+"use client";
+
+import { Switch } from "../../../../components/ui/switch.client.mjs";
+import { useInlineState } from "../../hooks/inline-state.client.mjs";
+import { useInlineAccess, useInlineMutation, useInlineStrategy } from "../../hooks/use-inline.client.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/modules/inline/components/inputs/switch.client.tsx
+function InlineSwitch({ initialValue, variables, mutation, permission, strategy, disabled, ...props }) {
+	const state = useInlineState(initialValue);
+	const access = useInlineAccess({
+		permission,
+		disabled
+	});
+	const { handleTrigger } = useInlineStrategy({
+		strategy,
+		state,
+		mutations: useInlineMutation({
+			variables,
+			mutation,
+			access,
+			state
+		}),
+		parser: {
+			decode: (value) => value,
+			encode: (value) => value
+		}
+	});
+	return /* @__PURE__ */ jsx(Switch, {
+		...props,
+		"data-inline-input": "switch",
+		"aria-invalid": state.isInvalid,
+		disabled: access.isDisabled,
+		checked: Boolean(state.value),
+		onCheckedChange: (checked) => {
+			handleTrigger("commit", checked ?? null);
+		}
+	});
+}
+
+//#endregion
+export { InlineSwitch };

package/dist/src/modules/inline/components/inputs/toggle.client.d.mts

@@ -0,0 +1,24 @@
+import { Toggle } from "../../../../components/ui/toggle.client.mjs";
+import { useInlineEditOptions } from "../../hooks/use-inline.client.mjs";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { ComponentProps } from "react";
+import { z as z$1 } from "zod";
+import { DefaultError } from "@tanstack/react-query";
+
+//#region src/modules/inline/components/inputs/toggle.client.d.ts
+type ToggleInlineTrigger = "commit";
+type InlineToggleProps<TSchema extends z$1.ZodType<boolean | null, boolean | null> = z$1.ZodType<boolean | null, boolean | null>, TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = Omit<ComponentProps<typeof Toggle>, "pressed" | "defaultPressed"> & useInlineEditOptions<ToggleInlineTrigger, TSchema, TData, TError, TVariables, TOnMutateResult>;
+declare function InlineToggle<TSchema extends z$1.ZodType<boolean | null, boolean | null> = z$1.ZodType<boolean | null, boolean | null>, TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown>({
+  initialValue,
+  variables,
+  mutation,
+  children,
+  permission,
+  disabled,
+  strategy,
+  className,
+  onPressedChange,
+  ...props
+}: InlineToggleProps<TSchema, TData, TError, TVariables, TOnMutateResult>): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { InlineToggle, InlineToggleProps };

package/dist/src/modules/inline/components/inputs/toggle.client.mjs

@@ -0,0 +1,47 @@
+"use client";
+
+import { cn } from "../../../../lib/utils/cn.mjs";
+import { Toggle } from "../../../../components/ui/toggle.client.mjs";
+import { useInlineState } from "../../hooks/inline-state.client.mjs";
+import { useInlineAccess, useInlineMutation, useInlineStrategy } from "../../hooks/use-inline.client.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/modules/inline/components/inputs/toggle.client.tsx
+function InlineToggle({ initialValue, variables, mutation, children, permission, disabled, strategy, className, onPressedChange, ...props }) {
+	const state = useInlineState(initialValue);
+	const access = useInlineAccess({
+		permission,
+		disabled
+	});
+	const { handleTrigger } = useInlineStrategy({
+		strategy,
+		state,
+		mutations: useInlineMutation({
+			variables,
+			mutation,
+			access,
+			state
+		}),
+		parser: {
+			decode: (value) => value,
+			encode: (value) => value
+		}
+	});
+	return /* @__PURE__ */ jsx(Toggle, {
+		...props,
+		"data-inline-input": "toggle",
+		className: cn("flex flex-wrap items-center justify-start gap-1", className),
+		"aria-invalid": state.isInvalid,
+		disabled: access.isDisabled,
+		variant: "outline",
+		pressed: Boolean(state.value),
+		onPressedChange: (nextValue) => {
+			handleTrigger("commit", nextValue);
+			onPressedChange?.(nextValue);
+		},
+		children
+	});
+}
+
+//#endregion
+export { InlineToggle };

package/dist/src/modules/inline/hooks/inline-provider.d.mts

@@ -0,0 +1,28 @@
+import { Permission } from "../../auth/lib/permissions.mjs";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import React from "react";
+
+//#region src/modules/inline/hooks/inline-provider.d.ts
+/**
+ * Shared inline config for a subtree.
+ */
+type InlineProviderContextParams = {
+  permission?: Permission;
+  disabled?: boolean;
+};
+declare const InlineProviderContext: React.Context<InlineProviderContextParams>;
+/**
+ * Inline Provider
+ */
+declare function useInlineProviderContext(): InlineProviderContextParams;
+/**
+ * Shared inline config provider.
+ */
+declare function InlineProvider({
+  children,
+  ...value
+}: InlineProviderContextParams & {
+  children: React.ReactNode;
+}): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { InlineProvider, InlineProviderContext, InlineProviderContextParams, useInlineProviderContext };

package/dist/src/modules/inline/hooks/inline-provider.mjs

@@ -0,0 +1,25 @@
+"use client";
+
+import { jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+
+//#region src/modules/inline/hooks/inline-provider.tsx
+const InlineProviderContext = createContext({});
+/**
+* Inline Provider
+*/
+function useInlineProviderContext() {
+	return useContext(InlineProviderContext);
+}
+/**
+* Shared inline config provider.
+*/
+function InlineProvider({ children, ...value }) {
+	return /* @__PURE__ */ jsx(InlineProviderContext.Provider, {
+		value,
+		children
+	});
+}
+
+//#endregion
+export { InlineProvider, InlineProviderContext, useInlineProviderContext };

package/dist/src/modules/inline/hooks/inline-state.client.d.mts

@@ -0,0 +1,30 @@
+import { IndicatorStatus } from "../../../lib/hooks/use-indicator.mjs";
+import * as react from "react";
+import { Dispatch, SetStateAction } from "react";
+
+//#region src/modules/inline/hooks/inline-state.client.d.ts
+/**
+ * Shared inline runtime state (status + validation error)
+ */
+type InlineStateContextType = {
+  status: IndicatorStatus;
+  setStatus: Dispatch<SetStateAction<IndicatorStatus>>;
+  error: string | undefined;
+  setError: Dispatch<SetStateAction<string | undefined>>;
+};
+declare const InlineStateContext: react.Context<InlineStateContextType | undefined>;
+/**
+ * Inline State Hook
+ */
+declare function useInlineState<TValue = never>(initialValue?: TValue): {
+  initialValue: TValue | undefined;
+  value: TValue | undefined;
+  setValue: Dispatch<SetStateAction<TValue | undefined>>;
+  isInvalid: boolean;
+  status: IndicatorStatus;
+  setStatus: Dispatch<SetStateAction<IndicatorStatus>>;
+  error: string | undefined;
+  setError: Dispatch<SetStateAction<string | undefined>>;
+};
+//#endregion
+export { InlineStateContext, InlineStateContextType, useInlineState };

package/dist/src/modules/inline/hooks/inline-state.client.mjs

@@ -0,0 +1,25 @@
+"use client";
+
+import { createContext, use, useState } from "react";
+
+//#region src/modules/inline/hooks/inline-state.client.tsx
+const InlineStateContext = createContext(void 0);
+/**
+* Inline State Hook
+*/
+function useInlineState(initialValue) {
+	const context = use(InlineStateContext);
+	if (!context) throw new Error("useInlineState must be used within an InlineStateContext.Provider");
+	const [value, setValue] = useState(initialValue);
+	const isInvalid = context.status === "error" || Boolean(context.error);
+	return {
+		...context,
+		initialValue,
+		value,
+		setValue,
+		isInvalid
+	};
+}
+
+//#endregion
+export { InlineStateContext, useInlineState };

package/dist/src/modules/inline/hooks/use-inline.client.d.mts

@@ -0,0 +1,144 @@
+import { Permission } from "../../auth/lib/permissions.mjs";
+import { useInlineState } from "./inline-state.client.mjs";
+import { z as z$1 } from "zod";
+import { DefaultError, MutationOptions } from "@tanstack/react-query";
+
+//#region src/modules/inline/hooks/use-inline.client.d.ts
+type InlineTrigger = "change" | "blur" | "commit";
+type MutationConfig<TAllowedTrigger extends InlineTrigger> = {
+  on: TAllowedTrigger;
+  debounceMs?: number;
+};
+type InlineStrategy<TSchema extends z$1.ZodType, TAllowedTrigger extends InlineTrigger> = {
+  validate?: Partial<Record<TAllowedTrigger, TSchema>>;
+  mutate: MutationConfig<TAllowedTrigger>;
+};
+/**
+ * Use the inline edit hook options.
+ */
+type useInlineEditOptions<TAllowedTrigger extends InlineTrigger, TSchema extends z$1.ZodType, TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = {
+  /**
+   * Initial value
+   */
+  initialValue?: z$1.input<TSchema>;
+  /**
+   * Transform validated schema value to mutation variables
+   */
+  variables?: (value: z$1.output<TSchema>) => TVariables;
+  /**
+   * Mutation options to execute on update
+   */
+  mutation: MutationOptions<TData, TError, TVariables, TOnMutateResult>;
+  /**
+   * Permission required to edit
+   */
+  permission?: Permission;
+  /**
+   * Disable inline editing
+   */
+  disabled?: boolean;
+  /**
+   * Trigger-based strategy
+   */
+  strategy: InlineStrategy<TSchema, TAllowedTrigger>;
+};
+/**
+ * Inline edit hook props
+ */
+type UseInlineEditProps<TAllowedTrigger extends InlineTrigger, TSchema extends z$1.ZodType, TValue, TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = useInlineEditOptions<TAllowedTrigger, TSchema, TData, TError, TVariables, TOnMutateResult> & {
+  parser: {
+    /**
+     * Transform the value from the result type to the value type
+     */
+    decode: (value: z$1.input<TSchema>) => TValue;
+    /**
+     * Transform the value from the value type to the result type
+     */
+    encode: (value: TValue) => z$1.input<TSchema>;
+  };
+};
+/**
+ * Resolves access and disabled state for inline editing.
+ *
+ * Responsibilities:
+ * - Merge local `permission`/`disabled` with provider-level config
+ * - Evaluate authorization via `usePermission`
+ * - Return `isAllowed` and final `isDisabled`
+ */
+type UseInlineAccessProps = {
+  permission?: Permission;
+  disabled?: boolean;
+};
+declare function useInlineAccess({
+  permission,
+  disabled
+}: UseInlineAccessProps): {
+  isAllowed: boolean;
+  isDisabled: boolean;
+};
+/**
+ * Encapsulates mutation lifecycle and side effects.
+ *
+ * Responsibilities:
+ * - Execute mutation with status transitions (`pending/success/error`)
+ * - Reset value on error to `initialValue`
+ * - Apply permission/disabled guards before mutating
+ * - Provide debounced and immediate mutation entry points
+ */
+type UseInlineMutationProps<TSchema extends z$1.ZodType, TValue, TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = {
+  variables?: (value: z$1.output<TSchema>) => TVariables;
+  mutation: MutationOptions<TData, TError, TVariables, TOnMutateResult>;
+  state: ReturnType<typeof useInlineState<TValue>>;
+  access: ReturnType<typeof useInlineAccess>;
+};
+declare function useInlineMutation<TSchema extends z$1.ZodType, TValue, TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown>({
+  variables,
+  mutation,
+  state,
+  access
+}: UseInlineMutationProps<TSchema, TValue, TData, TError, TVariables, TOnMutateResult>): {
+  mutate: (input: z$1.output<TSchema>) => void;
+};
+/**
+ * Handles trigger-driven validation and mutation orchestration.
+ *
+ * Responsibilities:
+ * - Validate by trigger (`change/blur/commit`) using provided strategy
+ * - Encode input through parser before validation
+ * - Update local value immediately on trigger
+ * - Mutate only when trigger matches `strategy.mutate.on`
+ */
+type UseInlineStrategyProps<TAllowedTrigger extends InlineTrigger, TSchema extends z$1.ZodType, TValue> = {
+  strategy: InlineStrategy<TSchema, TAllowedTrigger>;
+  parser: {
+    /**
+     * Transform the value from the result type to the value type
+     */
+    decode: (value: z$1.input<TSchema>) => TValue;
+    /**
+     * Transform the value from the value type to the result type
+     */
+    encode: (value: TValue) => z$1.input<TSchema>;
+  };
+  state: ReturnType<typeof useInlineState<TValue>>;
+  mutations: ReturnType<typeof useInlineMutation<TSchema, TValue>>;
+};
+declare function useInlineStrategy<TAllowedTrigger extends InlineTrigger, TSchema extends z$1.ZodType, TValue>({
+  strategy,
+  state,
+  mutations,
+  parser
+}: UseInlineStrategyProps<TAllowedTrigger, TSchema, TValue>): {
+  validate: <TValidator extends z$1.ZodType>(params: {
+    validator?: TValidator;
+    input: TValue | null;
+  }) => {
+    success: true;
+    data: z$1.output<TValidator>;
+  } | {
+    success: false;
+  };
+  handleTrigger: (trigger: TAllowedTrigger, input: TValue | null) => void;
+};
+//#endregion
+export { InlineStrategy, InlineTrigger, UseInlineAccessProps, UseInlineEditProps, UseInlineMutationProps, UseInlineStrategyProps, useInlineAccess, useInlineEditOptions, useInlineMutation, useInlineStrategy };

package/dist/src/modules/inline/hooks/use-inline.client.mjs

@@ -0,0 +1,125 @@
+"use client";
+
+import { usePermission } from "../../auth/hooks/use-permission.mjs";
+import { useAction } from "../../../lib/hooks/use-action.mjs";
+import { useInlineProviderContext } from "./inline-provider.mjs";
+import { useCallback } from "react";
+import { useDebouncedCallback } from "use-debounce";
+
+//#region src/modules/inline/hooks/use-inline.client.tsx
+function useInlineAccess({ permission, disabled }) {
+	const providerContext = useInlineProviderContext();
+	const isAllowed = usePermission({ permission: permission ?? providerContext.permission })?.success;
+	return {
+		isAllowed,
+		isDisabled: Boolean(providerContext.disabled || disabled || !isAllowed)
+	};
+}
+function useInlineMutation({ variables, mutation, state, access }) {
+	/**
+	* Wraps the mutation with status management and error handling.
+	* - Sets status to "pending" on mutate
+	* - On success, sets status to "success" and clears errors
+	* - On error, resets value to initial and sets status to "error"
+	*/
+	const action = useAction({
+		...mutation,
+		onMutate: async (...params) => {
+			state.setStatus("pending");
+			return await mutation.onMutate?.(...params);
+		},
+		onSuccess: async (...params) => {
+			state.setStatus("success");
+			state.setError(void 0);
+			return await mutation.onSuccess?.(...params);
+		},
+		onError: async (...params) => {
+			state.setValue(state.initialValue);
+			state.setStatus("error");
+			return await mutation.onError?.(...params);
+		}
+	});
+	return { mutate: useCallback((input) => {
+		if (!access.isAllowed) {
+			state.setStatus("error");
+			state.setError("Je hebt geen toestemming om dit te bewerken");
+			return;
+		}
+		if (access.isDisabled) return;
+		const nextVariables = variables ? variables(input) : input;
+		return action.mutate(nextVariables);
+	}, [
+		action,
+		access.isAllowed,
+		access.isDisabled,
+		state.setError,
+		state.setStatus,
+		variables
+	]) };
+}
+function useInlineStrategy({ strategy, state, mutations, parser }) {
+	/**
+	* Debounced mutation function that wraps `mutateInstant` with a debounce.
+	*/
+	const mutateDebounced = useDebouncedCallback(mutations.mutate, strategy.mutate.debounceMs ?? 0);
+	/**
+	* Main mutation function that checks if debounce is configured and calls the appropriate mutate function.
+	*/
+	const mutate = useCallback((input) => strategy.mutate.debounceMs ? mutateDebounced(input) : mutations.mutate(input), [
+		mutateDebounced,
+		mutations,
+		strategy.mutate.debounceMs
+	]);
+	/**
+	* Validate the input based on the trigger and strategy configuration.
+	*/
+	const validate = useCallback((params) => {
+		const encodedValue = params.input !== null ? parser.encode(params.input) : null;
+		if (!params.validator) {
+			state.setError(void 0);
+			state.setStatus((currentStatus) => currentStatus === "error" ? "idle" : currentStatus);
+			return {
+				success: true,
+				data: encodedValue
+			};
+		}
+		const result = params.validator.safeParse(encodedValue);
+		if (result.success) {
+			state.setError(void 0);
+			state.setStatus((currentStatus) => currentStatus === "error" ? "idle" : currentStatus);
+			return {
+				success: true,
+				data: result.data
+			};
+		}
+		const message = result.error.issues[0]?.message ?? "De ingevoerde waarde is ongeldig";
+		state.setStatus("error");
+		state.setError(message);
+		return { success: false };
+	}, [
+		parser,
+		state.setError,
+		state.setStatus
+	]);
+	return {
+		validate,
+		handleTrigger: useCallback((trigger, input) => {
+			state.setValue(input ?? void 0);
+			const validator = strategy.validate?.[trigger];
+			const result = validate({
+				validator,
+				input
+			});
+			if (!result.success || strategy.mutate.on !== trigger) return;
+			mutate(result.data);
+		}, [
+			mutate,
+			state.setValue,
+			strategy,
+			validate
+		])
+	};
+}
+
+//#endregion
+export { useInlineAccess, useInlineMutation, useInlineStrategy };

package/dist/src/modules/inline/lib/validators.d.mts

@@ -0,0 +1,56 @@
+import { ZodType, z as z$1 } from "zod";
+
+//#region src/modules/inline/lib/validators.d.ts
+/**
+ * Inline edit schema
+ */
+declare const inlineEditSchema: z$1.ZodObject<{
+  id: z$1.ZodString;
+}, z$1.core.$strip>;
+type InlineEditSchema<TValue> = z$1.infer<typeof inlineEditSchema> & {
+  value: TValue;
+};
+/**
+ * Create inline edit schema
+ */
+declare const createInlineEditSchema: <TValue extends ZodType>(value: TValue) => z$1.ZodObject<{
+  id: z$1.ZodString;
+  value: TValue;
+}, z$1.core.$strip>;
+/**
+ * Inline edit string schema
+ */
+declare const inlineEditStringSchema: z$1.ZodObject<{
+  id: z$1.ZodString;
+  value: z$1.ZodString;
+}, z$1.core.$strip>;
+/**
+ * Inline edit number schema
+ */
+declare const inlineEditNumberSchema: z$1.ZodObject<{
+  id: z$1.ZodString;
+  value: z$1.ZodNumber;
+}, z$1.core.$strip>;
+/**
+ * Inline edit boolean schema
+ */
+declare const inlineEditBooleanSchema: z$1.ZodObject<{
+  id: z$1.ZodString;
+  value: z$1.ZodBoolean;
+}, z$1.core.$strip>;
+/**
+ * Inline edit date schema
+ */
+declare const inlineEditDateSchema: z$1.ZodObject<{
+  id: z$1.ZodString;
+  value: z$1.ZodDate;
+}, z$1.core.$strip>;
+/**
+ * Inline edit json schema
+ */
+declare const inlineEditJsonSchema: z$1.ZodObject<{
+  id: z$1.ZodString;
+  value: z$1.ZodAny;
+}, z$1.core.$strip>;
+//#endregion
+export { InlineEditSchema, createInlineEditSchema, inlineEditBooleanSchema, inlineEditDateSchema, inlineEditJsonSchema, inlineEditNumberSchema, inlineEditStringSchema };

package/dist/src/modules/inline/lib/validators.mjs

@@ -0,0 +1,34 @@
+import { z as z$1 } from "zod";
+
+//#region src/modules/inline/lib/validators.ts
+/**
+* Inline edit schema
+*/
+const inlineEditSchema = z$1.object({ id: z$1.string() });
+/**
+* Create inline edit schema
+*/
+const createInlineEditSchema = (value) => inlineEditSchema.extend({ value });
+/**
+* Inline edit string schema
+*/
+const inlineEditStringSchema = createInlineEditSchema(z$1.string());
+/**
+* Inline edit number schema
+*/
+const inlineEditNumberSchema = createInlineEditSchema(z$1.number());
+/**
+* Inline edit boolean schema
+*/
+const inlineEditBooleanSchema = createInlineEditSchema(z$1.boolean());
+/**
+* Inline edit date schema
+*/
+const inlineEditDateSchema = createInlineEditSchema(z$1.date());
+/**
+* Inline edit json schema
+*/
+const inlineEditJsonSchema = createInlineEditSchema(z$1.any());
+
+//#endregion
+export { createInlineEditSchema, inlineEditBooleanSchema, inlineEditDateSchema, inlineEditJsonSchema, inlineEditNumberSchema, inlineEditStringSchema };

package/dist/src/modules/inline/lib/variants.d.mts

@@ -0,0 +1,11 @@
+import { VariantProps } from "class-variance-authority";
+import * as class_variance_authority_types0 from "class-variance-authority/types";
+
+//#region src/modules/inline/lib/variants.d.ts
+declare const inlineEditVariants: (props?: ({
+  variant?: "default" | "table" | null | undefined;
+  status?: "error" | "success" | "pending" | "idle" | null | undefined;
+} & class_variance_authority_types0.ClassProp) | undefined) => string;
+type InlineEditVariantsProps = VariantProps<typeof inlineEditVariants>;
+//#endregion
+export { InlineEditVariantsProps };