@ram_28/kf-ai-sdk 1.0.11 → 1.0.12

package/sdk/components/hooks/useFilter/types.ts

@@ -1,24 +1,18 @@
 import type {
-  Condition,
-  ConditionGroup,
-  ConditionGroupOperator,
-  Filter,
-  FilterRHSType,
-  // Legacy types for backwards compatibility
-  FilterCondition,
-  FilterOperator,
+  ConditionType,
+  ConditionGroupType,
+  ConditionGroupOperatorType,
+  FilterType,
+  FilterRHSTypeType,
 } from "../../../types/common";
 
 // Re-export from common types for convenience
 export type {
-  Condition,
-  ConditionGroup,
-  ConditionGroupOperator,
-  Filter,
-  FilterRHSType,
-  // Legacy re-exports
-  FilterCondition,
-  FilterOperator,
+  ConditionType,
+  ConditionGroupType,
+  ConditionGroupOperatorType,
+  FilterType,
+  FilterRHSTypeType,
 };
 
 // ============================================================
@@ -29,8 +23,8 @@ export type {
  * Type guard to check if an item is a ConditionGroup (has nested Condition array)
  */
 export const isConditionGroup = (
-  item: Condition | ConditionGroup
-): item is ConditionGroup => {
+  item: ConditionType | ConditionGroupType
+): item is ConditionGroupType => {
   return "Condition" in item;
 };
 
@@ -38,25 +32,11 @@ export const isConditionGroup = (
  * Type guard to check if an item is a leaf Condition (has LHSField)
  */
 export const isCondition = (
-  item: Condition | ConditionGroup
-): item is Condition => {
+  item: ConditionType | ConditionGroupType
+): item is ConditionType => {
   return "LHSField" in item;
 };
 
-// ============================================================
-// LEGACY TYPE GUARDS (for backwards compatibility)
-// ============================================================
-
-/**
- * @deprecated Use `isConditionGroup` instead
- */
-export const isFilterLogical = isConditionGroup;
-
-/**
- * @deprecated Use `isCondition` instead
- */
-export const isFilterCondition = isCondition;
-
 // ============================================================
 // HOOK-SPECIFIC TYPE DEFINITIONS
 // ============================================================
@@ -64,29 +44,29 @@ export const isFilterCondition = isCondition;
 /**
  * Hook options (minimal configuration)
  */
-export interface UseFilterOptions {
+export interface UseFilterOptionsType {
   /** Initial filter conditions */
-  initialConditions?: Array<Condition | ConditionGroup>;
+  initialConditions?: Array<ConditionType | ConditionGroupType>;
   /** Initial operator for combining conditions (defaults to "And") */
-  initialOperator?: ConditionGroupOperator;
+  initialOperator?: ConditionGroupOperatorType;
 }
 
 /**
  * Hook return interface with nested filter support
  */
-export interface UseFilterReturn {
+export interface UseFilterReturnType {
   // ============================================================
   // STATE (read-only)
   // ============================================================
 
   /** Current operator for combining root-level conditions ("And" | "Or" | "Not") */
-  operator: ConditionGroupOperator;
+  operator: ConditionGroupOperatorType;
 
   /** Current filter items (with id populated) */
-  items: Array<Condition | ConditionGroup>;
+  items: Array<ConditionType | ConditionGroupType>;
 
   /** Ready-to-use API payload (id stripped, undefined if no conditions) */
-  payload: Filter | undefined;
+  payload: FilterType | undefined;
 
   /** Whether any conditions exist */
   hasConditions: boolean;
@@ -99,27 +79,27 @@ export interface UseFilterReturn {
    * Add a leaf condition at root level
    * @returns The id of the created condition
    */
-  add: (condition: Omit<Condition, "id">) => string;
+  add: (condition: Omit<ConditionType, "id">) => string;
 
   /**
    * Add a condition group at root level
    * @returns The id of the created group
    */
-  addGroup: (operator: ConditionGroupOperator) => string;
+  addGroup: (operator: ConditionGroupOperatorType) => string;
 
   /**
    * Add a leaf condition to a specific parent group
    * @param parentId - The id of the parent ConditionGroup
    * @returns The id of the created condition
    */
-  addTo: (parentId: string, condition: Omit<Condition, "id">) => string;
+  addTo: (parentId: string, condition: Omit<ConditionType, "id">) => string;
 
   /**
    * Add a condition group to a specific parent group
    * @param parentId - The id of the parent ConditionGroup
    * @returns The id of the created group
    */
-  addGroupTo: (parentId: string, operator: ConditionGroupOperator) => string;
+  addGroupTo: (parentId: string, operator: ConditionGroupOperatorType) => string;
 
   // ============================================================
   // UPDATE OPERATIONS
@@ -130,14 +110,14 @@ export interface UseFilterReturn {
    * @param id - The id of the condition to update
    * @param updates - Partial updates to apply
    */
-  update: (id: string, updates: Partial<Omit<Condition, "id">>) => void;
+  update: (id: string, updates: Partial<Omit<ConditionType, "id">>) => void;
 
   /**
    * Update a condition group's operator by id
    * @param id - The id of the group to update
    * @param operator - The new operator
    */
-  updateOperator: (id: string, operator: ConditionGroupOperator) => void;
+  updateOperator: (id: string, operator: ConditionGroupOperatorType) => void;
 
   // ============================================================
   // REMOVE & ACCESS
@@ -154,7 +134,7 @@ export interface UseFilterReturn {
    * @param id - The id to look up
    * @returns The item or undefined if not found
    */
-  get: (id: string) => Condition | ConditionGroup | undefined;
+  get: (id: string) => ConditionType | ConditionGroupType | undefined;
 
   // ============================================================
   // UTILITY
@@ -164,14 +144,5 @@ export interface UseFilterReturn {
   clear: () => void;
 
   /** Set the root operator for combining conditions */
-  setOperator: (op: ConditionGroupOperator) => void;
-
-  // ============================================================
-  // LEGACY API (for backwards compatibility)
-  // ============================================================
-
-  /**
-   * @deprecated Use `items` instead
-   */
-  conditions: Array<Condition | ConditionGroup>;
+  setOperator: (op: ConditionGroupOperatorType) => void;
 }

package/sdk/components/hooks/useFilter/useFilter.ts

@@ -1,11 +1,11 @@
 import { useState, useCallback, useMemo } from "react";
 import type {
-  Condition,
-  ConditionGroup,
-  ConditionGroupOperator,
-  Filter,
+  ConditionType,
+  ConditionGroupType,
+  ConditionGroupOperatorType,
+  FilterType,
 } from "../../../types/common";
-import type { UseFilterOptions, UseFilterReturn } from "./types";
+import type { UseFilterOptionsType, UseFilterReturnType } from "./types";
 import { isConditionGroup } from "./types";
 
 // ============================================================
@@ -24,7 +24,7 @@ const generateId = (): string => {
 /**
  * Ensure an item has an id
  */
-const ensureId = <T extends Condition | ConditionGroup>(item: T): T => {
+const ensureId = <T extends ConditionType | ConditionGroupType>(item: T): T => {
   if (!item.id) {
     return { ...item, id: generateId() };
   }
@@ -35,8 +35,8 @@ const ensureId = <T extends Condition | ConditionGroup>(item: T): T => {
  * Deep clone and ensure all items have ids
  */
 const cloneWithIds = (
-  items: Array<Condition | ConditionGroup>
-): Array<Condition | ConditionGroup> => {
+  items: Array<ConditionType | ConditionGroupType>
+): Array<ConditionType | ConditionGroupType> => {
   return items.map((item) => {
     const withId = ensureId(item);
     if (isConditionGroup(withId)) {
@@ -53,18 +53,18 @@ const cloneWithIds = (
  * Strip id fields from items for API payload
  */
 const stripIds = (
-  items: Array<Condition | ConditionGroup>
-): Array<Condition | ConditionGroup> => {
+  items: Array<ConditionType | ConditionGroupType>
+): Array<ConditionType | ConditionGroupType> => {
   return items.map((item) => {
     if (isConditionGroup(item)) {
       const { id, ...rest } = item;
       return {
         ...rest,
         Condition: stripIds(item.Condition),
-      } as ConditionGroup;
+      } as ConditionGroupType;
     }
     const { id, ...rest } = item;
-    return rest as Condition;
+    return rest as ConditionType;
   });
 };
 
@@ -72,9 +72,9 @@ const stripIds = (
  * Find an item by id in a tree structure
  */
 const findById = (
-  items: Array<Condition | ConditionGroup>,
+  items: Array<ConditionType | ConditionGroupType>,
   id: string
-): Condition | ConditionGroup | undefined => {
+): ConditionType | ConditionGroupType | undefined => {
   for (const item of items) {
     if (item.id === id) {
       return item;
@@ -91,10 +91,10 @@ const findById = (
  * Find a parent group by child id
  */
 const findParentById = (
-  items: Array<Condition | ConditionGroup>,
+  items: Array<ConditionType | ConditionGroupType>,
   childId: string,
-  parent: ConditionGroup | null = null
-): ConditionGroup | null => {
+  parent: ConditionGroupType | null = null
+): ConditionGroupType | null => {
   for (const item of items) {
     if (item.id === childId) {
       return parent;
@@ -111,10 +111,10 @@ const findParentById = (
  * Update an item in the tree by id
  */
 const updateInTree = (
-  items: Array<Condition | ConditionGroup>,
+  items: Array<ConditionType | ConditionGroupType>,
   id: string,
-  updater: (item: Condition | ConditionGroup) => Condition | ConditionGroup
-): Array<Condition | ConditionGroup> => {
+  updater: (item: ConditionType | ConditionGroupType) => ConditionType | ConditionGroupType
+): Array<ConditionType | ConditionGroupType> => {
   return items.map((item) => {
     if (item.id === id) {
       return updater(item);
@@ -133,9 +133,9 @@ const updateInTree = (
  * Remove an item from the tree by id
  */
 const removeFromTree = (
-  items: Array<Condition | ConditionGroup>,
+  items: Array<ConditionType | ConditionGroupType>,
   id: string
-): Array<Condition | ConditionGroup> => {
+): Array<ConditionType | ConditionGroupType> => {
   return items
     .filter((item) => item.id !== id)
     .map((item) => {
@@ -153,10 +153,10 @@ const removeFromTree = (
  * Add an item to a specific parent in the tree
  */
 const addToParent = (
-  items: Array<Condition | ConditionGroup>,
+  items: Array<ConditionType | ConditionGroupType>,
   parentId: string,
-  newItem: Condition | ConditionGroup
-): Array<Condition | ConditionGroup> => {
+  newItem: ConditionType | ConditionGroupType
+): Array<ConditionType | ConditionGroupType> => {
   return items.map((item) => {
     if (item.id === parentId && isConditionGroup(item)) {
       return {
@@ -178,18 +178,18 @@ const addToParent = (
 // USE FILTER HOOK - Nested Filter Support
 // ============================================================
 
-export function useFilter(options: UseFilterOptions = {}): UseFilterReturn {
+export function useFilter(options: UseFilterOptionsType = {}): UseFilterReturnType {
   // Initialize items with ids
-  const [items, setItems] = useState<Array<Condition | ConditionGroup>>(() =>
+  const [items, setItems] = useState<Array<ConditionType | ConditionGroupType>>(() =>
     cloneWithIds(options.initialConditions || [])
   );
 
-  const [operator, setOperatorState] = useState<ConditionGroupOperator>(
+  const [operator, setOperatorState] = useState<ConditionGroupOperatorType>(
     options.initialOperator || "And"
   );
 
   // Build payload for API (strip ids)
-  const payload = useMemo((): Filter | undefined => {
+  const payload = useMemo((): FilterType | undefined => {
     if (items.length === 0) return undefined;
     return {
       Operator: operator,
@@ -203,16 +203,16 @@ export function useFilter(options: UseFilterOptions = {}): UseFilterReturn {
   // ADD OPERATIONS
   // ============================================================
 
-  const add = useCallback((condition: Omit<Condition, "id">): string => {
+  const add = useCallback((condition: Omit<ConditionType, "id">): string => {
     const id = generateId();
-    const newCondition: Condition = { ...condition, id };
+    const newCondition: ConditionType = { ...condition, id };
     setItems((prev) => [...prev, newCondition]);
     return id;
   }, []);
 
-  const addGroup = useCallback((groupOperator: ConditionGroupOperator): string => {
+  const addGroup = useCallback((groupOperator: ConditionGroupOperatorType): string => {
     const id = generateId();
-    const newGroup: ConditionGroup = {
+    const newGroup: ConditionGroupType = {
       id,
       Operator: groupOperator,
       Condition: [],
@@ -222,9 +222,9 @@ export function useFilter(options: UseFilterOptions = {}): UseFilterReturn {
   }, []);
 
   const addTo = useCallback(
-    (parentId: string, condition: Omit<Condition, "id">): string => {
+    (parentId: string, condition: Omit<ConditionType, "id">): string => {
       const id = generateId();
-      const newCondition: Condition = { ...condition, id };
+      const newCondition: ConditionType = { ...condition, id };
       setItems((prev) => addToParent(prev, parentId, newCondition));
       return id;
     },
@@ -232,9 +232,9 @@ export function useFilter(options: UseFilterOptions = {}): UseFilterReturn {
   );
 
   const addGroupTo = useCallback(
-    (parentId: string, groupOperator: ConditionGroupOperator): string => {
+    (parentId: string, groupOperator: ConditionGroupOperatorType): string => {
       const id = generateId();
-      const newGroup: ConditionGroup = {
+      const newGroup: ConditionGroupType = {
         id,
         Operator: groupOperator,
         Condition: [],
@@ -250,7 +250,7 @@ export function useFilter(options: UseFilterOptions = {}): UseFilterReturn {
   // ============================================================
 
   const update = useCallback(
-    (id: string, updates: Partial<Omit<Condition, "id">>): void => {
+    (id: string, updates: Partial<Omit<ConditionType, "id">>): void => {
       setItems((prev) =>
         updateInTree(prev, id, (item) => {
           if (!isConditionGroup(item)) {
@@ -264,7 +264,7 @@ export function useFilter(options: UseFilterOptions = {}): UseFilterReturn {
   );
 
   const updateOperator = useCallback(
-    (id: string, newOperator: ConditionGroupOperator): void => {
+    (id: string, newOperator: ConditionGroupOperatorType): void => {
       setItems((prev) =>
         updateInTree(prev, id, (item) => {
           if (isConditionGroup(item)) {
@@ -286,7 +286,7 @@ export function useFilter(options: UseFilterOptions = {}): UseFilterReturn {
   }, []);
 
   const get = useCallback(
-    (id: string): Condition | ConditionGroup | undefined => {
+    (id: string): ConditionType | ConditionGroupType | undefined => {
       return findById(items, id);
     },
     [items]
@@ -300,7 +300,7 @@ export function useFilter(options: UseFilterOptions = {}): UseFilterReturn {
     setItems([]);
   }, []);
 
-  const setOperator = useCallback((op: ConditionGroupOperator): void => {
+  const setOperator = useCallback((op: ConditionGroupOperatorType): void => {
     setOperatorState(op);
   }, []);
 
@@ -332,8 +332,5 @@ export function useFilter(options: UseFilterOptions = {}): UseFilterReturn {
     // Utility
     clear,
     setOperator,
-
-    // Legacy API
-    conditions: items,
   };
 }

package/sdk/components/hooks/useForm/apiClient.ts

@@ -4,7 +4,7 @@
 // Handles schema fetching and form submissions
 
 import { api, getBdoSchema } from "../../../api";
-import type { BDOSchema, FormOperation, SubmissionResult } from "./types";
+import type { BDOSchemaType, FormOperationType, SubmissionResultType } from "./types";
 
 // ============================================================
 // SCHEMA FETCHING
@@ -13,7 +13,7 @@ import type { BDOSchema, FormOperation, SubmissionResult } from "./types";
 /**
  * Fetch BDO schema from backend metadata endpoint
  */
-export async function fetchFormSchema(source: string): Promise<BDOSchema> {
+export async function fetchFormSchema(source: string): Promise<BDOSchemaType> {
   try {
     // Use the new metadata API client to fetch BDO schema
     const bdoResp = await getBdoSchema(source);
@@ -25,7 +25,7 @@ export async function fetchFormSchema(source: string): Promise<BDOSchema> {
     }
 
     // Return the full BDO schema - the form processor will extract what it needs
-    return bdoSchema as BDOSchema;
+    return bdoSchema as BDOSchemaType;
   } catch (error) {
     console.error(`Schema fetch error for ${source}:`, error);
     throw new Error(
@@ -40,7 +40,7 @@ export async function fetchFormSchema(source: string): Promise<BDOSchema> {
 export async function fetchFormSchemaWithRetry(
   source: string,
   maxRetries: number = 3
-): Promise<BDOSchema> {
+): Promise<BDOSchemaType> {
   let lastError: Error;
 
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
@@ -88,10 +88,10 @@ export async function fetchRecord<T = any>(
  */
 export async function submitFormData<T = any>(
   source: string,
-  operation: FormOperation,
+  operation: FormOperationType,
   data: Partial<T>,
   recordId?: string
-): Promise<SubmissionResult> {
+): Promise<SubmissionResultType> {
   try {
     let result;
 
@@ -242,7 +242,7 @@ export function validateFormData<T>(
 export function cleanFormData<T>(
   data: Partial<T>,
   computedFields: string[],
-  operation: FormOperation = "create",
+  operation: FormOperationType = "create",
   originalData?: Partial<T>
 ): Partial<T> {
   const cleanedData: Partial<T> = {};
@@ -404,7 +404,7 @@ export function clearCache(keyPrefix?: string): void {
  */
 export async function fetchFormSchemaWithCache(
   source: string
-): Promise<BDOSchema> {
+): Promise<BDOSchemaType> {
   const cacheKey = `schema:${source}`;
   const cached = getCacheData(cacheKey);
 

package/sdk/components/hooks/useForm/expressionValidator.utils.ts

@@ -4,10 +4,10 @@
 // Evaluates backend expression trees for form validation
 
 import type {
-  ExpressionTree,
-  ExpressionContext,
-  FieldValidationResult,
-  SchemaValidationRule,
+  ExpressionTreeType,
+  ExpressionContextType,
+  FieldValidationResultType,
+  SchemaValidationRuleType,
 } from "./types";
 
 // ============================================================
@@ -137,7 +137,7 @@ const FUNCTIONS = {
 /**
  * Evaluate an expression tree node
  */
-function evaluateNode(node: ExpressionTree, context: ExpressionContext): any {
+function evaluateNode(node: ExpressionTreeType, context: ExpressionContextType): any {
   switch (node.Type) {
     case "Literal":
       return node.Value;
@@ -217,8 +217,8 @@ function evaluateNode(node: ExpressionTree, context: ExpressionContext): any {
  * Get value from identifier based on source
  */
 function getIdentifierValue(
-  node: ExpressionTree,
-  context: ExpressionContext
+  node: ExpressionTreeType,
+  context: ExpressionContextType
 ): any {
   const { Name, Source } = node;
 
@@ -292,8 +292,8 @@ function evaluateBinaryOperation(operator: string, left: any, right: any): any {
  */
 function evaluateLogicalOperation(
   operator: string,
-  args: ExpressionTree[],
-  context: ExpressionContext
+  args: ExpressionTreeType[],
+  context: ExpressionContextType
 ): boolean {
   switch (operator) {
     case "AND":
@@ -313,11 +313,11 @@ function evaluateLogicalOperation(
  * Evaluate a complete expression tree
  */
 export function evaluateExpression(
-  expressionTree: ExpressionTree,
+  expressionTree: ExpressionTreeType,
   formValues: Record<string, any>,
   referenceData: Record<string, any> = {}
 ): any {
-  const context: ExpressionContext = {
+  const context: ExpressionContextType = {
     formValues,
     systemValues: getSystemValues(),
     referenceData,
@@ -337,10 +337,10 @@ export function evaluateExpression(
 export function validateField<T = Record<string, any>>(
   fieldName: string,
   fieldValue: any,
-  validationRules: SchemaValidationRule[],
+  validationRules: SchemaValidationRuleType[],
   formValues: T,
   referenceData: Record<string, any> = {}
-): FieldValidationResult<T> {
+): FieldValidationResultType<T> {
   // If no validation rules, field is valid
   if (!validationRules || validationRules.length === 0) {
     return { isValid: true };
@@ -380,13 +380,13 @@ export function validateField<T = Record<string, any>>(
 export function validateCrossField<T = Record<string, any>>(
   validationRules: Array<{
     Id: string;
-    Condition: { ExpressionTree: ExpressionTree };
+    Condition: { ExpressionTree: ExpressionTreeType };
     Message: string;
   }>,
   formValues: T,
   referenceData: Record<string, any> = {}
-): FieldValidationResult<T>[] {
-  const results: FieldValidationResult<T>[] = [];
+): FieldValidationResultType<T>[] {
+  const results: FieldValidationResultType<T>[] = [];
 
   for (const rule of validationRules) {
     try {
@@ -415,7 +415,7 @@ export function validateCrossField<T = Record<string, any>>(
  * Calculate computed field value
  */
 export function calculateComputedValue(
-  expressionTree: ExpressionTree,
+  expressionTree: ExpressionTreeType,
   formValues: Record<string, any>,
   referenceData: Record<string, any> = {}
 ): any {
@@ -431,7 +431,7 @@ export function calculateComputedValue(
  * Calculate default field value
  */
 export function calculateDefaultValue(
-  expressionTree: ExpressionTree,
+  expressionTree: ExpressionTreeType,
   formValues: Record<string, any> = {},
   referenceData: Record<string, any> = {}
 ): any {

package/sdk/components/hooks/useForm/index.ts

@@ -7,46 +7,46 @@ export { useForm } from './useForm';
 
 // === TYPES: Core (Always needed) ===
 export type {
-  UseFormOptions,
-  UseFormReturn,
-  FormOperation,
-  FormMode,
+  UseFormOptionsType,
+  UseFormReturnType,
+  FormOperationType,
+  FormModeType,
 } from './types';
 
 // === TYPES: Form Field Configuration (For dynamic form rendering) ===
 export type {
-  FormFieldConfig,
-  FormSchemaConfig,
-  FormFieldType,
-  SelectOption,
-  FieldPermission,
-  FieldRuleIds,
+  FormFieldConfigType,
+  FormSchemaConfigType,
+  FormFieldTypeType,
+  SelectOptionType,
+  FieldPermissionType,
+  FieldRuleIdsType,
 } from './types';
 
 // === TYPES: Result Types ===
 export type {
-  FieldValidationResult,
-  SubmissionResult,
+  FieldValidationResultType,
+  SubmissionResultType,
 } from './types';
 
 // === TYPES: BDO Schema (For advanced schema manipulation) ===
 export type {
-  BDOSchema,
-  BDOFieldDefinition,
-  SchemaValidationRule,
-  ComputedFieldFormula,
-  DefaultValueExpression,
-  ReferenceFieldConfig,
-  FieldOptionsConfig,
-  ExpressionTree,
-  BusinessObjectRules,
-  RolePermission,
-  RuleType,
+  BDOSchemaType,
+  BDOFieldDefinitionType,
+  SchemaValidationRuleType,
+  ComputedFieldFormulaType,
+  DefaultValueExpressionType,
+  ReferenceFieldConfigType,
+  FieldOptionsConfigType,
+  ExpressionTreeType,
+  BusinessObjectRulesType,
+  RolePermissionType,
+  RuleTypeType,
 } from './types';
 
 // === TYPES: Expression Evaluation (For custom expression handling) ===
 export type {
-  ExpressionContext,
+  ExpressionContextType,
 } from './types';
 
 // === UTILITIES: Error Handling ===