Merge branch 'main' into lstein/global-configuration

.github/workflows/mkdocs-material.yml

@@ -36,7 +36,7 @@ jobs:
             --verbose
 
       - name: deploy to gh-pages
-        if: ${{ github.ref == 'refs/heads/main' }}
+        if: ${{ github.ref == 'refs/heads/v2.3' }}
         run: |
           python -m \
             mkdocs gh-deploy \

invokeai/frontend/web/src/features/nodes/components/InputFieldComponent.tsx

@@ -10,6 +10,7 @@ import ConditioningInputFieldComponent from './fields/ConditioningInputFieldComp
 import ModelInputFieldComponent from './fields/ModelInputFieldComponent';
 import NumberInputFieldComponent from './fields/NumberInputFieldComponent';
 import StringInputFieldComponent from './fields/StringInputFieldComponent';
+import ItemInputFieldComponent from './fields/ItemInputFieldComponent';
 
 type InputFieldComponentProps = {
   nodeId: string;
@@ -115,6 +116,16 @@ const InputFieldComponent = (props: InputFieldComponentProps) => {
     );
   }
 
+  if (type === 'item' && template.type === 'item') {
+    return (
+      <ItemInputFieldComponent
+        nodeId={nodeId}
+        field={field}
+        template={template}
+      />
+    );
+  }
+
   return <Box p={2}>Unknown field type: {type}</Box>;
 };
 

invokeai/frontend/web/src/features/nodes/components/fields/ItemInputFieldComponent.tsx

@@ -0,0 +1,17 @@
+import {
+  ItemInputFieldTemplate,
+  ItemInputFieldValue,
+} from 'features/nodes/types/types';
+import { memo } from 'react';
+import { FaAddressCard, FaList } from 'react-icons/fa';
+import { FieldComponentProps } from './types';
+
+const ItemInputFieldComponent = (
+  props: FieldComponentProps<ItemInputFieldValue, ItemInputFieldTemplate>
+) => {
+  const { nodeId, field } = props;
+
+  return <FaAddressCard />;
+};
+
+export default memo(ItemInputFieldComponent);

invokeai/frontend/web/src/features/nodes/types/constants.ts

@@ -14,6 +14,7 @@ export const FIELD_TYPE_MAP: Record<string, FieldType> = {
   ConditioningField: 'conditioning',
   model: 'model',
   array: 'array',
+  item: 'item',
 };
 
 const COLOR_TOKEN_VALUE = 500;
@@ -82,4 +83,10 @@ export const FIELDS: Record<FieldType, FieldUIConfig> = {
     title: 'Array',
     description: 'TODO: Array type description.',
   },
+  item: {
+    color: 'gray',
+    colorCssVar: getColorTokenCssVariable('gray'),
+    title: 'Collection Item',
+    description: 'TODO: Collection Item type description.',
+  },
 };

invokeai/frontend/web/src/features/nodes/types/types.ts

@@ -58,7 +58,8 @@ export type FieldType =
   | 'latents'
   | 'conditioning'
   | 'model'
-  | 'array';
+  | 'array'
+  | 'item';
 
 /**
  * An input field is persisted across reloads as part of the user's local state.
@@ -78,7 +79,8 @@ export type InputFieldValue =
   | ConditioningInputFieldValue
   | EnumInputFieldValue
   | ModelInputFieldValue
-  | ArrayInputFieldValue;
+  | ArrayInputFieldValue
+  | ItemInputFieldValue;
 
 /**
  * An input field template is generated on each page load from the OpenAPI schema.
@@ -96,7 +98,8 @@ export type InputFieldTemplate =
   | ConditioningInputFieldTemplate
   | EnumInputFieldTemplate
   | ModelInputFieldTemplate
-  | ArrayInputFieldTemplate;
+  | ArrayInputFieldTemplate
+  | ItemInputFieldTemplate;
 
 /**
  * An output field is persisted across as part of the user's local state.
@@ -185,6 +188,11 @@ export type ArrayInputFieldValue = FieldValueBase & {
   value?: (string | number)[];
 };
 
+export type ItemInputFieldValue = FieldValueBase & {
+  type: 'item';
+  value?: undefined;
+};
+
 export type InputFieldTemplateBase = {
   name: string;
   title: string;
@@ -255,10 +263,15 @@ export type ModelInputFieldTemplate = InputFieldTemplateBase & {
 };
 
 export type ArrayInputFieldTemplate = InputFieldTemplateBase & {
-  default: (string | number)[];
+  default: [];
   type: 'array';
 };
 
+export type ItemInputFieldTemplate = InputFieldTemplateBase & {
+  default: undefined;
+  type: 'item';
+};
+
 /**
  * JANKY CUSTOMISATION OF OpenAPI SCHEMA TYPES
  */

invokeai/frontend/web/src/features/nodes/util/fieldTemplateBuilders.ts

@@ -16,6 +16,8 @@ import {
   OutputFieldTemplate,
   TypeHints,
   FieldType,
+  ArrayInputFieldTemplate,
+  ItemInputFieldTemplate,
 } from '../types/types';
 
 export type BaseFieldProperties = 'name' | 'title' | 'description';
@@ -230,6 +232,36 @@ const buildEnumInputFieldTemplate = ({
   return template;
 };
 
+const buildArrayInputFieldTemplate = ({
+  schemaObject,
+  baseField,
+}: BuildInputFieldArg): ArrayInputFieldTemplate => {
+  const template: ArrayInputFieldTemplate = {
+    ...baseField,
+    type: 'array',
+    inputRequirement: 'always',
+    inputKind: 'direct',
+    default: [],
+  };
+
+  return template;
+};
+
+const buildItemInputFieldTemplate = ({
+  schemaObject,
+  baseField,
+}: BuildInputFieldArg): ItemInputFieldTemplate => {
+  const template: ItemInputFieldTemplate = {
+    ...baseField,
+    type: 'item',
+    inputRequirement: 'always',
+    inputKind: 'direct',
+    default: undefined,
+  };
+
+  return template;
+};
+
 export const getFieldType = (
   schemaObject: OpenAPIV3.SchemaObject,
   name: string,
@@ -303,6 +335,12 @@ export const buildInputFieldTemplate = (
   if (['boolean'].includes(fieldType)) {
     return buildBooleanInputFieldTemplate({ schemaObject, baseField });
   }
+  if (['array'].includes(fieldType)) {
+    return buildArrayInputFieldTemplate({ schemaObject, baseField });
+  }
+  if (['item'].includes(fieldType)) {
+    return buildItemInputFieldTemplate({ schemaObject, baseField });
+  }
 
   return;
 };

invokeai/frontend/web/src/features/nodes/util/linearGraphBuilder/buildIterateNode.ts

@@ -7,7 +7,7 @@ export const buildIterateNode = (): IterateInvocation => {
   return {
     id: nodeId,
     type: 'iterate',
-    collection: [],
+    // collection: [],
-    index: 0,
+    // index: 0,
   };
 };

invokeai/frontend/web/src/features/nodes/util/parseSchema.ts

@@ -13,7 +13,7 @@ import {
   buildOutputFieldTemplates,
 } from './fieldTemplateBuilders';
 
-const invocationDenylist = ['Graph', 'Collect', 'LoadImage'];
+const invocationDenylist = ['Graph', 'LoadImage'];
 
 export const parseSchema = (openAPI: OpenAPIV3.Document) => {
   // filter out non-invocation schemas, plus some tricky invocations for now
@@ -32,49 +32,62 @@ export const parseSchema = (openAPI: OpenAPIV3.Document) => {
     if (isInvocationSchemaObject(schema)) {
       const type = schema.properties.type.default;
 
-      const title =
+      const title = schema.ui?.title ?? schema.title.replace('Invocation', '');
-        schema.ui?.title ??
-        schema.title
-          .replace('Invocation', '')
-          .split(/(?=[A-Z])/) // split PascalCase into array
-          .join(' ');
 
       const typeHints = schema.ui?.type_hints;
 
-      const inputs = reduce(
+      const inputs: Record<string, InputFieldTemplate> = {};
-        schema.properties,
+
-        (inputsAccumulator, property, propertyName) => {
+      if (type === 'collect') {
-          if (
+        const itemProperty = schema.properties[
-            // `type` and `id` are not valid inputs/outputs
+          'item'
-            !['type', 'id'].includes(propertyName) &&
+        ] as InvocationSchemaObject;
-            isSchemaObject(property)
+        // Handle the special Collect node
-          ) {
+        inputs.item = {
-            let field: InputFieldTemplate | undefined;
+          type: 'item',
-            if (propertyName === 'collection') {
+          name: 'item',
-              field = {
+          description: itemProperty.description ?? '',
-                default: property.default ?? [],
+          title: 'Collection Item',
-                name: 'collection',
+          inputKind: 'connection',
-                title: property.title ?? '',
+          inputRequirement: 'always',
-                description: property.description ?? '',
+          default: undefined,
-                type: 'array',
+        };
-                inputRequirement: 'always',
+      } else if (type === 'iterate') {
-                inputKind: 'connection',
+        const itemProperty = schema.properties[
-              };
+          'collection'
-            } else {
+        ] as InvocationSchemaObject;
-              field = buildInputFieldTemplate(
+
-                property,
+        inputs.collection = {
-                propertyName,
+          type: 'array',
-                typeHints
+          name: 'collection',
-              );
+          title: itemProperty.title ?? '',
+          default: [],
+          description: itemProperty.description ?? '',
+          inputRequirement: 'always',
+          inputKind: 'connection',
+        };
+      } else {
+        // All other nodes
+        reduce(
+          schema.properties,
+          (inputsAccumulator, property, propertyName) => {
+            if (
+              // `type` and `id` are not valid inputs/outputs
+              !['type', 'id'].includes(propertyName) &&
+              isSchemaObject(property)
+            ) {
+              const field: InputFieldTemplate | undefined =
+                buildInputFieldTemplate(property, propertyName, typeHints);
+
+              if (field) {
+                inputsAccumulator[propertyName] = field;
+              }
             }
-            if (field) {
+            return inputsAccumulator;
-              inputsAccumulator[propertyName] = field;
+          },
-            }
+          inputs
-          }
+        );
-          return inputsAccumulator;
+      }
-        },
-        {} as Record<string, InputFieldTemplate>
-      );
 
       const rawOutput = (schema as InvocationSchemaObject).output;
 

invokeai/frontend/web/src/features/system/store/systemSlice.ts

@@ -107,7 +107,7 @@ const initialSystemState: SystemState = {
   subscribedNodeIds: [],
   wereModelsReceived: false,
   wasSchemaParsed: false,
-  consoleLogLevel: 'error',
+  consoleLogLevel: 'debug',
   shouldLogToConsole: true,
   statusTranslationKey: 'common.statusDisconnected',
   canceledSession: '',