LCOV - code coverage report
Current view: top level - packages/object-info-parser/src/schemas - nodeDefSchemaV2.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 92.0 % 50 46
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import { z } from 'zod'
       2              : 
       3              : import {
       4              :   zBaseInputOptions,
       5              :   zBooleanInputOptions,
       6              :   zColorStop,
       7              :   zComboInputOptions,
       8              :   zFloatInputOptions,
       9              :   zIntInputOptions,
      10              :   zStringInputOptions
      11              : } from '#/schemas/nodeDefSchema'
      12              : 
      13         2356 : const zIntInputSpec = zIntInputOptions.extend({
      14              :   type: z.literal('INT'),
      15              :   name: z.string(),
      16              :   isOptional: z.boolean().optional()
      17              : })
      18              : 
      19         2356 : const zFloatInputSpec = zFloatInputOptions.extend({
      20              :   type: z.literal('FLOAT'),
      21              :   name: z.string(),
      22              :   isOptional: z.boolean().optional()
      23              : })
      24              : 
      25         2356 : const zBooleanInputSpec = zBooleanInputOptions.extend({
      26              :   type: z.literal('BOOLEAN'),
      27              :   name: z.string(),
      28              :   isOptional: z.boolean().optional()
      29              : })
      30              : 
      31         2356 : const zStringInputSpec = zStringInputOptions.extend({
      32              :   type: z.literal('STRING'),
      33              :   name: z.string(),
      34              :   isOptional: z.boolean().optional()
      35              : })
      36              : 
      37         2356 : const zComboInputSpec = zComboInputOptions.extend({
      38              :   type: z.literal('COMBO'),
      39              :   name: z.string(),
      40              :   isOptional: z.boolean().optional()
      41              : })
      42              : 
      43         2356 : const zColorInputSpec = zBaseInputOptions.extend({
      44              :   type: z.literal('COLOR'),
      45              :   name: z.string(),
      46              :   isOptional: z.boolean().optional(),
      47              :   default: z.string().optional(),
      48              :   options: z.object({ default: z.string().optional() }).optional()
      49              : })
      50              : 
      51         2356 : const zImageInputSpec = zBaseInputOptions.extend({
      52              :   type: z.literal('IMAGE'),
      53              :   name: z.string(),
      54              :   isOptional: z.boolean().optional(),
      55              :   options: z.record(z.string(), z.unknown()).optional()
      56              : })
      57              : 
      58         2356 : const zImageCompareInputSpec = zBaseInputOptions.extend({
      59              :   type: z.literal('IMAGECOMPARE'),
      60              :   name: z.string(),
      61              :   isOptional: z.boolean().optional(),
      62              :   options: z.record(z.string(), z.unknown()).optional()
      63              : })
      64              : 
      65         2356 : const zBoundingBoxInputSpec = zBaseInputOptions.extend({
      66              :   type: z.literal('BOUNDING_BOX'),
      67              :   name: z.string(),
      68              :   isOptional: z.boolean().optional(),
      69              :   component: z.enum(['ImageCrop']).optional(),
      70              :   default: z
      71              :     .object({
      72              :       x: z.number(),
      73              :       y: z.number(),
      74              :       width: z.number(),
      75              :       height: z.number()
      76              :     })
      77              :     .optional()
      78              : })
      79              : 
      80         2356 : const zMarkdownInputSpec = zBaseInputOptions.extend({
      81              :   type: z.literal('MARKDOWN'),
      82              :   name: z.string(),
      83              :   isOptional: z.boolean().optional(),
      84              :   default: z.string().optional()
      85              : })
      86              : 
      87         2356 : const zChartInputSpec = zBaseInputOptions.extend({
      88              :   type: z.literal('CHART'),
      89              :   name: z.string(),
      90              :   isOptional: z.boolean().optional(),
      91              :   chartType: z.enum(['bar', 'line']).optional(),
      92              :   data: z.record(z.string(), z.unknown()).optional(),
      93              :   options: z
      94              :     .object({
      95              :       type: z.enum(['bar', 'line']).optional(),
      96              :       data: z.record(z.string(), z.unknown()).optional()
      97              :     })
      98              :     .optional()
      99              : })
     100              : 
     101         2356 : const zGalleriaInputSpec = zBaseInputOptions.extend({
     102              :   type: z.literal('GALLERIA'),
     103              :   name: z.string(),
     104              :   isOptional: z.boolean().optional(),
     105              :   images: z.array(z.string()).optional(),
     106              :   options: z.object({ images: z.array(z.string()).optional() }).optional()
     107              : })
     108              : 
     109         2356 : const zColorsInputSpec = zBaseInputOptions.extend({
     110              :   type: z.literal('COLORS'),
     111              :   name: z.string(),
     112              :   isOptional: z.boolean().optional(),
     113              :   default: z.array(z.string()).optional()
     114              : })
     115              : 
     116         2356 : const zBoundingBoxesInputSpec = zBaseInputOptions.extend({
     117              :   type: z.literal('BOUNDING_BOXES'),
     118              :   name: z.string(),
     119              :   isOptional: z.boolean().optional(),
     120              :   default: z
     121              :     .array(
     122              :       z.object({
     123              :         x: z.number(),
     124              :         y: z.number(),
     125              :         width: z.number(),
     126              :         height: z.number(),
     127              :         metadata: z.object({
     128              :           type: z.enum(['obj', 'text']),
     129              :           text: z.string(),
     130              :           desc: z.string(),
     131              :           palette: z.array(z.string())
     132              :         })
     133              :       })
     134              :     )
     135              :     .optional(),
     136              :   max_boxes: z.number().int().positive().optional()
     137              : })
     138              : 
     139         2356 : const zTextareaInputSpec = zBaseInputOptions.extend({
     140              :   type: z.literal('TEXTAREA'),
     141              :   name: z.string(),
     142              :   isOptional: z.boolean().optional(),
     143              :   rows: z.number().optional(),
     144              :   cols: z.number().optional(),
     145              :   default: z.string().optional(),
     146              :   options: z
     147              :     .object({
     148              :       rows: z.number().optional(),
     149              :       cols: z.number().optional(),
     150              :       default: z.string().optional()
     151              :     })
     152              :     .optional()
     153              : })
     154              : 
     155         2356 : const zCurvePoint = z.tuple([z.number(), z.number()])
     156              : 
     157         2356 : const zCurveData = z.object({
     158              :   points: z.array(zCurvePoint),
     159              :   interpolation: z.enum(['monotone_cubic', 'linear'])
     160              : })
     161              : 
     162         2356 : const zCurveInputSpec = zBaseInputOptions.extend({
     163              :   type: z.literal('CURVE'),
     164              :   name: z.string(),
     165              :   isOptional: z.boolean().optional(),
     166              :   default: zCurveData.optional()
     167              : })
     168              : 
     169         2356 : const zRangeValue = z.object({
     170              :   min: z.number(),
     171              :   max: z.number(),
     172              :   midpoint: z.number().optional()
     173              : })
     174              : 
     175         2356 : const zRangeInputSpec = zBaseInputOptions.extend({
     176              :   type: z.literal('RANGE'),
     177              :   name: z.string(),
     178              :   isOptional: z.boolean().optional(),
     179              :   default: zRangeValue.optional(),
     180              :   display: z.enum(['plain', 'gradient', 'histogram']).optional(),
     181              :   gradient_stops: z.array(zColorStop).optional(),
     182              :   show_midpoint: z.boolean().optional(),
     183              :   midpoint_scale: z.enum(['linear', 'gamma']).optional(),
     184              :   value_min: z.number().optional(),
     185              :   value_max: z.number().optional()
     186              : })
     187              : 
     188         2356 : const zVideoEditValue = z.object({
     189              :   trim: z
     190              :     .object({
     191              :       start_time: z.number(),
     192              :       duration: z.number()
     193              :     })
     194              :     .optional(),
     195              :   crop: z
     196              :     .object({
     197              :       x: z.number(),
     198              :       y: z.number(),
     199              :       width: z.number(),
     200              :       height: z.number()
     201              :     })
     202              :     .optional()
     203              : })
     204              : 
     205         2356 : const zVideoEditInputSpec = zBaseInputOptions.extend({
     206              :   type: z.literal('VIDEO_EDIT'),
     207              :   name: z.string(),
     208              :   isOptional: z.boolean().optional(),
     209              :   features: z.array(z.enum(['trim', 'crop'])).optional(),
     210              :   default: zVideoEditValue.optional()
     211              : })
     212              : 
     213         2356 : const zVideoConcatInputSpec = zBaseInputOptions.extend({
     214              :   type: z.literal('VIDEO_CONCAT'),
     215              :   name: z.string(),
     216              :   isOptional: z.boolean().optional(),
     217              :   source: z.string(),
     218              :   default: z.object({ order: z.array(z.string()).optional() }).optional()
     219              : })
     220              : 
     221         2356 : const zResolutionPreviewInputSpec = zBaseInputOptions.extend({
     222              :   type: z.literal('RESOLUTION_PREVIEW'),
     223              :   name: z.string(),
     224              :   isOptional: z.boolean().optional(),
     225              :   ratio_widget: z.string().optional(),
     226              :   megapixels_widget: z.string().optional(),
     227              :   multiple_widget: z.string().optional()
     228              : })
     229              : 
     230         2356 : const zCustomInputSpec = zBaseInputOptions.extend({
     231              :   type: z.string(),
     232              :   name: z.string(),
     233              :   isOptional: z.boolean().optional()
     234              : })
     235              : 
     236         2356 : const zInputSpec = z.union([
     237              :   zIntInputSpec,
     238              :   zFloatInputSpec,
     239              :   zBooleanInputSpec,
     240              :   zStringInputSpec,
     241              :   zComboInputSpec,
     242              :   zColorInputSpec,
     243              :   zImageInputSpec,
     244              :   zImageCompareInputSpec,
     245              :   zBoundingBoxInputSpec,
     246              :   zMarkdownInputSpec,
     247              :   zChartInputSpec,
     248              :   zGalleriaInputSpec,
     249              :   zColorsInputSpec,
     250              :   zBoundingBoxesInputSpec,
     251              :   zTextareaInputSpec,
     252              :   zCurveInputSpec,
     253              :   zRangeInputSpec,
     254              :   zVideoEditInputSpec,
     255              :   zVideoConcatInputSpec,
     256              :   zResolutionPreviewInputSpec,
     257              :   zCustomInputSpec
     258              : ])
     259              : 
     260              : // Output specs
     261         2356 : const zOutputSpec = z.object({
     262              :   index: z.number(),
     263              :   name: z.string(),
     264              :   type: z.string(),
     265              :   is_list: z.boolean(),
     266              :   options: z.array(z.any()).optional(),
     267              :   tooltip: z.string().optional()
     268              : })
     269              : 
     270              : // Main node definition schema
     271         2356 : export const zComfyNodeDef = z.object({
     272              :   inputs: z.record(z.string(), zInputSpec),
     273              :   outputs: z.array(zOutputSpec),
     274              :   hidden: z.record(z.string(), z.unknown()).optional(),
     275              : 
     276              :   name: z.string(),
     277              :   display_name: z.string(),
     278              :   description: z.string(),
     279              :   help: z.string().optional(),
     280              :   category: z.string(),
     281              :   output_node: z.boolean(),
     282              :   python_module: z.string(),
     283              :   deprecated: z.boolean().optional(),
     284              :   experimental: z.boolean().optional(),
     285              :   dev_only: z.boolean().optional(),
     286              :   api_node: z.boolean().optional()
     287              : })
     288              : 
     289              : // Export types
     290              : type IntInputSpec = z.infer<typeof zIntInputSpec>
     291              : type FloatInputSpec = z.infer<typeof zFloatInputSpec>
     292              : type BooleanInputSpec = z.infer<typeof zBooleanInputSpec>
     293              : type StringInputSpec = z.infer<typeof zStringInputSpec>
     294              : export type ComboInputSpec = z.infer<typeof zComboInputSpec>
     295              : export type ColorInputSpec = z.infer<typeof zColorInputSpec>
     296              : export type ImageCompareInputSpec = z.infer<typeof zImageCompareInputSpec>
     297              : export type BoundingBoxInputSpec = z.infer<typeof zBoundingBoxInputSpec>
     298              : export type ChartInputSpec = z.infer<typeof zChartInputSpec>
     299              : export type GalleriaInputSpec = z.infer<typeof zGalleriaInputSpec>
     300              : export type ColorsInputSpec = z.infer<typeof zColorsInputSpec>
     301              : export type BoundingBoxesInputSpec = z.infer<typeof zBoundingBoxesInputSpec>
     302              : export type TextareaInputSpec = z.infer<typeof zTextareaInputSpec>
     303              : export type CurveInputSpec = z.infer<typeof zCurveInputSpec>
     304              : export type RangeInputSpec = z.infer<typeof zRangeInputSpec>
     305              : export type VideoEditInputSpec = z.infer<typeof zVideoEditInputSpec>
     306              : type VideoConcatInputSpec = z.infer<typeof zVideoConcatInputSpec>
     307              : export type ResolutionPreviewInputSpec = z.infer<
     308              :   typeof zResolutionPreviewInputSpec
     309              : >
     310              : export type CustomInputSpec = z.infer<typeof zCustomInputSpec>
     311              : 
     312              : export type InputSpec = z.infer<typeof zInputSpec>
     313              : export type OutputSpec = z.infer<typeof zOutputSpec>
     314              : export type ComfyNodeDef = z.infer<typeof zComfyNodeDef>
     315              : 
     316         2356 : export const isIntInputSpec = (
     317              :   inputSpec: InputSpec
     318              : ): inputSpec is IntInputSpec => {
     319        16175 :   return inputSpec.type === 'INT'
     320              : }
     321              : 
     322         2356 : export const isFloatInputSpec = (
     323              :   inputSpec: InputSpec
     324              : ): inputSpec is FloatInputSpec => {
     325         7257 :   return inputSpec.type === 'FLOAT'
     326              : }
     327              : 
     328         2356 : export const isBooleanInputSpec = (
     329              :   inputSpec: InputSpec
     330              : ): inputSpec is BooleanInputSpec => {
     331          326 :   return inputSpec.type === 'BOOLEAN'
     332              : }
     333              : 
     334         2356 : export const isStringInputSpec = (
     335              :   inputSpec: InputSpec
     336              : ): inputSpec is StringInputSpec => {
     337         9778 :   return inputSpec.type === 'STRING'
     338              : }
     339              : 
     340         2356 : export const isComboInputSpec = (
     341              :   inputSpec: InputSpec
     342              : ): inputSpec is ComboInputSpec => {
     343        28113 :   return inputSpec.type === 'COMBO'
     344              : }
     345              : 
     346         2356 : export const isChartInputSpec = (
     347              :   inputSpec: InputSpec
     348              : ): inputSpec is ChartInputSpec => {
     349            0 :   return inputSpec.type === 'CHART'
     350              : }
     351              : 
     352         2356 : export const isColorInputSpec = (
     353              :   inputSpec: InputSpec
     354              : ): inputSpec is ColorInputSpec => {
     355           34 :   return inputSpec.type === 'COLOR'
     356              : }
     357              : 
     358         2356 : export const isTextareaInputSpec = (
     359              :   inputSpec: InputSpec
     360              : ): inputSpec is TextareaInputSpec => {
     361            0 :   return inputSpec.type === 'TEXTAREA'
     362              : }
     363              : 
     364         2356 : export const isGalleriaInputSpec = (
     365              :   inputSpec: InputSpec
     366              : ): inputSpec is GalleriaInputSpec => {
     367            0 :   return inputSpec.type === 'GALLERIA'
     368              : }
     369              : 
     370         2356 : export const isVideoConcatInputSpec = (
     371              :   inputSpec: InputSpec
     372              : ): inputSpec is VideoConcatInputSpec => {
     373            0 :   return inputSpec.type === 'VIDEO_CONCAT'
     374              : }
     375              : 
     376         2356 : export const isResolutionPreviewInputSpec = (
     377              :   inputSpec: InputSpec
     378              : ): inputSpec is ResolutionPreviewInputSpec => {
     379            3 :   return inputSpec.type === 'RESOLUTION_PREVIEW'
     380              : }
        

Generated by: LCOV version 2.0-1