@tulip-systems/core 0.8.3 → 0.10.0

package/src/modules/inline/components/inputs/combobox-dropdown.client.tsx

@@ -0,0 +1,112 @@
+"use client";
+
+import type { DefaultError } from "@tanstack/react-query";
+import type { z } from "zod";
+import {
+  ComboboxDropdown,
+  type ComboboxDropdownItem,
+  type ComboboxDropdownProps,
+} from "@/components/ui/combobox-dropdown.client";
+import { cn } from "@/lib/utils/cn";
+import { useInlineState } from "../../hooks/inline-state.client";
+import {
+  useInlineAccess,
+  type useInlineEditOptions,
+  useInlineMutation,
+  useInlineStrategy,
+} from "../../hooks/use-inline.client";
+import { type InlineEditVariantsProps, inlineEditVariants } from "../../lib/variants";
+
+type ComboboxDropdownInlineTrigger = "commit";
+
+type InlineStringSchema =
+  | z.ZodType<string | null, string | null>
+  | z.ZodType<string, string>;
+
+export type InlineEditComboboxDropdownProps<
+  TValue extends ComboboxDropdownItem,
+  TSchema extends InlineStringSchema = z.ZodType<string | null, string | null>,
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = unknown,
+  TOnMutateResult = unknown,
+> = useInlineEditOptions<
+  ComboboxDropdownInlineTrigger,
+  TSchema,
+  TData,
+  TError,
+  TVariables,
+  TOnMutateResult
+> &
+  InlineEditVariantsProps &
+  Omit<ComboboxDropdownProps<TValue>, "onSelect"> & {
+    onSelect?: ComboboxDropdownProps<TValue>["onSelect"];
+  };
+
+export function InlineComboboxDropdown<
+  TValue extends ComboboxDropdownItem,
+  TSchema extends InlineStringSchema = z.ZodType<string | null, string | null>,
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = unknown,
+  TOnMutateResult = unknown,
+>({
+  selectedItem,
+  variant,
+  className,
+  onSelect,
+  initialValue,
+  variables,
+  mutation,
+  permission,
+  strategy,
+  disabled,
+  ...props
+}: InlineEditComboboxDropdownProps<TValue, TSchema, TData, TError, TVariables, TOnMutateResult>) {
+  const state = useInlineState<string | null>(initialValue);
+  const access = useInlineAccess({ permission, disabled });
+  const mutations = useInlineMutation<
+    TSchema,
+    string | null,
+    TData,
+    TError,
+    TVariables,
+    TOnMutateResult
+  >({
+    variables,
+    mutation,
+    access,
+    state,
+  });
+
+  const { handleTrigger } = useInlineStrategy<
+    ComboboxDropdownInlineTrigger,
+    TSchema,
+    string | null
+  >({
+    strategy,
+    state,
+    mutations,
+    parser: {
+      decode: (value) => value,
+      encode: (value) => value as z.input<TSchema>,
+    },
+  });
+
+  const resolvedValue = state.value ?? initialValue ?? null;
+  const valueSelectedItem =
+    resolvedValue !== null ? props.items.find((item) => item.id === resolvedValue) : undefined;
+
+  return (
+    <ComboboxDropdown
+      {...props}
+      className={cn(inlineEditVariants({ variant, status: state.status }), className)}
+      disabled={access.isDisabled}
+      selectedItem={selectedItem ?? valueSelectedItem}
+      onSelect={(event) => {
+        handleTrigger("commit", event.id ?? null);
+        onSelect?.(event);
+      }}
+    />
+  );
+}

package/src/modules/inline/components/inputs/combobox.client.tsx

@@ -0,0 +1,100 @@
+"use client";
+
+import type { DefaultError } from "@tanstack/react-query";
+import type { z } from "zod";
+import { Combobox, type ComboboxProps } from "@/components/ui/combobox.client";
+import { useInlineState } from "../../hooks/inline-state.client";
+import {
+  useInlineAccess,
+  type useInlineEditOptions,
+  useInlineMutation,
+  useInlineStrategy,
+} from "../../hooks/use-inline.client";
+
+type ComboboxInlineTrigger = "commit";
+
+type InlineStringSchema =
+  | z.ZodType<string | null, string | null>
+  | z.ZodType<string, string>;
+
+export type InlineComboboxProps<
+  TValue,
+  TSchema extends InlineStringSchema = z.ZodType<string | null, string | null>,
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = unknown,
+  TOnMutateResult = unknown,
+> = useInlineEditOptions<
+  ComboboxInlineTrigger,
+  TSchema,
+  TData,
+  TError,
+  TVariables,
+  TOnMutateResult
+> &
+  Omit<ComboboxProps<TValue>, "value">;
+
+export function InlineCombobox<
+  TValue,
+  TSchema extends InlineStringSchema = z.ZodType<string | null, string | null>,
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = unknown,
+  TOnMutateResult = unknown,
+>({
+  initialValue,
+  variables,
+  mutation,
+  permission,
+  onSelect,
+  onBlur,
+  disabled,
+  strategy,
+  ...props
+}: InlineComboboxProps<TValue, TSchema, TData, TError, TVariables, TOnMutateResult>) {
+  const state = useInlineState<string | null>(initialValue);
+  const access = useInlineAccess({ permission, disabled });
+  const mutations = useInlineMutation<
+    TSchema,
+    string | null,
+    TData,
+    TError,
+    TVariables,
+    TOnMutateResult
+  >({
+    variables,
+    mutation,
+    access,
+    state,
+  });
+
+  const { handleTrigger } = useInlineStrategy<
+    ComboboxInlineTrigger,
+    TSchema,
+    string | null
+  >({
+    strategy,
+    state,
+    mutations,
+    parser: {
+      decode: (value) => value,
+      encode: (value) => value as z.input<TSchema>,
+    },
+  });
+
+  return (
+    <Combobox
+      {...props}
+      value={state.value}
+      disabled={access.isDisabled}
+      onSelect={(value) => {
+        handleTrigger("commit", (value as string | null | undefined) ?? null);
+        onSelect?.(value as TValue);
+      }}
+      onBlur={(e) => {
+        handleTrigger("commit", e.target.value ? e.target.value : null);
+        onBlur?.(e);
+      }}
+    />
+  );
+}

package/src/modules/inline/components/inputs/date-time.client.tsx

@@ -0,0 +1,102 @@
+"use client";
+
+import type { DefaultError } from "@tanstack/react-query";
+import { format } from "date-fns";
+import type { ComponentProps } from "react";
+import type { z } from "zod";
+import { DateTimeInput } from "@/components/ui/input-date-time.client";
+import { cn } from "@/lib/utils/cn";
+import { useInlineState } from "../../hooks/inline-state.client";
+import {
+  useInlineAccess,
+  type useInlineEditOptions,
+  useInlineMutation,
+  useInlineStrategy,
+} from "../../hooks/use-inline.client";
+import { type InlineEditVariantsProps, inlineEditVariants } from "../../lib/variants";
+
+type DateTimeInlineTrigger = "change" | "blur";
+
+type InlineDateTimeSchema =
+  | z.ZodType<Date | null, Date | null>
+  | z.ZodType<Date, Date>;
+
+type InlineDateTimeInputProps<
+  TSchema extends InlineDateTimeSchema = z.ZodType<Date | null, Date | null>,
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = unknown,
+  TOnMutateResult = unknown,
+> = ComponentProps<typeof DateTimeInput> &
+  useInlineEditOptions<
+    DateTimeInlineTrigger,
+    TSchema,
+    TData,
+    TError,
+    TVariables,
+    TOnMutateResult
+  > &
+  InlineEditVariantsProps;
+
+export function InlineDateTimeInput<
+  TSchema extends InlineDateTimeSchema = z.ZodType<Date | null, Date | null>,
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = unknown,
+  TOnMutateResult = unknown,
+>({
+  initialValue,
+  variables,
+  mutation,
+  permission,
+  variant,
+  className,
+  strategy,
+  disabled,
+  ...props
+}: InlineDateTimeInputProps<TSchema, TData, TError, TVariables, TOnMutateResult>) {
+  const state = useInlineState<string>(
+    initialValue ? format(initialValue, "yyyy-MM-dd'T'HH:mm") : "",
+  );
+  const access = useInlineAccess({ permission, disabled });
+  const mutations = useInlineMutation<
+    TSchema,
+    string,
+    TData,
+    TError,
+    TVariables,
+    TOnMutateResult
+  >({
+    variables,
+    mutation,
+    access,
+    state,
+  });
+
+  const { handleTrigger } = useInlineStrategy<
+    DateTimeInlineTrigger,
+    TSchema,
+    string
+  >({
+    strategy,
+    state,
+    mutations,
+    parser: {
+      decode: (date) => (date ? format(date, "yyyy-MM-dd'T'HH:mm") : ""),
+      encode: (dateTime) => (dateTime ? new Date(dateTime) : null) as z.input<TSchema>,
+    },
+  });
+
+  return (
+    <DateTimeInput
+      data-inline-input="date-time"
+      value={state.value ?? undefined}
+      className={cn(inlineEditVariants({ variant, status: state.status }), className)}
+      disabled={access.isDisabled}
+      aria-invalid={state.isInvalid}
+      onValueChange={(date) => handleTrigger("change", date ?? null)}
+      onValueBlur={(date) => handleTrigger("blur", date ?? null)}
+      {...props}
+    />
+  );
+}

package/src/modules/inline/components/inputs/date.client.tsx

@@ -0,0 +1,295 @@
+"use client";
+
+import type { DefaultError, MutationOptions } from "@tanstack/react-query";
+import type { Locale } from "date-fns";
+import { format, isValid, parse } from "date-fns";
+import { CalendarIcon } from "lucide-react";
+import type { ComponentProps, ReactNode } from "react";
+import { createContext, useContext, useEffect, useState } from "react";
+import type { z } from "zod";
+import { Button } from "@/components/ui/button";
+import { Calendar } from "@/components/ui/calendar.client";
+import { Input } from "@/components/ui/input";
+import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover.client";
+import { cn } from "@/lib/utils/cn";
+import type { Permission } from "@/modules/auth/lib/permissions";
+import { useInlineState } from "../../hooks/inline-state.client";
+import {
+  type InlineStrategy,
+  useInlineAccess,
+  useInlineMutation,
+  useInlineStrategy,
+} from "../../hooks/use-inline.client";
+import { type InlineEditVariantsProps, inlineEditVariants } from "../../lib/variants";
+
+type DateSchema = z.ZodType<string | null, string | null>;
+type DateInputTrigger = "change" | "blur";
+type DatePickerTrigger = "commit";
+
+type InlineDateInputStrategy = InlineStrategy<DateSchema, DateInputTrigger>;
+type InlineDatePickerStrategy = InlineStrategy<DateSchema, DatePickerTrigger>;
+
+const DEFAULT_INPUT_DATE_FORMAT = "dd/MM/yyyy";
+
+/**
+ * Inline Date Context
+ */
+type InlineDateContextType = {
+  state: ReturnType<typeof useInlineState<string | null>>;
+  mutations: ReturnType<typeof useInlineMutation<DateSchema, string | null>>;
+  access: ReturnType<typeof useInlineAccess>;
+  locale?: Locale;
+};
+
+const InlineDateContext = createContext<InlineDateContextType | undefined>(undefined);
+
+function useInlineDateContext() {
+  const context = useContext(InlineDateContext);
+  if (!context) {
+    throw new Error("InlineDate components must be used within InlineDateProvider");
+  }
+
+  return context;
+}
+
+/**
+ * Inline Date Provider
+ */
+export type InlineDateProviderProps<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = unknown,
+  TOnMutateResult = unknown,
+> = {
+  initialValue?: string | null;
+  variables?: (value: string | null) => TVariables;
+  mutation: MutationOptions<TData, TError, TVariables, TOnMutateResult>;
+  permission?: Permission;
+  disabled?: boolean;
+  locale?: Locale;
+  children: ReactNode;
+};
+
+export function InlineDateProvider<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = unknown,
+  TOnMutateResult = unknown,
+>({
+  variables,
+  mutation,
+  permission,
+  disabled,
+  locale,
+  initialValue,
+  children,
+}: InlineDateProviderProps<TData, TError, TVariables, TOnMutateResult>) {
+  const state = useInlineState<string | null>(initialValue);
+  const access = useInlineAccess({ permission, disabled });
+  const mutations = useInlineMutation<
+    DateSchema,
+    string | null,
+    TData,
+    TError,
+    TVariables,
+    TOnMutateResult
+  >({ variables, mutation, access, state });
+
+  return (
+    <InlineDateContext value={{ state, access, mutations, locale }}>{children}</InlineDateContext>
+  );
+}
+
+/**
+ * The inline edit date input component.
+ */
+export type InlineDateInputFieldProps = Omit<
+  ComponentProps<typeof Input>,
+  "type" | "value" | "defaultValue" | "onChange" | "onBlur"
+> &
+  InlineEditVariantsProps & {
+    strategy: InlineDateInputStrategy;
+    dateFormat?: string;
+  };
+
+export function InlineDateInputField({
+  strategy,
+  dateFormat = DEFAULT_INPUT_DATE_FORMAT,
+  variant,
+  className,
+  ...props
+}: InlineDateInputFieldProps) {
+  const { state, access, mutations } = useInlineDateContext();
+
+  const [draftValue, setDraftValue] = useState(() =>
+    formatDisplayDate(state.value, dateFormat),
+  );
+  const [isLocallyInvalid, setIsLocallyInvalid] = useState(false);
+  const [isFocused, setIsFocused] = useState(false);
+
+  useEffect(() => {
+    if (isFocused || isLocallyInvalid) return;
+    setDraftValue(formatDisplayDate(state.value, dateFormat));
+  }, [dateFormat, isFocused, isLocallyInvalid, state.value]);
+
+  const { handleTrigger } = useInlineStrategy<DateInputTrigger, DateSchema, string | null>({
+    strategy,
+    state,
+    mutations,
+    parser: {
+      encode: (date) => date,
+      decode: (input) => input,
+    },
+  });
+
+  const isInvalid = state.isInvalid || isLocallyInvalid;
+
+  return (
+    <Input
+      {...props}
+      data-inline-input="date-composed-input"
+      type="text"
+      value={draftValue}
+      aria-invalid={isInvalid}
+      disabled={access.isDisabled}
+      className={cn(
+        inlineEditVariants({ variant, status: state.status }),
+        isInvalid && "text-destructive",
+        className,
+      )}
+      onFocus={() => setIsFocused(true)}
+      onChange={(e) => {
+        const nextValue = e.target.value;
+        const parsedValue = parseDisplayDate(nextValue, dateFormat);
+
+        setDraftValue(nextValue);
+        setIsLocallyInvalid(false);
+
+        if (parsedValue !== undefined) handleTrigger("change", parsedValue);
+      }}
+      onBlur={(e) => {
+        const parsedValue = parseDisplayDate(e.target.value, dateFormat);
+        setIsFocused(false);
+
+        if (parsedValue === undefined) {
+          setIsLocallyInvalid(true);
+          return;
+        }
+
+        if (parsedValue === null) {
+          setIsLocallyInvalid(false);
+          setDraftValue("");
+          handleTrigger("blur", null);
+          return;
+        }
+
+        setIsLocallyInvalid(false);
+        setDraftValue(formatDisplayDate(parsedValue, dateFormat));
+        handleTrigger("blur", parsedValue);
+      }}
+    />
+  );
+}
+
+/**
+ * The inline edit date picker component.
+ */
+export type InlineDatePickerFieldProps = Omit<ComponentProps<typeof Button>, "type"> &
+  InlineEditVariantsProps & {
+    strategy: InlineDatePickerStrategy;
+  };
+
+export function InlineDatePickerField({
+  strategy,
+  className,
+  variant,
+  ...props
+}: InlineDatePickerFieldProps) {
+  const { state, access, mutations, locale } = useInlineDateContext();
+  const selectedDate = toCalendarDate(state.value);
+
+  const { handleTrigger } = useInlineStrategy<DatePickerTrigger, DateSchema, string | null>({
+    strategy,
+    state,
+    mutations,
+    parser: {
+      encode: (date) => date,
+      decode: (input) => input,
+    },
+  });
+
+  return (
+    <Popover>
+      <PopoverTrigger asChild>
+        <Button
+          {...props}
+          data-inline-input="date-composed-picker"
+          type="button"
+          variant="ghost"
+          aria-label="Open kalender"
+          aria-invalid={state.isInvalid}
+          disabled={access.isDisabled}
+          className={cn(
+            "absolute top-0 right-0 bottom-0 opacity-50",
+            !state.value && "text-muted-foreground",
+            inlineEditVariants({ variant, status: state.status }),
+            className,
+          )}
+        >
+          <CalendarIcon className="h-4 w-4" />
+        </Button>
+      </PopoverTrigger>
+
+      <PopoverContent className="w-auto p-0">
+        <Calendar
+          mode="single"
+          autoFocus
+          selected={selectedDate}
+          defaultMonth={selectedDate}
+          locale={locale}
+          disabled={access.isDisabled}
+          onSelect={(selectedDate) => {
+            if (!selectedDate) return;
+            handleTrigger("commit", format(selectedDate, "yyyy-MM-dd"));
+          }}
+        />
+      </PopoverContent>
+    </Popover>
+  );
+}
+
+/**
+ * Helper functions
+ */
+function toCalendarDate(value: string | null | undefined): Date | undefined {
+  if (!value) return undefined;
+
+  const date = parse(value, "yyyy-MM-dd", new Date());
+  if (!isValid(date)) return undefined;
+
+  return format(date, "yyyy-MM-dd") === value ? date : undefined;
+}
+
+function formatDisplayDate(
+  value: string | null | undefined,
+  dateFormat: string,
+): string {
+  const date = toCalendarDate(value);
+  if (!date) return "";
+
+  return format(date, dateFormat);
+}
+
+function parseDisplayDate(
+  value: string,
+  dateFormat: string,
+): string | null | undefined {
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+
+  const parsedDate = parse(trimmed, dateFormat, new Date());
+  if (!isValid(parsedDate)) return undefined;
+  if (format(parsedDate, dateFormat) !== trimmed) return undefined;
+
+  return format(parsedDate, "yyyy-MM-dd");
+}

package/src/modules/inline/components/inputs/editor.client.tsx

@@ -0,0 +1,105 @@
+"use client";
+
+import type { DefaultError } from "@tanstack/react-query";
+import type { z } from "zod";
+import { Editor, type EditorProps } from "@/components/editor/components/editor.client";
+import type { EditorJSONContent } from "@/components/editor/lib/types";
+import { cn } from "@/lib/utils/cn";
+import { useInlineState } from "../../hooks/inline-state.client";
+import {
+  useInlineAccess,
+  type useInlineEditOptions,
+  useInlineMutation,
+  useInlineStrategy,
+} from "../../hooks/use-inline.client";
+import { type InlineEditVariantsProps, inlineEditVariants } from "../../lib/variants";
+
+type EditorInlineTrigger = "change" | "blur";
+
+type InlineEditorSchema =
+  | z.ZodType<EditorJSONContent | null, EditorJSONContent | null>
+  | z.ZodType<EditorJSONContent, EditorJSONContent>;
+
+export type InlineEditorProps<
+  TSchema extends InlineEditorSchema = z.ZodType<EditorJSONContent | null, EditorJSONContent | null>,
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = unknown,
+  TOnMutateResult = unknown,
+> = useInlineEditOptions<
+  EditorInlineTrigger,
+  TSchema,
+  TData,
+  TError,
+  TVariables,
+  TOnMutateResult
+> &
+  InlineEditVariantsProps &
+  Omit<EditorProps, "value" | "onUpdate" | "onBlur" | "variant">;
+
+export function InlineEditor<
+  TSchema extends InlineEditorSchema = z.ZodType<EditorJSONContent | null, EditorJSONContent | null>,
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = unknown,
+  TOnMutateResult = unknown,
+>({
+  initialValue,
+  variables,
+  mutation,
+  extensions,
+  variant,
+  disabled,
+  permission,
+  strategy,
+  className,
+  children,
+}: InlineEditorProps<TSchema, TData, TError, TVariables, TOnMutateResult>) {
+  const state = useInlineState<EditorJSONContent | null>(initialValue);
+  const access = useInlineAccess({ permission, disabled });
+  const mutations = useInlineMutation<
+    TSchema,
+    EditorJSONContent | null,
+    TData,
+    TError,
+    TVariables,
+    TOnMutateResult
+  >({
+    variables,
+    mutation,
+    access,
+    state,
+  });
+
+  const { handleTrigger } = useInlineStrategy<
+    EditorInlineTrigger,
+    TSchema,
+    EditorJSONContent | null
+  >({
+    strategy,
+    state,
+    mutations,
+    parser: {
+      decode: (content) => content,
+      encode: (content) => content as z.input<TSchema>,
+    },
+  });
+
+  return (
+    <Editor
+      value={state.value}
+      extensions={extensions}
+      onUpdate={(nextValue) => handleTrigger("change", nextValue)}
+      onBlur={(nextValue) => handleTrigger("blur", nextValue)}
+      className={cn(inlineEditVariants({ variant, status: state.status }), className)}
+      disabled={access.isDisabled}
+      variant={variant}
+      attributes={{
+        "data-inline-input": "editor",
+        "aria-invalid": state.isInvalid ? "true" : "false",
+      }}
+    >
+      {children}
+    </Editor>
+  );
+}