@spaceinvoices/react-ui 0.4.12 → 0.4.32

package/src/components/tax-reports/slovenia-yearly-export-form.tsx

@@ -60,6 +60,7 @@ const translations = {
     "slovenia-yearly.profile.vat-profile.placeholder": "Optional",
     "slovenia-yearly.profile.vat-profile.options.standard": "Standard VAT subject",
     "slovenia-yearly.profile.vat-profile.options.special_vat_identified": "Special VAT subject",
+    "slovenia-yearly.profile.vat-profile.options.non_vat_subject": "Non-VAT subject",
     "slovenia-yearly.profile.insurance-basis.label": "Insurance basis",
     "slovenia-yearly.profile.insurance-basis.placeholder": "Select insurance basis",
     "slovenia-yearly.profile.insurance-basis.options.full_time_self_employed": "Full-time self-employed",
@@ -136,6 +137,7 @@ const translations = {
     "slovenia-yearly.profile.vat-profile.placeholder": "Neobvezno",
     "slovenia-yearly.profile.vat-profile.options.standard": "Običajni DDV zavezanec",
     "slovenia-yearly.profile.vat-profile.options.special_vat_identified": "Posebni DDV zavezanec",
+    "slovenia-yearly.profile.vat-profile.options.non_vat_subject": "Ne-DDV zavezanec",
     "slovenia-yearly.profile.insurance-basis.label": "Zavarovalna podlaga",
     "slovenia-yearly.profile.insurance-basis.placeholder": "Izberi zavarovalno podlago",
     "slovenia-yearly.profile.insurance-basis.options.full_time_self_employed": "Polni s.p.",
@@ -212,6 +214,7 @@ const translations = {
     "slovenia-yearly.profile.vat-profile.placeholder": "Opcionalno",
     "slovenia-yearly.profile.vat-profile.options.standard": "Standardni PDV obveznik",
     "slovenia-yearly.profile.vat-profile.options.special_vat_identified": "Posebni PDV obveznik",
+    "slovenia-yearly.profile.vat-profile.options.non_vat_subject": "Nije PDV obveznik",
     "slovenia-yearly.profile.insurance-basis.label": "Osnova osiguranja",
     "slovenia-yearly.profile.insurance-basis.placeholder": "Odaberi osnovu osiguranja",
     "slovenia-yearly.profile.insurance-basis.options.full_time_self_employed": "Puni samostalni obrt",

package/src/components/tax-reports/slovenia-yearly-review-step.tsx

@@ -1,5 +1,6 @@
 import { AlertCircle, TriangleAlert } from "lucide-react";
 import type { ChangeEvent } from "react";
+import { getDisplayDocumentNumber } from "@/ui/lib/document-display";
 import { Alert, AlertDescription, AlertTitle } from "../ui/alert";
 import { Input } from "../ui/input";
 import { Label } from "../ui/label";
@@ -196,7 +197,7 @@ export function SloveniaYearlyReviewStep({
                       >
                         <div className="flex flex-wrap items-center justify-between gap-2">
                           <div className="font-medium">
-                            {document.number} ·{" "}
+                            {getDisplayDocumentNumber(document, t)} ·{" "}
                             {document.type === "invoice"
                               ? t("slovenia-yearly.review.issues.document-type.invoice")
                               : t("slovenia-yearly.review.issues.document-type.credit-note")}

package/src/components/ui/form.tsx

@@ -3,16 +3,7 @@
 import * as React from "react"
 import type * as LabelPrimitive from "@radix-ui/react-label"
 import { Slot } from "@radix-ui/react-slot"
-import {
-  Controller,
-  type ControllerProps,
-  type FieldErrors,
-  type FieldPath,
-  type FieldValues,
-  FormProvider,
-  type UseFormReturn,
-  useFormContext,
-} from "react-hook-form"
+import { Controller, type ControllerProps, type FieldErrors, type FieldPath, type FieldValues, FormProvider, useFormContext } from "react-hook-form"
 
 import { cn } from "@/ui/lib/utils"
 import { Label } from "@/ui/components/ui/label"
@@ -20,16 +11,17 @@ import { getValidationLocale, translateZodValidationMessage } from "@/ui/lib/zod
 
 const ValidationLocaleContext = React.createContext<string | undefined>(undefined)
 
-type FormProps = UseFormReturn<any> & {
+type FormProps = {
   children: React.ReactNode
   locale?: string
+  [key: string]: any
 }
 
 function Form({ locale, ...props }: FormProps) {
   const { watch, getFieldState, clearErrors, trigger } = props
 
   React.useEffect(() => {
-    const subscription = watch((_value, { name, type }) => {
+    const subscription = watch((_value: unknown, { name, type }: { name?: string; type?: string }) => {
       if (!name || type !== "change") return
 
       const fieldState = getFieldState(name)
@@ -49,7 +41,7 @@ function Form({ locale, ...props }: FormProps) {
 
   return (
     <ValidationLocaleContext.Provider value={locale}>
-      <FormProvider {...props} />
+      <FormProvider {...(props as any)} />
     </ValidationLocaleContext.Provider>
   )
 }

package/src/components/ui/select.tsx

@@ -119,7 +119,6 @@ function SelectValue({
     <SelectPrimitive.Value
       data-slot="select-value"
       className={cn("flex flex-1 text-left", className)}
-      // @ts-expect-error - Base UI SelectValue accepts placeholder at runtime
       placeholder={placeholder}
       {...props}
     />

package/src/components/ui/sidebar.tsx

@@ -556,7 +556,7 @@ function SidebarMenuButton({
       },
       props
     ),
-    render: !tooltip ? renderProp : TooltipTrigger,
+    render: renderProp,
     state: {
       slot: "sidebar-menu-button",
       sidebar: "menu-button",
@@ -577,7 +577,7 @@ function SidebarMenuButton({
 
   return (
     <Tooltip>
-      {comp}
+      <TooltipTrigger asChild>{comp}</TooltipTrigger>
       <TooltipContent
         side="right"
         align="center"

package/src/generate-schemas.ts

@@ -5,22 +5,52 @@ import path from "node:path";
 const SCHEMAS_DIR = "./src/generated/schemas";
 const GENERATED_DIR = "./generated";
 
-type SchemaGroups = {
-  [key: string]: string[];
+type OperationSchemaEntry = {
+  alias: string;
+  schemaName: string;
+  groupName: string;
 };
 
-// Helper to get group name from schema name
-const getGroupName = (schemaName: string): string => {
+// Helper to get group name from schema name / alias
+const getGroupName = (schemaName: string, alias?: string): string => {
   // Remove _Body and extract the resource name (e.g., Customer from createCustomer)
-  return schemaName.replace(/(create|patch|update|delete)([A-Z][a-zA-Z]+)_Body/, "$2").toLowerCase();
-};
+  if (schemaName.endsWith("_Body")) {
+    return schemaName.replace(/(create|patch|update|delete)([A-Z][a-zA-Z]+)_Body/, "$2").toLowerCase();
+  }
+
+  if (alias) {
+    return alias
+      .replace(/^(create|patch|update|delete|register|upload|send|preview|render|accept|add|start|authorize|sync|void)/, "")
+      .toLowerCase();
+  }
 
-// Helper to format operation name
-const formatOperationName = (operationType: string, resourceName: string): string => {
-  // Convert to proper case format (e.g., createCustomer)
-  return `${operationType}${resourceName}`;
+  return schemaName.toLowerCase();
 };
 
+function extractOperationSchemaEntries(fullContent: string): OperationSchemaEntry[] {
+  const endpointBlockRegex = /  \{[\s\S]*?\n  \},?/g;
+  const dedupedEntries = new Map<string, OperationSchemaEntry>();
+
+  for (const block of fullContent.match(endpointBlockRegex) ?? []) {
+    const aliasMatch = block.match(/alias:\s*"([^"]+)"/);
+    const bodySchemaMatch = block.match(/type:\s*"Body",[\s\S]*?schema:\s*((?:[A-Z][A-Za-z0-9_]*|[a-z][A-Za-z0-9]*_Body))/);
+
+    if (!aliasMatch || !bodySchemaMatch) {
+      continue;
+    }
+
+    const alias = aliasMatch[1];
+    const schemaName = bodySchemaMatch[1];
+    dedupedEntries.set(alias, {
+      alias,
+      schemaName,
+      groupName: getGroupName(schemaName, alias),
+    });
+  }
+
+  return [...dedupedEntries.values()];
+}
+
 async function main() {
   // Ensure directories exist
   await fs.mkdir(SCHEMAS_DIR, { recursive: true });
@@ -70,6 +100,21 @@ async function main() {
   // Fix Zod v3 record syntax - z.record(z.string()) -> z.record(z.string(), z.any())
   content = content.replace(/z\.record\(z\.string\(\)\)/g, "z.record(z.string(), z.any())");
 
+  // Fix nullable enums emitted as z.enum([... , null]), which newer Zod typings reject.
+  content = content.replace(/z\.enum\(\[([\s\S]*?)\]\)/g, (match, values) => {
+    if (!/\bnull\b/.test(values)) {
+      return match;
+    }
+
+    const enumValues = values
+      .split(",")
+      .map((value: string) => value.trim())
+      .filter((value: string) => value.length > 0 && value !== "null")
+      .join(", ");
+
+    return `z.union([z.enum([${enumValues}]), z.null()])`;
+  });
+
   // Remove .default({}) from metadata fields to keep them truly optional
   // When using .optional().default({}), Zod infers the type as required since it always has a value after parsing
   // We want metadata to be optional in the form type to match SDK types
@@ -85,13 +130,6 @@ async function main() {
   content = content.replace(/: EuTaxRules,/g, ": z.any().optional(),");
   content = content.replace(/z\.array\(EntityBankAccount\)/g, "z.array(z.any())");
 
-  // Extract just the schema definitions
-  const schemaMatch = content.match(/export const schemas = {([^}]+)}/s);
-  if (!schemaMatch) {
-    throw new Error("Could not find schema definitions in generated file");
-  }
-  const schemaSection = schemaMatch[1];
-
   // Helper function to find schema dependencies (schemas referenced by other schemas)
   function findSchemaDependencies(schemaName: string, fullContent: string): string[] {
     const dependencies: string[] = [];
@@ -117,30 +155,50 @@ async function main() {
     return dependencies;
   }
 
-  // Parse schema names and group them
-  const schemasByGroup = schemaSection
-    .split(",\n")
-    .map((line) => line.trim())
-    .filter((line) => line.includes("_Body"))
-    .map((line) => line.split(":")[0].trim())
-    .reduce<SchemaGroups>((groups, schemaName) => {
-      const groupName = getGroupName(schemaName);
-      if (!groups[groupName]) {
-        groups[groupName] = [];
+  const operationEntries = extractOperationSchemaEntries(content);
+  if (operationEntries.length === 0) {
+    throw new Error("Could not find endpoint body schemas in generated file");
+  }
+
+  const schemasByGroup = operationEntries.reduce<Record<string, OperationSchemaEntry[]>>((groups, entry) => {
+    if (!groups[entry.groupName]) {
+      groups[entry.groupName] = [];
+    }
+
+    groups[entry.groupName].push(entry);
+    return groups;
+  }, {});
+
+  // Remove previously generated schema files so stale outputs don't survive generator changes.
+  for (const file of await fs.readdir(SCHEMAS_DIR)) {
+    if (file.endsWith(".ts")) {
+      await fs.unlink(path.join(SCHEMAS_DIR, file));
+    }
+  }
+
+  // Create files for each group
+  for (const [groupName, groupEntries] of Object.entries(schemasByGroup)) {
+    const primaryEntryBySchemaName = new Map<string, OperationSchemaEntry>();
+    for (const entry of groupEntries) {
+      if (!primaryEntryBySchemaName.has(entry.schemaName)) {
+        primaryEntryBySchemaName.set(entry.schemaName, entry);
       }
+    }
 
-      // Add the main schema
-      groups[groupName].push(schemaName);
+    const schemaNames = groupEntries.reduce<string[]>((acc, entry) => {
+      if (!acc.includes(entry.schemaName)) {
+        acc.push(entry.schemaName);
+      }
 
       // Find and add dependencies
-      const deps = findSchemaDependencies(schemaName, content);
+      const deps = findSchemaDependencies(entry.schemaName, content);
       const queue = [...deps];
       const processed = new Set(deps);
 
       while (queue.length > 0) {
         const currentDep = queue.shift()!;
-        if (!groups[groupName].includes(currentDep)) {
-          groups[groupName].push(currentDep);
+        if (!acc.includes(currentDep)) {
+          acc.push(currentDep);
         }
 
         const nestedDeps = findSchemaDependencies(currentDep, content);
@@ -152,38 +210,12 @@ async function main() {
         }
       }
 
-      return groups;
-    }, {});
-
-  // Topological sort: ensures each schema is defined after all schemas it depends on
-  function topologicalSort(names: string[], fullContent: string): string[] {
-    const visited = new Set<string>();
-    const result: string[] = [];
+      return acc;
+    }, []);
 
-    function visit(name: string) {
-      if (visited.has(name)) return;
-      visited.add(name);
-      // Visit dependencies first so they appear earlier in the output
-      const deps = findSchemaDependencies(name, fullContent);
-      for (const dep of deps) {
-        if (names.includes(dep)) {
-          visit(dep);
-        }
-      }
-      result.push(name);
-    }
-
-    for (const name of names) {
-      visit(name);
-    }
-    return result;
-  }
-
-  // Create files for each group
-  for (const [groupName, schemaNames] of Object.entries(schemasByGroup)) {
     // Separate dependencies from operation schemas
-    const dependencies = schemaNames.filter((name) => !name.includes("_Body"));
-    const operations = schemaNames.filter((name) => name.includes("_Body"));
+    const dependencies = schemaNames.filter((name) => !groupEntries.some((entry) => entry.schemaName === name));
+    const operations = [...new Set(groupEntries.map((entry) => entry.schemaName))];
 
     // Topologically sort dependencies so each schema is defined after its own dependencies
     const sortedDependencies = topologicalSort(dependencies, content);
@@ -193,11 +225,9 @@ async function main() {
 
     const schemas = orderedNames
       .map((schemaName) => {
-        // Check if this is an operation schema or a dependency
-        const operationMatch = schemaName.match(/(create|patch|update|delete|register|upload|send|preview|render)/i);
-        const isOperationSchema = operationMatch && schemaName.includes("_Body");
+        const operationEntry = primaryEntryBySchemaName.get(schemaName);
 
-        if (!isOperationSchema) {
+        if (!operationEntry) {
           // This is a dependency schema, just extract its definition
           const schemaDefinitionMatch = content.match(new RegExp(`const ${schemaName} = ([^;]+);`, "s"));
           if (!schemaDefinitionMatch) {
@@ -211,20 +241,9 @@ const ${schemaName} = ${schemaDefinitionMatch[1]};
 `;
         }
 
-        // Handle operation schemas
-        const resourceMatch = schemaName.match(/[A-Z][a-zA-Z]+_Body/);
-        if (!resourceMatch) {
-          console.warn(`Warning: Invalid schema name format: ${schemaName}`);
-          return null;
-        }
-
-        const operationType = operationMatch[1].toLowerCase();
-        const resourceName = resourceMatch[0].replace("_Body", "");
-        const operationName = formatOperationName(operationType, resourceName);
-
-        const schemaDefinitionMatch = content.match(new RegExp(`const ${schemaName} = ([^;]+);`, "s"));
+        const schemaDefinitionMatch = content.match(new RegExp(`const ${operationEntry.schemaName} = ([^;]+);`, "s"));
         if (!schemaDefinitionMatch) {
-          console.warn(`Warning: Could not find schema definition for ${schemaName}`);
+          console.warn(`Warning: Could not find schema definition for ${operationEntry.schemaName}`);
           return null;
         }
 
@@ -245,35 +264,26 @@ const ${schemaName} = ${schemaDefinitionMatch[1]};
         // Add min length to country
         schemaDefinition = schemaDefinition.replace(/country: z\.string\(\)(?!\.min)/g, "country: z.string().min(1)");
 
+        const operationName = operationEntry.alias;
+
         return `
-// Schema for ${operationType} ${resourceName.toLowerCase()} operation
+// Schema for ${operationName} operation
 const ${operationName}SchemaDefinition = ${schemaDefinition};
-
-// Type for ${operationType} ${resourceName.toLowerCase()} operation
-export type ${operationName.slice(0, 1).toUpperCase() + operationName.slice(1)}Schema = z.infer<typeof ${operationName}SchemaDefinition>;
 `;
       })
       .filter((schema) => schema !== null) // Remove null entries
       .join("\n");
 
-    const exports = schemaNames
-      .filter((schemaName) => {
-        // Only export operation schemas, not dependencies
-        const operationMatch = schemaName.match(/(create|patch|update|delete|register|upload|send|preview|render)/i);
-        return operationMatch !== null && schemaName.includes("_Body");
-      })
-      .map((schemaName) => {
-        const operationMatch = schemaName.match(/(create|patch|update|delete|register|upload|send|preview|render)/i);
-        const resourceMatch = schemaName.match(/[A-Z][a-zA-Z]+_Body/);
-
-        if (!operationMatch || !resourceMatch) {
-          throw new Error(`Invalid schema name format: ${schemaName}`);
+    const exports = groupEntries
+      .map(({ alias, schemaName }) => {
+        const definitionEntry = primaryEntryBySchemaName.get(schemaName);
+        if (!definitionEntry) {
+          throw new Error(`Missing primary operation entry for ${schemaName}`);
         }
 
-        const operationType = operationMatch[1].toLowerCase();
-        const resourceName = resourceMatch[0].replace("_Body", "");
-        const operationName = formatOperationName(operationType, resourceName);
-        return `export const ${operationName}Schema = ${operationName}SchemaDefinition;`;
+        const typeName = alias.slice(0, 1).toUpperCase() + alias.slice(1);
+        return `export type ${typeName}Schema = z.infer<typeof ${definitionEntry.alias}SchemaDefinition>;
+export const ${alias}Schema = ${definitionEntry.alias}SchemaDefinition;`;
       })
       .join("\n");
 
@@ -292,6 +302,29 @@ ${exports}
 
     await fs.writeFile(path.join(SCHEMAS_DIR, `${groupName}.ts`), schemaContent);
   }
+  // Topological sort: ensures each schema is defined after all schemas it depends on
+  function topologicalSort(names: string[], fullContent: string): string[] {
+    const visited = new Set<string>();
+    const result: string[] = [];
+
+    function visit(name: string) {
+      if (visited.has(name)) return;
+      visited.add(name);
+      // Visit dependencies first so they appear earlier in the output
+      const deps = findSchemaDependencies(name, fullContent);
+      for (const dep of deps) {
+        if (names.includes(dep)) {
+          visit(dep);
+        }
+      }
+      result.push(name);
+    }
+
+    for (const name of names) {
+      visit(name);
+    }
+    return result;
+  }
 
   // Create index file - export ALL schema files (not just schemasByGroup)
   const normalizedSchemaFiles = new Map<string, string>();

package/src/generated/schemas/acceptentityinvitation_body.ts

@@ -8,10 +8,11 @@ import { z } from 'zod';
 
 // Schemas for acceptentityinvitation_body endpoints
 
-// Dependency schema for acceptentityinvitation_body
-const acceptEntityInvitation_Body = z.object({
+// Schema for acceptEntityInvitation operation
+const acceptEntityInvitationSchemaDefinition = z.object({
   name: z.string().min(1).max(255),
   password: z.string().min(8),
 });
 
-
+export type AcceptEntityInvitationSchema = z.infer<typeof acceptEntityInvitationSchemaDefinition>;
+export const acceptEntityInvitationSchema = acceptEntityInvitationSchemaDefinition;

package/src/generated/schemas/accountwebhook.ts

@@ -8,7 +8,7 @@ import { z } from 'zod';
 
 // Schemas for accountwebhook endpoints
 
-// Schema for create accountwebhook operation
+// Schema for createAccountWebhook operation
 const createAccountWebhookSchemaDefinition = z.object({
   url: z.string().max(2048).url(),
   description: z.union([z.string().max(4000, "Description must not exceed 4000 characters"), z.null()]).optional(),
@@ -31,11 +31,8 @@ const createAccountWebhookSchemaDefinition = z.object({
   metadata: z.union([z.record(z.string(), z.any()), z.null()]).optional(),
 });
 
-// Type for create accountwebhook operation
-export type CreateAccountWebhookSchema = z.infer<typeof createAccountWebhookSchemaDefinition>;
-
 
-// Schema for update accountwebhook operation
+// Schema for updateAccountWebhook operation
 const updateAccountWebhookSchemaDefinition = z
   .object({
     url: z.string().max(2048).url(),
@@ -60,8 +57,7 @@ const updateAccountWebhookSchemaDefinition = z
   })
   .partial();
 
-// Type for update accountwebhook operation
-export type UpdateAccountWebhookSchema = z.infer<typeof updateAccountWebhookSchemaDefinition>;
-
+export type CreateAccountWebhookSchema = z.infer<typeof createAccountWebhookSchemaDefinition>;
 export const createAccountWebhookSchema = createAccountWebhookSchemaDefinition;
+export type UpdateAccountWebhookSchema = z.infer<typeof updateAccountWebhookSchemaDefinition>;
 export const updateAccountWebhookSchema = updateAccountWebhookSchemaDefinition;

package/src/generated/schemas/addentityuser_body.ts

@@ -8,11 +8,12 @@ import { z } from 'zod';
 
 // Schemas for addentityuser_body endpoints
 
-// Dependency schema for addentityuser_body
-const addEntityUser_Body = z.object({
+// Schema for addEntityUser operation
+const addEntityUserSchemaDefinition = z.object({
   email: z.string().email(),
   role: z.enum(["viewer", "editor", "admin"]).optional().default("editor"),
   send_invite: z.boolean().optional().default(true),
 });
 
-
+export type AddEntityUserSchema = z.infer<typeof addEntityUserSchemaDefinition>;
+export const addEntityUserSchema = addEntityUserSchemaDefinition;