@tulip-systems/core 0.8.2 → 0.9.0

package/src/modules/commands/hooks/use-command-menu.client.tsx

@@ -1,252 +0,0 @@
-"use client";
-
-import type {
-  BulkCommandDefRenderParams,
-  CommandDef,
-  SingleCommandDefRenderParams,
-} from "../lib/definitions";
-
-/**
- * Command menu props
- */
-export type SingleCommandMenuProps<TData, TMeta> = {
-  data: TData;
-  commands: CommandDef<TData, TMeta>[];
-  meta?: TMeta;
-  onSuccess?: () => void;
-};
-
-export type BulkCommandMenuProps<TData, TMeta> = {
-  data: TData[];
-  commands: CommandDef<TData, TMeta>[];
-  meta?: TMeta;
-  onSuccess?: () => void;
-};
-
-/**
- * Check if a command has an id field in the data
- */
-function dataHasId<TData>(data: TData) {
-  return data && typeof data === "object" && "id" in data && typeof data.id === "string";
-}
-
-/**
- * Single command validation
- */
-type ValidateSingleCommandParams<TData, TMeta> = {
-  data: TData;
-  command: CommandDef<TData, TMeta> & { mode: "single" };
-};
-
-function validateSingleCommand<TData, TMeta>({
-  data,
-  command,
-}: ValidateSingleCommandParams<TData, TMeta>) {
-  const valid = command.conditions?.({ data });
-  return Array.isArray(valid) ? valid.every(Boolean) : (valid ?? true);
-}
-
-/**
- * Single command rendering
- */
-type RenderSingleCommandParams<TData, TMeta> = {
-  data: TData;
-  meta?: TMeta;
-  command: CommandDef<TData, TMeta> & { mode: "single" };
-};
-
-function renderSingleCommand<TData, TMeta>({
-  data,
-  command,
-  meta,
-}: RenderSingleCommandParams<TData, TMeta>) {
-  return command.render({
-    data,
-    meta: meta ?? ({} as TMeta),
-    ...(dataHasId(data) ? { id: (data as TData & { id: string }).id } : {}),
-  } as SingleCommandDefRenderParams<TData, TMeta>);
-}
-
-/**
- * Bulk command validation
- */
-type ValidateBulkCommandParams<TData, TMeta> = {
-  data: TData[];
-  command: CommandDef<TData, TMeta> & { mode: "bulk" };
-};
-
-function validateBulkCommand<TData, TMeta>({
-  data,
-  command,
-}: ValidateBulkCommandParams<TData, TMeta>) {
-  const valid = command.conditions?.({ data });
-  return Array.isArray(valid) ? valid.every(Boolean) : (valid ?? true);
-}
-
-/**
- * Bulk command rendering
- */
-type RenderBulkCommandParams<TData, TMeta> = {
-  data: TData[];
-  command: CommandDef<TData, TMeta> & { mode: "bulk" };
-  meta?: TMeta;
-};
-
-function renderBulkCommand<TData, TMeta>({
-  data,
-  command,
-  meta,
-}: RenderBulkCommandParams<TData, TMeta>) {
-  const ids = data.filter(dataHasId).map((data) => (data as TData & { id: string }).id);
-
-  return command.render({
-    data,
-    meta: meta ?? ({} as TMeta),
-    ...(ids.length > 0 ? { ids } : {}),
-  } as BulkCommandDefRenderParams<TData, TMeta>);
-}
-
-/**
- * useSingleCommandMenu
- */
-export function useSingleCommandMenu<TData, TMeta>({
-  data,
-  commands,
-  meta,
-}: SingleCommandMenuProps<TData, TMeta> & { data: TData }) {
-  // filter out commands that don't have valid conditions
-  const validCommands = commands.filter((command) =>
-    command.mode === "single"
-      ? validateSingleCommand({ data, command })
-      : validateBulkCommand({ data: [data], command }),
-  );
-
-  function renderCommand(command: (typeof validCommands)[number]) {
-    return command.mode === "single"
-      ? renderSingleCommand({ command, data, meta })
-      : renderBulkCommand({ command, data: [data], meta });
-  }
-
-  return [validCommands, renderCommand] as const;
-}
-
-/**
- * useBulkCommandMenu
- */
-export function useBulkCommandMenu<TData, TMeta>({
-  data,
-  commands,
-  meta,
-}: BulkCommandMenuProps<TData, TMeta>) {
-  /**
-   * Filter out commands that don't have valid conditions
-   */
-  const validCommands = commands
-    // filter out commands that have mode "bulk"
-    .filter((command) => command.mode === "bulk")
-    // filter out commands that don't have valid conditions
-    .filter((command) => command.mode === "bulk" && validateBulkCommand({ data, command }));
-
-  /**
-   * Render command
-   */
-  function renderCommand(command: (typeof commands)[number]) {
-    if (command.mode === "single") return null;
-
-    return renderBulkCommand({ command, data, meta });
-  }
-
-  return [validCommands, renderCommand] as const;
-}
-
-// export function useBulkCommandMenu<TData, TMeta>({
-//   data,
-//   commands,
-//   meta,
-// }: BulkCommandMenuProps<TData, TMeta>) {
-//   /**
-//    * Filter out commands that don't have valid conditions
-//    */
-//   const validCommands = useSuspenseQueries({
-//     queries: commands.flatMap((command) => ({
-//       queryKey: ["command", command],
-//       queryFn: async () => {
-//         const { mode, permission } = command;
-
-//         // filter out commands that have mode "bulk"
-//         if (mode !== "bulk") return null;
-
-//         // filter out commands that don't have valid conditions
-//         if (!validateBulkCommand({ data, command })) return null;
-
-//         // filter out commands that don't have a  permissions defined
-//         if (!permission) return command;
-
-//         // filter out commands that don't have valid permissions
-//         const session = await authClient.getSession();
-//         const userId = session.data?.user.id;
-//         const hasPermission = await authClient.admin.hasPermission({ permission, userId });
-//         if (!hasPermission.data?.success) return null;
-
-//         return command;
-//       },
-//     })),
-//     combine: (items) =>
-//       items.filter(({ data }) => data).map(({ data }) => data as NonNullable<typeof data>),
-//   });
-
-//   /**
-//    * Render command
-//    */
-//   const renderCommand = (command: (typeof validCommands)[number]) =>
-//     renderBulkCommand({ command, data, meta });
-
-//   return [validCommands, renderCommand] as const;
-// }
-
-//  */
-// export function useSingleCommandMenu<TData, TMeta>({
-//   data,
-//   commands,
-//   meta,
-// }: SingleCommandMenuProps<TData, TMeta> & { data: TData }) {
-//   /**
-//    * Filter out commands that don't have valid conditions
-//    */
-//   const validCommands = useSuspenseQueries({
-//     queries: commands.flatMap((command) => ({
-//       queryKey: ["command", command],
-//       queryFn: async () => {
-//         const { mode, permission } = command;
-
-//         // filter out commands that don't have valid conditions
-//         if (mode === "single" && !validateSingleCommand({ data, command })) return null;
-//         if (mode === "bulk" && !validateBulkCommand({ data: [data], command })) return null;
-
-//         // filter out commands that don't have a  permissions defined
-//         if (!permission) return command;
-
-//         // filter out commands that don't have valid permissions
-//         const session = await authClient.getSession();
-//         const userId = session.data?.user.id;
-//         const hasPermission = await authClient.admin.hasPermission({ permission, userId });
-//         if (!hasPermission.data?.success) return null;
-
-//         return command;
-//       },
-//     })),
-//     combine: (items) =>
-//       items.filter(({ data }) => data).map(({ data }) => data as NonNullable<typeof data>),
-//   });
-
-//   /**
-//    * Render command
-//    */
-//   function renderCommand(command: (typeof validCommands)[number]) {
-//     return command.mode === "single"
-//       ? renderSingleCommand({ command, data, meta })
-//       : renderBulkCommand({ command, data: [data], meta });
-//   }
-
-//   return [validCommands, renderCommand] as const;
-// }

package/src/modules/commands/hooks/use-command-mutation.client.tsx

@@ -1,65 +0,0 @@
-"use client";
-
-import type { DefaultError, MutationFunction, MutationOptions } from "@tanstack/react-query";
-import { useRouter } from "next/navigation";
-import { useAction } from "@/lib/hooks/use-action";
-import { useCommand } from "./context.client";
-
-export type CommandActionResult = Promise<unknown>;
-
-export type CommandAction<TInput = void> = (input: TInput) => CommandActionResult;
-export type BulkCommandAction = (params: { ids: string[] }) => CommandActionResult;
-
-export type CommandMutationMeta = {
-  router: ReturnType<typeof useRouter>;
-};
-
-export function useCommandMutation<
-  TData = unknown,
-  TError = DefaultError,
-  TVariables = void,
-  TOnMutateResult = unknown,
->(options?: MutationOptions<TData, TError, TVariables, TOnMutateResult>) {
-  const router = useRouter();
-  const commandContext = useCommand();
-
-  const mutation = useAction({
-    ...options,
-    mutationFn: options?.mutationFn as MutationFunction<TData, TVariables>,
-    onMutate: async (...params) => {
-      const result = options?.onMutate?.(...params);
-
-      commandContext.setStatus("pending");
-
-      return (await result) as TOnMutateResult;
-    },
-    onSuccess: async (...params) => {
-      const result = options?.onSuccess?.(...params);
-
-      commandContext.setStatus("success");
-      await commandContext.onSuccess?.();
-
-      return await result;
-    },
-    onError: async (...params) => {
-      const result = options?.onError?.(...params);
-
-      commandContext.setStatus("error");
-      await commandContext.onError?.();
-
-      return await result;
-    },
-    onSettled: async (...params) => {
-      const result = options?.onSettled?.(...params);
-
-      commandContext.setStatus("idle");
-
-      return await result;
-    },
-    meta: {
-      router,
-    } satisfies CommandMutationMeta,
-  });
-
-  return mutation;
-}

package/src/modules/commands/lib/definitions.ts

@@ -1,42 +0,0 @@
-import type { Permission } from "@/modules/auth/lib/permissions";
-
-/**
- * Command mode
- */
-export type CommandMode = Pick<CommandDef<never, never>, "mode">["mode"];
-
-/**
- * Command definition
- */
-export type CommandDef<TData = object, TMeta = object> = {
-  name: string;
-  permission?: Permission;
-} & (SingleCommandDef<TData, TMeta> | BulkCommandDef<TData, TMeta>);
-
-/**
- * Single command definition
- */
-export type SingleCommandDef<TData, TMeta> = {
-  mode: "single";
-  conditions?: (params: { data: TData }) => boolean | boolean[];
-  render: (params: SingleCommandDefRenderParams<TData, TMeta>) => React.ReactNode;
-};
-
-export type SingleCommandDefRenderParams<TData, TMeta> = {
-  data: TData;
-  meta: TMeta;
-} & (TData extends { id: string } ? { id: string } : object);
-
-/**
- * Bulk command definition
- */
-export type BulkCommandDef<TData, TMeta> = {
-  mode: "bulk";
-  conditions?: (params: { data: TData[] }) => boolean | boolean[];
-  render: (params: BulkCommandDefRenderParams<TData, TMeta>) => React.ReactNode;
-};
-
-export type BulkCommandDefRenderParams<TData, TMeta> = {
-  data: TData[];
-  meta: TMeta;
-} & (TData extends { id: string } ? { ids: string[] } : object);

package/src/modules/commands/lib/factory.ts

@@ -1,5 +0,0 @@
-import type { CommandDef } from "./definitions";
-
-export function createCommand<TData = object, TMeta = object>(config: CommandDef<TData, TMeta>) {
-  return { ...config };
-}

package/src/modules/commands/lib/schema.ts

@@ -1,23 +0,0 @@
-import { z } from "zod";
-
-/**
- * Send email schema
- */
-export const sendEmailSchema = z.object({
-  to: z.email({ message: "Ongeldig email adres" }),
-  //   z.array(
-  //       z
-  //         .string({
-  //           invalid_type_error: "Ongeldig email adres",
-  //           required_error: "Email adres is verplicht",
-  //         })
-  //         .email({ message: "Ongeldig email adres" }),
-  //     )
-  //     .min(1),
-  cc: z.email({ message: "Ongeldig email adres" }).optional().or(z.literal("")),
-  bcc: z.email({ message: "Ongeldig email adres" }).optional().or(z.literal("")),
-  subject: z.string().min(1),
-  body: z.string().min(1),
-});
-
-export type SendEmailSchema = z.infer<typeof sendEmailSchema>;

package/src/modules/commands/menus/context-menu.client.tsx

@@ -1,69 +0,0 @@
-"use client";
-
-import { type ComponentProps, useState } from "react";
-import {
-  ContextMenu,
-  ContextMenuContent,
-  ContextMenuItem,
-  ContextMenuTrigger,
-} from "@/components/ui/context-menu.client";
-import { cn } from "@/lib/entry";
-import { RenderCommand } from "../components/render-command";
-import { CommandContextProvider } from "../hooks/context.client";
-import {
-  type SingleCommandMenuProps,
-  useSingleCommandMenu,
-} from "../hooks/use-command-menu.client";
-
-/**
- * ContextCommandMenu
- */
-export const ContextCommandMenu = ContextMenu;
-
-/**
- * ContextCommandMenuTrigger
- */
-export const ContextCommandMenuTrigger = ContextMenuTrigger;
-
-/**
- * ContextCommandMenuContent
- */
-export function ContextCommandMenuContent<TData, TMeta>({
-  data,
-  commands,
-  meta,
-  className,
-  ...props
-}: SingleCommandMenuProps<TData, TMeta> & ComponentProps<typeof ContextMenuContent>) {
-  const [hasCommands, setHasCommands] = useState(true);
-
-  const [validCommands, renderCommand] = useSingleCommandMenu({ data, commands, meta });
-
-  if (!hasCommands) {
-    return (
-      <CommandContextProvider value={{ menu: "context" }}>
-        <ContextMenuContent {...props} className={cn("min-w-40", className)}>
-          <ContextMenuItem className="font-medium" disabled>
-            Geen acties beschikbaar
-          </ContextMenuItem>
-        </ContextMenuContent>
-      </CommandContextProvider>
-    );
-  }
-
-  return (
-    <CommandContextProvider value={{ menu: "context" }}>
-      <ContextMenuContent
-        {...props}
-        className={cn("min-w-40", className)}
-        ref={(ref) => {
-          if (ref?.childNodes.length === 0) setHasCommands(false);
-        }}
-      >
-        {validCommands.map((command) => (
-          <RenderCommand key={command.name} command={command} render={renderCommand} />
-        ))}
-      </ContextMenuContent>
-    </CommandContextProvider>
-  );
-}

package/src/modules/commands/menus/dropdown-menu.client.tsx

@@ -1,62 +0,0 @@
-"use client";
-
-import { MoreHorizontal } from "lucide-react";
-import React, { type ComponentProps } from "react";
-import { Skeleton } from "@/components/entry";
-import { Button } from "@/components/ui/button";
-import {
-  DropdownMenu,
-  DropdownMenuContent,
-  DropdownMenuTrigger,
-} from "@/components/ui/dropdown-menu.client";
-import { cn } from "@/lib/utils/cn";
-import { RenderCommand } from "../components/render-command";
-import { CommandContextProvider } from "../hooks/context.client";
-import {
-  type SingleCommandMenuProps,
-  useSingleCommandMenu,
-} from "../hooks/use-command-menu.client";
-
-export function DropdownCommandMenu<TData, TMeta>({
-  data,
-  commands,
-  meta,
-  className,
-  ...props
-}: SingleCommandMenuProps<TData, TMeta> & React.HTMLAttributes<HTMLElement>) {
-  const [open, setOpen] = React.useState(false);
-  const [validCommands, renderCommand] = useSingleCommandMenu({ data, commands, meta });
-
-  if (!validCommands.length) return null;
-
-  return (
-    <DropdownMenu open={open} onOpenChange={setOpen}>
-      <DropdownMenuTrigger asChild>
-        <Button
-          {...props}
-          variant="ghost"
-          className={cn("size-8 p-0 data-[state=open]:bg-secondary", className)}
-        >
-          <MoreHorizontal className="h-4 w-4" />
-          <span className="sr-only">Open menu</span>
-        </Button>
-      </DropdownMenuTrigger>
-
-      <DropdownMenuContent align="end" className="min-w-[10rem]">
-        <CommandContextProvider value={{ menu: "dropdown", onSuccess: () => setOpen(false) }}>
-          {validCommands.map((command) => (
-            <RenderCommand key={command.name} command={command} render={renderCommand} />
-          ))}
-        </CommandContextProvider>
-      </DropdownMenuContent>
-    </DropdownMenu>
-  );
-}
-
-export function DropdownCommandMenuLoading({ className, ...props }: ComponentProps<"div">) {
-  return (
-    <div {...props} className={cn("flex w-fit items-center", className)}>
-      <Skeleton className="h-8 w-8" />
-    </div>
-  );
-}

package/src/modules/commands/menus/floating-menu.client.tsx

@@ -1,54 +0,0 @@
-"use client";
-
-import { useRef } from "react";
-import { cn } from "@/lib/utils/cn";
-import { RenderCommand } from "../components/render-command";
-import { CommandContextProvider } from "../hooks/context.client";
-import { type BulkCommandMenuProps, useBulkCommandMenu } from "../hooks/use-command-menu.client";
-
-type FloatingCommandMenuProps<TData, TMeta> = BulkCommandMenuProps<TData, TMeta> &
-  React.HTMLAttributes<HTMLElement> & {
-    state: "open" | "closed";
-  };
-
-export function FloatingCommandMenu<TData, TMeta>({
-  data,
-  commands,
-  meta,
-  state,
-  onSuccess,
-  className,
-  ...props
-}: FloatingCommandMenuProps<TData, TMeta>) {
-  const hasCommands = useRef(true);
-
-  const [validCommands, renderCommand] = useBulkCommandMenu({ data, commands, meta });
-
-  return (
-    <div
-      {...props}
-      data-state={state}
-      className={cn(
-        "fixed right-0 bottom-12 left-0 z-50 mx-auto flex w-fit items-center rounded-xl border bg-muted/80 px-3 py-2 shadow-xl backdrop-blur-2xl data-[state=open]:flex data-[state=closed]:hidden",
-        className,
-      )}
-    >
-      <CommandContextProvider value={{ menu: "table", onSuccess }}>
-        <div
-          className="flex gap-2"
-          ref={(ref) => {
-            if (ref?.childNodes.length === 0) hasCommands.current = false;
-          }}
-        >
-          {validCommands.map((command) => (
-            <RenderCommand key={command.name} command={command} render={renderCommand} />
-          ))}
-        </div>
-
-        {!hasCommands.current && (
-          <span className="font-medium text-sm">Geen acties beschikbaar</span>
-        )}
-      </CommandContextProvider>
-    </div>
-  );
-}

package/src/modules/commands/menus/inline-menu.client.tsx

@@ -1,51 +0,0 @@
-"use client";
-
-import type React from "react";
-import type { ComponentProps } from "react";
-import { Skeleton } from "@/components/entry";
-import { cn } from "@/lib/utils/cn";
-import { RenderCommand } from "../components/render-command";
-import { CommandContextProvider } from "../hooks/context.client";
-import {
-  type SingleCommandMenuProps,
-  useSingleCommandMenu,
-} from "../hooks/use-command-menu.client";
-
-export type InlineCommandMenuProps<TData, TMeta> = SingleCommandMenuProps<TData, TMeta> &
-  React.HTMLAttributes<HTMLElement>;
-
-export function InlineCommandMenu<TData, TMeta>({
-  data,
-  meta,
-  commands,
-  className,
-  ...props
-}: InlineCommandMenuProps<TData, TMeta>) {
-  const [validCommands, renderCommand] = useSingleCommandMenu({ data, commands, meta });
-
-  if (!validCommands.length) return null;
-
-  return (
-    <div {...props} className={cn("flex w-fit items-center", className)}>
-      <div className="flex gap-2">
-        <CommandContextProvider value={{ menu: "inline" }}>
-          {validCommands.map((command) => (
-            <RenderCommand key={command.name} command={command} render={renderCommand} />
-          ))}
-        </CommandContextProvider>
-      </div>
-    </div>
-  );
-}
-
-export function InlineCommandMenuLoading({ className, ...props }: ComponentProps<"div">) {
-  return (
-    <div {...props} className={cn("flex w-fit items-center", className)}>
-      <div className="flex gap-2">
-        {Array.from({ length: 3 }).map((_, index) => (
-          <Skeleton key={index} className="h-8 w-8" />
-        ))}
-      </div>
-    </div>
-  );
-}

package/src/modules/commands/menus/responsive-menu.client.tsx

@@ -1,27 +0,0 @@
-"use client";
-
-import type { SingleCommandMenuProps } from "../hooks/use-command-menu.client";
-import { DropdownCommandMenu, DropdownCommandMenuLoading } from "./dropdown-menu.client";
-import { InlineCommandMenu, InlineCommandMenuLoading } from "./inline-menu.client";
-
-type ResponsiveCommandMenuProps<TData, TMeta> = SingleCommandMenuProps<TData, TMeta>;
-
-export function ResponsiveCommandMenu<TData, TMeta>(
-  props: ResponsiveCommandMenuProps<TData, TMeta>,
-) {
-  return (
-    <>
-      <InlineCommandMenu className="hidden xl:flex" {...props} />
-      <DropdownCommandMenu className="xl:hidden" {...props} />
-    </>
-  );
-}
-
-export function ResponsiveCommandMenuLoading() {
-  return (
-    <>
-      <InlineCommandMenuLoading className="hidden xl:flex" />
-      <DropdownCommandMenuLoading className="xl:hidden" />
-    </>
-  );
-}