@enjoys/context-engine 1.3.1 → 1.4.2

package/data/signatureHelp/react.json

@@ -0,0 +1,285 @@
+{
+  "language": "react",
+  "triggerCharacters": [
+    "(",
+    ",",
+    "<"
+  ],
+  "retriggerCharacters": [
+    ","
+  ],
+  "signatures": [
+    {
+      "label": "useState<S>(initialState: S | (() => S)): [S, Dispatch<SetStateAction<S>>]",
+      "documentation": "Returns a stateful value and a function to update it. During the initial render, the returned state is the same as the value passed as the first argument. The setState function accepts a new state value or a function that receives the previous state.",
+      "parameters": [
+        {
+          "label": "initialState: S | (() => S)",
+          "documentation": "The value used for the initial state. Can also be a function that returns the initial state (lazy initialization)."
+        }
+      ]
+    },
+    {
+      "label": "useEffect(effect: EffectCallback, deps?: DependencyList): void",
+      "documentation": "Accepts a function that contains imperative, possibly effectful code. Runs the effect after every completed render unless a dependency array is provided.",
+      "parameters": [
+        {
+          "label": "effect: EffectCallback",
+          "documentation": "The effect function to run. May return a cleanup function."
+        },
+        {
+          "label": "deps?: DependencyList",
+          "documentation": "Optional array of dependencies. Effect re-runs only when dependencies change."
+        }
+      ]
+    },
+    {
+      "label": "useContext<T>(context: Context<T>): T",
+      "documentation": "Accepts a context object (the value returned from React.createContext) and returns the current context value. The current context value is determined by the nearest Provider above.",
+      "parameters": [
+        {
+          "label": "context: Context<T>",
+          "documentation": "Context object created by React.createContext."
+        }
+      ]
+    },
+    {
+      "label": "useReducer<R>(reducer: R, initialState: ReducerState<R>, init?: (initial: ReducerState<R>) => ReducerState<R>): [ReducerState<R>, Dispatch<ReducerAction<R>>]",
+      "documentation": "An alternative to useState. Accepts a reducer of type (state, action) => newState, and returns the current state paired with a dispatch method.",
+      "parameters": [
+        {
+          "label": "reducer: R",
+          "documentation": "A function of type (state, action) => newState."
+        },
+        {
+          "label": "initialState: ReducerState<R>",
+          "documentation": "Initial state value for the reducer."
+        },
+        {
+          "label": "init?: (initial: ReducerState<R>) => ReducerState<R>",
+          "documentation": "Optional lazy initializer function."
+        }
+      ]
+    },
+    {
+      "label": "useMemo<T>(factory: () => T, deps: DependencyList): T",
+      "documentation": "Returns a memoized value. Pass a \"create\" function and an array of dependencies. useMemo will only recompute the memoized value when one of the dependencies has changed.",
+      "parameters": [
+        {
+          "label": "factory: () => T",
+          "documentation": "Function that computes and returns the memoized value."
+        },
+        {
+          "label": "deps: DependencyList",
+          "documentation": "Array of dependencies that trigger recomputation."
+        }
+      ]
+    },
+    {
+      "label": "useCallback<T extends Function>(callback: T, deps: DependencyList): T",
+      "documentation": "Returns a memoized callback. Pass an inline callback and an array of dependencies. useCallback will return a memoized version of the callback that only changes if one of the dependencies has changed.",
+      "parameters": [
+        {
+          "label": "callback: T",
+          "documentation": "The callback function to memoize."
+        },
+        {
+          "label": "deps: DependencyList",
+          "documentation": "Array of dependencies that trigger re-creation of the callback."
+        }
+      ]
+    },
+    {
+      "label": "useRef<T>(initialValue: T): MutableRefObject<T>",
+      "documentation": "Returns a mutable ref object whose .current property is initialized to the passed argument. The returned object will persist for the full lifetime of the component.",
+      "parameters": [
+        {
+          "label": "initialValue: T",
+          "documentation": "Initial value for the ref's .current property. Commonly null for DOM refs."
+        }
+      ]
+    },
+    {
+      "label": "useImperativeHandle<T, R>(ref: Ref<T>, createHandle: () => R, deps?: DependencyList): void",
+      "documentation": "Customizes the instance value that is exposed to parent components when using ref. Should be used with forwardRef.",
+      "parameters": [
+        {
+          "label": "ref: Ref<T>",
+          "documentation": "The ref forwarded from a parent component."
+        },
+        {
+          "label": "createHandle: () => R",
+          "documentation": "Function returning the handle object to expose."
+        },
+        {
+          "label": "deps?: DependencyList",
+          "documentation": "Optional dependency array for recomputing the handle."
+        }
+      ]
+    },
+    {
+      "label": "useLayoutEffect(effect: EffectCallback, deps?: DependencyList): void",
+      "documentation": "The signature is identical to useEffect, but it fires synchronously after all DOM mutations. Use this to read layout from the DOM and synchronously re-render.",
+      "parameters": [
+        {
+          "label": "effect: EffectCallback",
+          "documentation": "Effect function that runs synchronously after DOM mutations."
+        },
+        {
+          "label": "deps?: DependencyList",
+          "documentation": "Optional dependency array."
+        }
+      ]
+    },
+    {
+      "label": "useDebugValue<T>(value: T, format?: (value: T) => any): void",
+      "documentation": "Used to display a label for custom hooks in React DevTools. Optionally accepts a formatting function.",
+      "parameters": [
+        {
+          "label": "value: T",
+          "documentation": "The debug value to display."
+        },
+        {
+          "label": "format?: (value: T) => any",
+          "documentation": "Optional formatting function for expensive computations."
+        }
+      ]
+    },
+    {
+      "label": "useDeferredValue<T>(value: T): T",
+      "documentation": "Accepts a value and returns a deferred version of it that may lag behind the original. Useful for deferring expensive re-renders.",
+      "parameters": [
+        {
+          "label": "value: T",
+          "documentation": "The value to defer."
+        }
+      ]
+    },
+    {
+      "label": "useSyncExternalStore<T>(subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T): T",
+      "documentation": "Subscribe to an external store. Returns the current snapshot of the store's state.",
+      "parameters": [
+        {
+          "label": "subscribe: (onStoreChange: () => void) => () => void",
+          "documentation": "Function to subscribe to the store. Returns an unsubscribe function."
+        },
+        {
+          "label": "getSnapshot: () => T",
+          "documentation": "Function that returns the current snapshot of the store."
+        },
+        {
+          "label": "getServerSnapshot?: () => T",
+          "documentation": "Optional function returning snapshot for server rendering."
+        }
+      ]
+    },
+    {
+      "label": "useInsertionEffect(effect: EffectCallback, deps?: DependencyList): void",
+      "documentation": "Fires synchronously before all DOM mutations. Used for injecting styles into the DOM before layout effects read them.",
+      "parameters": [
+        {
+          "label": "effect: EffectCallback",
+          "documentation": "Effect for injecting styles or similar pre-layout operations."
+        },
+        {
+          "label": "deps?: DependencyList",
+          "documentation": "Optional dependency array."
+        }
+      ]
+    },
+    {
+      "label": "createContext<T>(defaultValue: T): Context<T>",
+      "documentation": "Creates a Context object. When React renders a component that subscribes to this Context object, it will read the current value from the closest matching Provider.",
+      "parameters": [
+        {
+          "label": "defaultValue: T",
+          "documentation": "The default value used when no Provider is found above in the tree."
+        }
+      ]
+    },
+    {
+      "label": "createElement(type: string | ComponentType, props?: object, ...children: ReactNode[]): ReactElement",
+      "documentation": "Create and return a new React element of the given type. Type can be a tag name string or a React component type.",
+      "parameters": [
+        {
+          "label": "type: string | ComponentType",
+          "documentation": "HTML tag name or React component."
+        },
+        {
+          "label": "props?: object",
+          "documentation": "Props to pass to the element."
+        },
+        {
+          "label": "...children: ReactNode[]",
+          "documentation": "Child elements."
+        }
+      ]
+    },
+    {
+      "label": "memo<P>(Component: FunctionComponent<P>, areEqual?: (prev: Readonly<P>, next: Readonly<P>) => boolean): NamedExoticComponent<P>",
+      "documentation": "If your component renders the same result given the same props, wrap it in React.memo for a performance boost by memoizing the result.",
+      "parameters": [
+        {
+          "label": "Component: FunctionComponent<P>",
+          "documentation": "The component to memoize."
+        },
+        {
+          "label": "areEqual?: (prev: Readonly<P>, next: Readonly<P>) => boolean",
+          "documentation": "Optional custom comparison function. Defaults to shallow comparison."
+        }
+      ]
+    },
+    {
+      "label": "forwardRef<T, P>(render: ForwardRefRenderFunction<T, P>): ForwardRefExoticComponent<PropsWithoutRef<P> & RefAttributes<T>>",
+      "documentation": "Creates a component that forwards ref to a child. Useful for passing refs to DOM elements or class components inside function components.",
+      "parameters": [
+        {
+          "label": "render: ForwardRefRenderFunction<T, P>",
+          "documentation": "Render function that receives props and ref as arguments."
+        }
+      ]
+    },
+    {
+      "label": "lazy<T extends ComponentType<any>>(factory: () => Promise<{ default: T }>): LazyExoticComponent<T>",
+      "documentation": "Lets you define a component that is loaded dynamically. Helps reduce bundle size by code-splitting components that aren't needed during initial render.",
+      "parameters": [
+        {
+          "label": "factory: () => Promise<{ default: T }>",
+          "documentation": "Function returning a dynamic import() of a module with a default export."
+        }
+      ]
+    },
+    {
+      "label": "createPortal(children: ReactNode, container: Element, key?: string): ReactPortal",
+      "documentation": "Creates a portal. Portals provide a way to render children into a DOM node that exists outside the parent component's DOM hierarchy.",
+      "parameters": [
+        {
+          "label": "children: ReactNode",
+          "documentation": "The React elements to render."
+        },
+        {
+          "label": "container: Element",
+          "documentation": "The DOM element to render into."
+        },
+        {
+          "label": "key?: string",
+          "documentation": "Optional unique key for the portal."
+        }
+      ]
+    },
+    {
+      "label": "createRoot(container: Element | DocumentFragment, options?: RootOptions): Root",
+      "documentation": "Create a React root for a browser DOM element. Use it to display React content inside a browser DOM element. After creating a root, call root.render() to display a React component inside it.",
+      "parameters": [
+        {
+          "label": "container: Element | DocumentFragment",
+          "documentation": "The DOM element to mount the React application into."
+        },
+        {
+          "label": "options?: RootOptions",
+          "documentation": "Optional configuration for the root (identifierPrefix, onRecoverableError, etc.)."
+        }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/shadcn.json

@@ -0,0 +1,237 @@
+{
+  "language": "shadcn",
+  "signatures": [
+    {
+      "label": "cn(...inputs: ClassValue[]): string",
+      "documentation": "Merges and deduplicates Tailwind CSS class names using clsx and tailwind-merge. Accepts strings, arrays, objects, and conditional expressions.",
+      "parameters": [
+        {
+          "label": "...inputs",
+          "documentation": "One or more class values: strings, arrays of strings, objects with boolean values, or falsy values to be filtered out."
+        }
+      ]
+    },
+    {
+      "label": "cva(base?: ClassValue, config?: CVAConfig): VariantFunction",
+      "documentation": "Creates a class-variance-authority variant function that generates class names based on variant combinations.",
+      "parameters": [
+        {
+          "label": "base",
+          "documentation": "Base class names applied to all variants. Accepts strings or arrays of class values."
+        },
+        {
+          "label": "config",
+          "documentation": "Configuration object containing variants, compoundVariants, and defaultVariants definitions."
+        }
+      ]
+    },
+    {
+      "label": "buttonVariants({ variant?, size?, className? }): string",
+      "documentation": "Generates class names for the Button component based on variant and size options.",
+      "parameters": [
+        {
+          "label": "variant",
+          "documentation": "Visual style variant: 'default' | 'destructive' | 'outline' | 'secondary' | 'ghost' | 'link'."
+        },
+        {
+          "label": "size",
+          "documentation": "Size variant: 'default' | 'sm' | 'lg' | 'icon'."
+        },
+        {
+          "label": "className",
+          "documentation": "Additional class names to merge with the variant classes."
+        }
+      ]
+    },
+    {
+      "label": "useToast(): { toast, dismiss, toasts }",
+      "documentation": "Returns the toast API for displaying toast notifications. Provides toast() to create, dismiss() to remove, and toasts array for current state.",
+      "parameters": []
+    },
+    {
+      "label": "toast({ title?, description?, variant?, action?, duration? }): { id, dismiss, update }",
+      "documentation": "Displays a toast notification with the given configuration. Returns controls to dismiss or update the toast.",
+      "parameters": [
+        {
+          "label": "title",
+          "documentation": "The title text displayed prominently in the toast."
+        },
+        {
+          "label": "description",
+          "documentation": "Secondary description text displayed below the title."
+        },
+        {
+          "label": "variant",
+          "documentation": "Visual variant: 'default' | 'destructive'."
+        },
+        {
+          "label": "action",
+          "documentation": "A ToastAction element rendered as an action button in the toast."
+        },
+        {
+          "label": "duration",
+          "documentation": "Auto-dismiss duration in milliseconds. Defaults to 5000."
+        }
+      ]
+    },
+    {
+      "label": "useFormField(): { id, name, formItemId, formDescriptionId, formMessageId, invalid, isDirty, isTouched, error }",
+      "documentation": "Returns form field context and state from the nearest FormField provider. Must be used within a FormField component.",
+      "parameters": []
+    },
+    {
+      "label": "useForm<TFieldValues>({ resolver?, defaultValues?, mode?, reValidateMode? }): UseFormReturn<TFieldValues>",
+      "documentation": "Initializes a react-hook-form instance with optional schema validation and default values.",
+      "parameters": [
+        {
+          "label": "resolver",
+          "documentation": "Validation resolver function, typically zodResolver(schema) for Zod-based validation."
+        },
+        {
+          "label": "defaultValues",
+          "documentation": "Default values for the form fields matching the schema shape."
+        },
+        {
+          "label": "mode",
+          "documentation": "Validation strategy: 'onBlur' | 'onChange' | 'onSubmit' | 'onTouched' | 'all'. Defaults to 'onSubmit'."
+        },
+        {
+          "label": "reValidateMode",
+          "documentation": "Re-validation strategy after submit: 'onBlur' | 'onChange' | 'onSubmit'. Defaults to 'onChange'."
+        }
+      ]
+    },
+    {
+      "label": "zodResolver(schema: ZodSchema, schemaOptions?, factoryOptions?): Resolver",
+      "documentation": "Creates a react-hook-form resolver from a Zod validation schema for seamless form validation integration.",
+      "parameters": [
+        {
+          "label": "schema",
+          "documentation": "The Zod schema object (e.g. z.object({...})) to validate form submissions against."
+        },
+        {
+          "label": "schemaOptions",
+          "documentation": "Optional Zod parse options like async mode or error mapping."
+        },
+        {
+          "label": "factoryOptions",
+          "documentation": "Optional factory configuration for the resolver behavior."
+        }
+      ]
+    },
+    {
+      "label": "React.forwardRef<TRef, TProps>(render: (props: TProps, ref: Ref<TRef>) => ReactElement): ForwardRefExoticComponent",
+      "documentation": "Creates a component that forwards its ref to a child DOM element or component. Essential for shadcn/ui primitives.",
+      "parameters": [
+        {
+          "label": "render",
+          "documentation": "Render function receiving (props, ref). Must forward the ref to a DOM element or child component."
+        }
+      ]
+    },
+    {
+      "label": "z.object(shape: ZodRawShape): ZodObject",
+      "documentation": "Creates a Zod object schema with the specified shape for form validation.",
+      "parameters": [
+        {
+          "label": "shape",
+          "documentation": "An object mapping field names to Zod type definitions (e.g. { name: z.string(), age: z.number() })."
+        }
+      ]
+    },
+    {
+      "label": "z.string(): ZodString & { .min(length, message?), .max(length, message?), .email(message?), .url(message?), .regex(pattern, message?) }",
+      "documentation": "Creates a Zod string validator with chainable refinement methods for form field validation.",
+      "parameters": [
+        {
+          "label": "min",
+          "documentation": "Minimum string length. Accepts (length: number, message?: string)."
+        },
+        {
+          "label": "max",
+          "documentation": "Maximum string length. Accepts (length: number, message?: string)."
+        }
+      ]
+    },
+    {
+      "label": "z.enum(values: [string, ...string[]]): ZodEnum",
+      "documentation": "Creates a Zod enum schema that validates against a fixed set of string values.",
+      "parameters": [
+        {
+          "label": "values",
+          "documentation": "A non-empty array of allowed string values (e.g. ['admin', 'user', 'guest'])."
+        }
+      ]
+    },
+    {
+      "label": "FormField<TFieldValues>({ control, name, render }): ReactElement",
+      "documentation": "Connects a form field to react-hook-form state management. Wraps form controls with validation and state tracking.",
+      "parameters": [
+        {
+          "label": "control",
+          "documentation": "The form control object from useForm(). Pass form.control."
+        },
+        {
+          "label": "name",
+          "documentation": "The field name path matching the form schema (e.g. 'email', 'address.street')."
+        },
+        {
+          "label": "render",
+          "documentation": "Render prop function receiving { field, fieldState, formState } to render the form control."
+        }
+      ]
+    },
+    {
+      "label": "columns: ColumnDef<TData, TValue>[]",
+      "documentation": "Array of column definitions for TanStack Table / shadcn DataTable. Each column defines accessors, headers, cells, and optional sorting/filtering.",
+      "parameters": [
+        {
+          "label": "accessorKey",
+          "documentation": "The key to access row data for this column. Maps to a property on TData."
+        },
+        {
+          "label": "header",
+          "documentation": "Column header content: a string, or a function receiving HeaderContext for custom rendering."
+        },
+        {
+          "label": "cell",
+          "documentation": "Cell renderer: a function receiving CellContext with row data for custom cell content."
+        }
+      ]
+    },
+    {
+      "label": "DataTable<TData, TValue>({ columns, data, searchKey?, pagination? }): ReactElement",
+      "documentation": "Renders a data table using TanStack Table with shadcn/ui styling. Supports sorting, filtering, and pagination.",
+      "parameters": [
+        {
+          "label": "columns",
+          "documentation": "Array of ColumnDef objects defining the table structure and cell rendering."
+        },
+        {
+          "label": "data",
+          "documentation": "Array of data objects to populate the table rows."
+        },
+        {
+          "label": "searchKey",
+          "documentation": "Optional column key to enable text search filtering."
+        },
+        {
+          "label": "pagination",
+          "documentation": "Optional boolean to enable table pagination controls."
+        }
+      ]
+    },
+    {
+      "label": "clsx(...inputs: ClassValue[]): string",
+      "documentation": "Constructs className strings conditionally from various input types. Foundation utility used by cn().",
+      "parameters": [
+        {
+          "label": "...inputs",
+          "documentation": "One or more class values: strings, numbers, objects with boolean values, arrays, or falsy values."
+        }
+      ]
+    }
+  ],
+  "triggerCharacters": ["(", ",", "<"],
+  "retriggerCharacters": [","]
+}