diff --git a/browser_tests/assets/vueNodes/linked-standard-widgets.json b/browser_tests/assets/vueNodes/linked-standard-widgets.json
new file mode 100644
index 00000000000..a85a0299345
--- /dev/null
+++ b/browser_tests/assets/vueNodes/linked-standard-widgets.json
@@ -0,0 +1,134 @@
+{
+ "id": "bc8526ee-e7ce-4b81-9a55-12a34d43cc3a",
+ "revision": 0,
+ "last_node_id": 2,
+ "last_link_id": 9,
+ "nodes": [
+ {
+ "id": 1,
+ "type": "DevToolsLinkedStandardWidgetSource",
+ "pos": [-1600, 100],
+ "size": [360, 270],
+ "flags": {},
+ "order": 0,
+ "mode": 0,
+ "inputs": [],
+ "outputs": [
+ { "name": "plain_text", "type": "STRING", "links": [1] },
+ { "name": "integer", "type": "INT", "links": [2] },
+ { "name": "number", "type": "FLOAT", "links": [3] },
+ { "name": "slider", "type": "FLOAT", "links": [4] },
+ { "name": "switch", "type": "BOOLEAN", "links": [5] },
+ { "name": "labeled_toggle", "type": "BOOLEAN", "links": [6] },
+ { "name": "select", "type": "COMBO", "links": [7] },
+ { "name": "color", "type": "COLOR", "links": [8] },
+ { "name": "textarea", "type": "STRING", "links": [9] }
+ ],
+ "properties": {
+ "Node name for S&R": "DevToolsLinkedStandardWidgetSource"
+ },
+ "widgets_values": []
+ },
+ {
+ "id": 2,
+ "type": "DevToolsLinkedStandardWidgets",
+ "pos": [200, 100],
+ "size": [560, 620],
+ "flags": {},
+ "order": 1,
+ "mode": 0,
+ "inputs": [
+ {
+ "name": "plain_text",
+ "type": "STRING",
+ "widget": { "name": "plain_text" },
+ "link": 1
+ },
+ {
+ "name": "integer",
+ "type": "INT",
+ "widget": { "name": "integer" },
+ "link": 2
+ },
+ {
+ "name": "number",
+ "type": "FLOAT",
+ "widget": { "name": "number" },
+ "link": 3
+ },
+ {
+ "name": "slider",
+ "type": "FLOAT",
+ "widget": { "name": "slider" },
+ "link": 4
+ },
+ {
+ "name": "switch",
+ "type": "BOOLEAN",
+ "widget": { "name": "switch" },
+ "link": 5
+ },
+ {
+ "name": "labeled_toggle",
+ "type": "BOOLEAN",
+ "widget": { "name": "labeled_toggle" },
+ "link": 6
+ },
+ {
+ "name": "select",
+ "type": "COMBO",
+ "widget": { "name": "select" },
+ "link": 7
+ },
+ {
+ "name": "color",
+ "type": "COLOR",
+ "widget": { "name": "color" },
+ "link": 8
+ },
+ {
+ "name": "textarea",
+ "type": "STRING",
+ "widget": { "name": "textarea" },
+ "link": 9
+ }
+ ],
+ "outputs": [],
+ "properties": {
+ "Node name for S&R": "DevToolsLinkedStandardWidgets"
+ },
+ "widgets_values": [
+ "STALE PLAIN TEXT",
+ 314,
+ 9.875,
+ 0.73,
+ true,
+ false,
+ "STALE SELECT VALUE",
+ "#22c55d",
+ "STALE MULTILINE PROMPT"
+ ]
+ }
+ ],
+ "links": [
+ [1, 1, 0, 2, 0, "STRING"],
+ [2, 1, 1, 2, 1, "INT"],
+ [3, 1, 2, 2, 2, "FLOAT"],
+ [4, 1, 3, 2, 3, "FLOAT"],
+ [5, 1, 4, 2, 4, "BOOLEAN"],
+ [6, 1, 5, 2, 5, "BOOLEAN"],
+ [7, 1, 6, 2, 6, "COMBO"],
+ [8, 1, 7, 2, 7, "COLOR"],
+ [9, 1, 8, 2, 8, "STRING"]
+ ],
+ "groups": [],
+ "config": {},
+ "extra": {
+ "ds": {
+ "scale": 1,
+ "offset": [0, 0]
+ },
+ "frontendVersion": "1.28.6"
+ },
+ "version": 0.4
+}
diff --git a/browser_tests/assets/widgets/linked_multiline_string.json b/browser_tests/assets/widgets/linked_multiline_string.json
new file mode 100644
index 00000000000..87573f64630
--- /dev/null
+++ b/browser_tests/assets/widgets/linked_multiline_string.json
@@ -0,0 +1,72 @@
+{
+ "last_node_id": 2,
+ "last_link_id": 1,
+ "nodes": [
+ {
+ "id": 1,
+ "type": "CLIPTextEncode",
+ "pos": [440, 80],
+ "size": [520, 280],
+ "flags": {},
+ "order": 1,
+ "mode": 0,
+ "inputs": [
+ {
+ "name": "clip",
+ "type": "CLIP",
+ "link": null
+ },
+ {
+ "name": "text",
+ "type": "STRING",
+ "widget": {
+ "name": "text"
+ },
+ "link": 1
+ }
+ ],
+ "outputs": [
+ {
+ "name": "CONDITIONING",
+ "type": "CONDITIONING",
+ "links": null
+ }
+ ],
+ "properties": {
+ "Node name for S&R": "CLIPTextEncode"
+ },
+ "widgets_values": ["stale local prompt"]
+ },
+ {
+ "id": 2,
+ "type": "PrimitiveString",
+ "pos": [40, 120],
+ "size": [315, 58],
+ "flags": {},
+ "order": 0,
+ "mode": 0,
+ "inputs": [],
+ "outputs": [
+ {
+ "name": "STRING",
+ "type": "STRING",
+ "links": [1]
+ }
+ ],
+ "properties": {
+ "Node name for S&R": "PrimitiveString"
+ },
+ "widgets_values": ["authoritative upstream prompt"]
+ }
+ ],
+ "links": [[1, 2, 0, 1, 1, "STRING"]],
+ "groups": [],
+ "config": {},
+ "extra": {
+ "ds": {
+ "offset": [0, 0],
+ "scale": 1
+ }
+ },
+ "version": 0.4
+}
diff --git a/browser_tests/fixtures/selectors.ts b/browser_tests/fixtures/selectors.ts
index 10ccb882559..3cc1e947535 100644
--- a/browser_tests/fixtures/selectors.ts
+++ b/browser_tests/fixtures/selectors.ts
@@ -174,6 +174,8 @@ export const TestIds = {
widgets: {
container: 'node-widgets',
widget: 'node-widget',
+ linkedContent: 'linked-widget-content',
+ linkedPlaceholder: 'linked-widget-placeholder',
layoutFieldLabel: 'widget-layout-field-label',
formDropdownMenu: 'form-dropdown-menu',
decrement: 'decrement',
diff --git a/browser_tests/fixtures/utils/promotedMissingModel.ts b/browser_tests/fixtures/utils/promotedMissingModel.ts
index 1984e118701..9b13e1788ac 100644
--- a/browser_tests/fixtures/utils/promotedMissingModel.ts
+++ b/browser_tests/fixtures/utils/promotedMissingModel.ts
@@ -235,18 +235,23 @@ export async function expectResolvedPromotedModelSuppressesStaleInteriorErrors(
const node = comfyPage.vueNodes.getNodeByTitle(step.nodeTitle)
await expect(node).toBeVisible()
- const staleCombo = node.getByRole('combobox', {
- name: PROMOTED_MODEL_WIDGET_NAME,
+ const linkedStatus = node.getByRole('img', {
+ name: `${PROMOTED_MODEL_WIDGET_NAME}: Linked input`,
exact: true
})
await expect(
- staleCombo,
- `${step.nodeTitle} should expose the stale linked interior widget`
- ).toBeDisabled()
+ linkedStatus,
+ `${step.nodeTitle} should expose the linked interior status`
+ ).toBeVisible()
+ const staleValue = node.getByText(staleModelName, { exact: true })
await expect(
- staleCombo,
- `${step.nodeTitle} should keep the stale interior value`
- ).toContainText(staleModelName)
+ staleValue,
+ `${step.nodeTitle} should retain the stale interior value`
+ ).toBeAttached()
+ await expect(
+ staleValue,
+ `${step.nodeTitle} should hide the stale interior value`
+ ).toBeHidden()
await expectNoMissingModelUi(comfyPage)
}
}
diff --git a/browser_tests/tests/subgraph/subgraphNested.spec.ts b/browser_tests/tests/subgraph/subgraphNested.spec.ts
index 7b30330e96a..ec894f134f0 100644
--- a/browser_tests/tests/subgraph/subgraphNested.spec.ts
+++ b/browser_tests/tests/subgraph/subgraphNested.spec.ts
@@ -64,13 +64,21 @@ test.describe('Nested Subgraphs', { tag: ['@subgraph'] }, () => {
await comfyExpect(innerNode).toBeVisible()
const innerTextboxes = innerNode.getByRole('textbox')
- await comfyExpect(innerTextboxes).toHaveCount(2)
- const innerValues = await innerTextboxes.evaluateAll<
- string[],
- HTMLInputElement
- >((boxes) => boxes.map((b) => b.value))
- comfyExpect(innerValues).toContain('11111111111')
- comfyExpect(innerValues).toContain('22222222222')
+ await comfyExpect(innerTextboxes).toHaveCount(1)
+ await comfyExpect(innerTextboxes).toHaveValue('11111111111')
+
+ await comfyExpect(
+ innerNode.getByRole('img', {
+ name: 'text_1: Linked input',
+ exact: true
+ })
+ ).toBeVisible()
+ const linkedTextbox = innerNode.getByTestId(
+ TestIds.widgets.linkedContent
+ )
+ await comfyExpect(linkedTextbox).toHaveCount(1)
+ await comfyExpect(linkedTextbox).toHaveValue('22222222222')
+ await comfyExpect(linkedTextbox).toBeHidden()
})
}
)
diff --git a/browser_tests/tests/subgraph/subgraphPromotion.spec.ts b/browser_tests/tests/subgraph/subgraphPromotion.spec.ts
index b39a1451eaf..6509cc288fb 100644
--- a/browser_tests/tests/subgraph/subgraphPromotion.spec.ts
+++ b/browser_tests/tests/subgraph/subgraphPromotion.spec.ts
@@ -471,12 +471,18 @@ test.describe(
.toEqual(expect.arrayContaining(['string_a', 'value']))
const subgraphNode = comfyPage.vueNodes.getNodeLocator('5')
- const linkedTextarea = subgraphNode.getByRole('textbox', {
- name: 'string_a',
- exact: true
- })
- await expect(linkedTextarea).toBeVisible()
+ await expect(
+ subgraphNode.getByRole('img', {
+ name: 'string_a: Linked input',
+ exact: true
+ })
+ ).toBeVisible()
+ const linkedTextarea = subgraphNode.getByTestId(
+ TestIds.widgets.linkedContent
+ )
+ await expect(linkedTextarea).toHaveCount(1)
await expect(linkedTextarea).toBeDisabled()
+ await expect(linkedTextarea).toBeHidden()
const allTextareas = subgraphNode.getByRole('textbox')
await expect(allTextareas.first()).toBeVisible()
diff --git a/browser_tests/tests/subgraph/subgraphPromotionDom.spec.ts b/browser_tests/tests/subgraph/subgraphPromotionDom.spec.ts
index eb44157d899..e894afa4a53 100644
--- a/browser_tests/tests/subgraph/subgraphPromotionDom.spec.ts
+++ b/browser_tests/tests/subgraph/subgraphPromotionDom.spec.ts
@@ -152,10 +152,15 @@ test.describe(
await openSubgraphById(comfyPage, '11')
- const interiorTextareas = comfyPage.page
- .locator('[data-node-id]')
- .getByRole('textbox')
- await expect(interiorTextareas).toHaveCount(2)
+ const interiorNodes = comfyPage.page.locator('[data-node-id]')
+ await expect(interiorNodes.locator('textarea')).toHaveCount(2)
+ await expect(interiorNodes.getByRole('textbox')).toHaveCount(0)
+ await expect(
+ interiorNodes.getByRole('img', {
+ name: 'text: Linked input',
+ exact: true
+ })
+ ).toHaveCount(2)
await comfyPage.subgraph.exitViaBreadcrumb()
diff --git a/browser_tests/tests/subgraph/subgraphSerialization.spec.ts b/browser_tests/tests/subgraph/subgraphSerialization.spec.ts
index f818473db02..4198b0ae79a 100644
--- a/browser_tests/tests/subgraph/subgraphSerialization.spec.ts
+++ b/browser_tests/tests/subgraph/subgraphSerialization.spec.ts
@@ -733,11 +733,16 @@ test.describe('Subgraph Serialization', { tag: ['@subgraph'] }, () => {
const outerNode = comfyPage.vueNodes.getNodeLocator('5')
await expect(outerNode).toBeVisible()
- const textarea = outerNode
- .getByRole('textbox', { name: 'string_a' })
- .first()
- await expect(textarea).toBeVisible()
+ await expect(
+ outerNode.getByRole('img', {
+ name: 'string_a: Linked input',
+ exact: true
+ })
+ ).toBeVisible()
+ const textarea = outerNode.getByTestId(TestIds.widgets.linkedContent)
+ await expect(textarea).toHaveCount(1)
await expect(textarea).toBeDisabled()
+ await expect(textarea).toBeHidden()
})
test('No legacy-prefixed or disconnected widgets remain on the node', async ({
diff --git a/browser_tests/tests/subgraph/subgraphSlots.spec.ts b/browser_tests/tests/subgraph/subgraphSlots.spec.ts
index ac46a936efa..6c61b52695d 100644
--- a/browser_tests/tests/subgraph/subgraphSlots.spec.ts
+++ b/browser_tests/tests/subgraph/subgraphSlots.spec.ts
@@ -419,9 +419,12 @@ test.describe('Subgraph Slots', { tag: ['@slow', '@subgraph'] }, () => {
const subgraphNode = comfyPage.vueNodes.getNodeLocator('19')
await expect(subgraphNode).toBeVisible()
- const seedWidget = subgraphNode.getByLabel('seed', { exact: true })
- await expect(seedWidget).toBeVisible()
- await SubgraphHelper.expectWidgetBelowHeader(subgraphNode, seedWidget)
+ const seedStatus = subgraphNode.getByRole('img', {
+ name: 'renamed_seed: Linked input',
+ exact: true
+ })
+ await expect(seedStatus).toBeVisible()
+ await SubgraphHelper.expectWidgetBelowHeader(subgraphNode, seedStatus)
await comfyPage.settings.setSetting('Comfy.VueNodes.Enabled', false)
@@ -475,16 +478,17 @@ test.describe('Subgraph Slots', { tag: ['@slow', '@subgraph'] }, () => {
)
.toBe(RENAMED_LABEL)
- const seedWidgetAfter = subgraphNodeAfter.getByLabel('seed', {
+ const seedStatusAfter = subgraphNodeAfter.getByRole('img', {
+ name: `${RENAMED_LABEL}: Linked input`,
exact: true
})
- await expect(seedWidgetAfter).toBeVisible()
+ await expect(seedStatusAfter).toBeVisible()
await expect(
subgraphNodeAfter.getByText(RENAMED_LABEL, { exact: true })
).toBeVisible()
await SubgraphHelper.expectWidgetBelowHeader(
subgraphNodeAfter,
- seedWidgetAfter
+ seedStatusAfter
)
})
})
diff --git a/browser_tests/tests/vueNodes/widgets/advancedWidgets.spec.ts b/browser_tests/tests/vueNodes/widgets/advancedWidgets.spec.ts
index 6452587bd71..88a7a7e1d9e 100644
--- a/browser_tests/tests/vueNodes/widgets/advancedWidgets.spec.ts
+++ b/browser_tests/tests/vueNodes/widgets/advancedWidgets.spec.ts
@@ -87,7 +87,7 @@ test.describe('Advanced Widget Visibility', { tag: '@vue-nodes' }, () => {
await expect(widgets).toHaveCount(2)
})
- test('should keep connected advanced widgets visible when advanced inputs are hidden', async ({
+ test('should show linked status for connected advanced widgets when advanced inputs are hidden', async ({
comfyPage
}) => {
const node = getNode(comfyPage)
@@ -124,7 +124,10 @@ test.describe('Advanced Widget Visibility', { tag: '@vue-nodes' }, () => {
await node.getByText(HIDE_ADVANCED_INPUTS).click()
- await expect(maxShiftWidget).toBeVisible()
+ await expect(
+ node.getByRole('img', { name: 'max_shift: Linked input' })
+ ).toBeVisible()
+ await expect(maxShiftWidget).toBeHidden()
await expect(baseShiftWidget).toBeHidden()
})
diff --git a/browser_tests/tests/vueNodes/widgets/int/integerWidget.spec.ts b/browser_tests/tests/vueNodes/widgets/int/integerWidget.spec.ts
index 985d9f17d05..ac618bf12ce 100644
--- a/browser_tests/tests/vueNodes/widgets/int/integerWidget.spec.ts
+++ b/browser_tests/tests/vueNodes/widgets/int/integerWidget.spec.ts
@@ -2,41 +2,58 @@ import {
comfyExpect as expect,
comfyPageFixture as test
} from '@e2e/fixtures/ComfyPage'
+import { TestIds } from '@e2e/fixtures/selectors'
test.describe('Vue Integer Widget', { tag: '@vue-nodes' }, () => {
- test('should be disabled and not allow changing value when link connected to slot', async ({
+ test('should hide a linked value and restore the control after disconnect', async ({
comfyPage
}) => {
await comfyPage.workflow.loadWorkflow('vueNodes/linked-int-widget')
- const seedWidget = comfyPage.vueNodes
- .getWidgetByName('KSampler', 'seed')
- .first()
- const controls = comfyPage.vueNodes.getInputNumberControls(seedWidget)
- const initialValue = Number(await controls.input.inputValue())
-
- // Verify widget is disabled when linked
- await expect(controls.incrementButton).toBeDisabled()
- await expect(controls.decrementButton).toBeDisabled()
- await expect(controls.input).toHaveValue(initialValue.toString())
+ const samplerNode = comfyPage.vueNodes.getNodeByTitle('KSampler').first()
+ const placeholder = samplerNode.getByTestId(
+ TestIds.widgets.linkedPlaceholder
+ )
+ const linkedContent = samplerNode.getByTestId(TestIds.widgets.linkedContent)
+ const hiddenInput = linkedContent.locator('input[role="spinbutton"]')
+ const nodeBounds = await samplerNode.boundingBox()
+ const [samplerNodeRef] =
+ await comfyPage.nodeOps.getNodeRefsByType('KSampler')
+ if (!samplerNodeRef || !nodeBounds) {
+ throw new Error('Linked KSampler node did not render')
+ }
+ const seedWidgetRef = await samplerNodeRef.getWidgetByName('seed')
+ const initialValue = Number(await seedWidgetRef.getValue())
- await expect(seedWidget).toBeVisible()
+ await expect(placeholder).toHaveAccessibleName('seed: Linked input')
+ await expect(linkedContent).toHaveAttribute('inert', '')
+ await expect(hiddenInput).toBeDisabled()
+ await expect(
+ samplerNode.getByRole('spinbutton', { name: 'seed' })
+ ).toHaveCount(0)
+ await placeholder.click()
+ await expect.poll(() => seedWidgetRef.getValue()).toBe(initialValue)
- // Delete the node that is linked to the slot (freeing up the widget)
- // Click on the header to select the node (clicking center may land on
- // the widget area where pointerdown.stop prevents node selection)
await comfyPage.vueNodes
.getNodeByTitle('Int')
.locator('.lg-node-header')
.click()
await comfyPage.vueNodes.deleteSelected()
- // Test widget works when unlinked
+ await expect(placeholder).toHaveCount(0)
+ const seedWidget = comfyPage.vueNodes
+ .getWidgetByName('KSampler', 'seed')
+ .first()
+ const controls = comfyPage.vueNodes.getInputNumberControls(seedWidget)
+ await expect(controls.input).toHaveValue(initialValue.toString())
await controls.incrementButton.click()
await expect(controls.input).toHaveValue((initialValue + 1).toString())
await controls.decrementButton.click()
await expect(controls.input).toHaveValue(initialValue.toString())
+ await expect
+ .poll(async () => (await samplerNode.boundingBox())?.height)
+ .toBeCloseTo(nodeBounds.height, 0)
})
test('displays control widgets with default state', async ({ comfyPage }) => {
diff --git a/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts b/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts
new file mode 100644
index 00000000000..0d41199c6d2
--- /dev/null
+++ b/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts
@@ -0,0 +1,168 @@
+import {
+ comfyExpect as expect,
+ comfyPageFixture as test
+} from '@e2e/fixtures/ComfyPage'
+import { TestIds } from '@e2e/fixtures/selectors'
+
+const TARGET_NODE_TYPE = 'DevToolsLinkedStandardWidgets'
+const TARGET_NODE_TITLE = 'Linked Standard Widgets'
+const WIDGET_NAMES = [
+ 'plain_text',
+ 'integer',
+ 'number',
+ 'slider',
+ 'switch',
+ 'labeled_toggle',
+ 'select',
+ 'color',
+ 'textarea'
+] as const
+
+test.describe(
+ 'Linked standard Vue widgets',
+ { tag: ['@vue-nodes', '@widget', '@node'] },
+ () => {
+ test.beforeEach(async ({ comfyPage }) => {
+ await comfyPage.page.setViewportSize({ width: 1280, height: 900 })
+ await comfyPage.workflow.loadWorkflow('vueNodes/linked-standard-widgets')
+ })
+
+ test.afterEach(async ({ comfyPage }) => {
+ await comfyPage.canvasOps.resetView()
+ })
+
+ test(
+ 'renders each linked control surface',
+ { tag: '@screenshot' },
+ async ({ comfyPage }) => {
+ const [targetNodeRef] =
+ await comfyPage.nodeOps.getNodeRefsByType(TARGET_NODE_TYPE)
+ if (!targetNodeRef)
+ throw new Error('Target DevTools node was not loaded')
+ await targetNodeRef.centerOnNode()
+
+ const targetNode = comfyPage.vueNodes
+ .getNodeByTitle(TARGET_NODE_TITLE)
+ .first()
+ await expect(targetNode).toBeVisible()
+
+ const statuses = targetNode.getByTestId(
+ TestIds.widgets.linkedPlaceholder
+ )
+ await expect(statuses).toHaveCount(WIDGET_NAMES.length)
+
+ for (const name of WIDGET_NAMES) {
+ await expect(
+ targetNode.getByRole('img', {
+ name: `${name}: Linked input`
+ })
+ ).toBeVisible()
+ }
+
+ await comfyPage.nextFrame()
+ await comfyPage.nextFrame()
+ await expect(targetNode).toHaveScreenshot('linked-standard-widgets.png')
+ }
+ )
+
+ test('keeps linked controls inaccessible to focus', async ({
+ comfyPage
+ }) => {
+ const targetNode = comfyPage.vueNodes
+ .getNodeByTitle(TARGET_NODE_TITLE)
+ .first()
+ await expect(targetNode).toBeVisible()
+
+ const linkedContent = targetNode.getByTestId(
+ TestIds.widgets.linkedContent
+ )
+ await expect(linkedContent).toHaveCount(WIDGET_NAMES.length)
+
+ for (let index = 0; index < WIDGET_NAMES.length; index++) {
+ await expect(linkedContent.nth(index)).toHaveAttribute('inert', '')
+ await expect(linkedContent.nth(index)).toHaveAttribute(
+ 'aria-hidden',
+ 'true'
+ )
+ }
+
+ const interactive = targetNode.locator(
+ `[data-testid="${TestIds.widgets.linkedContent}"]:is(input, textarea, button, [role="slider"]), ` +
+ `[data-testid="${TestIds.widgets.linkedContent}"] :is(input, textarea, button, [role="slider"])`
+ )
+ const interactiveCount = await interactive.count()
+ expect(interactiveCount).toBeGreaterThan(WIDGET_NAMES.length)
+
+ const controlStates = await interactive.evaluateAll((elements) =>
+ elements.map((element) => {
+ const disabled =
+ element instanceof HTMLButtonElement ||
+ element instanceof HTMLInputElement ||
+ element instanceof HTMLTextAreaElement
+ ? element.disabled
+ : element.getAttribute('aria-disabled') === 'true' ||
+ element.hasAttribute('data-disabled')
+
+ if (element instanceof HTMLElement) element.focus()
+
+ return {
+ disabled,
+ focused: document.activeElement === element
+ }
+ })
+ )
+ expect(controlStates.every(({ disabled }) => disabled)).toBe(true)
+ expect(controlStates.every(({ focused }) => !focused)).toBe(true)
+
+ for (let index = 0; index < interactiveCount; index++) {
+ await expect(interactive.nth(index)).toBeHidden()
+ }
+ })
+
+ test('ignores pointer input on linked controls', async ({ comfyPage }) => {
+ const [targetNodeRef] =
+ await comfyPage.nodeOps.getNodeRefsByType(TARGET_NODE_TYPE)
+ if (!targetNodeRef) throw new Error('Target DevTools node was not loaded')
+
+ const targetNode = comfyPage.vueNodes
+ .getNodeByTitle(TARGET_NODE_TITLE)
+ .first()
+ await expect(targetNode).toBeVisible()
+
+ for (const text of [
+ 'STALE SELECT VALUE',
+ 'STALE ON',
+ 'STALE OFF',
+ '#22c55d'
+ ]) {
+ const staleValue = targetNode.getByText(text, { exact: true })
+ await expect(staleValue).toBeAttached()
+ await expect(staleValue).toBeHidden()
+ }
+
+ const widgetRefs = await Promise.all(
+ WIDGET_NAMES.map((name) => targetNodeRef.getWidgetByName(name))
+ )
+ const valuesBefore = await Promise.all(
+ widgetRefs.map((widget) => widget.getValue())
+ )
+
+ await targetNode
+ .getByRole('img', { name: 'switch: Linked input' })
+ .click()
+
+ await targetNode
+ .getByRole('img', { name: 'select: Linked input' })
+ .click()
+
+ await targetNode
+ .getByRole('img', { name: 'textarea: Linked input' })
+ .click()
+
+ await comfyPage.nextFrame()
+ await expect
+ .poll(() => Promise.all(widgetRefs.map((widget) => widget.getValue())))
+ .toStrictEqual(valuesBefore)
+ })
+ }
+)
diff --git a/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts-snapshots/linked-standard-widgets-chromium-linux.png b/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts-snapshots/linked-standard-widgets-chromium-linux.png
new file mode 100644
index 00000000000..3489e0af2f6
Binary files /dev/null and b/browser_tests/tests/vueNodes/widgets/linked/linkedStandardWidgets.spec.ts-snapshots/linked-standard-widgets-chromium-linux.png differ
diff --git a/browser_tests/tests/vueNodes/widgets/text/lockedWidgetHoverColor.spec.ts-snapshots/locked-widget-hover-color-chromium-linux.png b/browser_tests/tests/vueNodes/widgets/text/lockedWidgetHoverColor.spec.ts-snapshots/locked-widget-hover-color-chromium-linux.png
index 2eb6df89275..f460a7567ab 100644
Binary files a/browser_tests/tests/vueNodes/widgets/text/lockedWidgetHoverColor.spec.ts-snapshots/locked-widget-hover-color-chromium-linux.png and b/browser_tests/tests/vueNodes/widgets/text/lockedWidgetHoverColor.spec.ts-snapshots/locked-widget-hover-color-chromium-linux.png differ
diff --git a/browser_tests/tests/vueNodes/widgets/text/multilineStringWidget.spec.ts b/browser_tests/tests/vueNodes/widgets/text/multilineStringWidget.spec.ts
index 61b9c9131e9..578313c5b1f 100644
--- a/browser_tests/tests/vueNodes/widgets/text/multilineStringWidget.spec.ts
+++ b/browser_tests/tests/vueNodes/widgets/text/multilineStringWidget.spec.ts
@@ -3,6 +3,7 @@ import {
comfyPageFixture as test
} from '@e2e/fixtures/ComfyPage'
import type { ComfyPage } from '@e2e/fixtures/ComfyPage'
+import { TestIds } from '@e2e/fixtures/selectors'
test.describe('Vue Multiline String Widget', { tag: '@vue-nodes' }, () => {
test.afterEach(async ({ comfyPage }) => {
@@ -46,6 +47,56 @@ test.describe('Vue Multiline String Widget', { tag: '@vue-nodes' }, () => {
await expect(textarea).toHaveValue('Keep me around')
})
+ test('hides a linked core prompt without changing node geometry', async ({
+ comfyPage
+ }) => {
+ await comfyPage.workflow.loadWorkflow('widgets/linked_multiline_string')
+
+ const clipNode = getFirstClipNode(comfyPage)
+ const placeholder = clipNode.getByTestId(TestIds.widgets.linkedPlaceholder)
+ const linkedContent = clipNode.getByTestId(TestIds.widgets.linkedContent)
+ const hiddenTextarea = clipNode.locator('textarea')
+ const nodeBounds = await clipNode.boundingBox()
+
+ await expect(placeholder).toHaveAttribute(
+ 'data-linked-display',
+ 'expanding'
+ )
+ await expect(placeholder).toHaveAccessibleName('text: Linked input')
+ await expect(linkedContent).toHaveAttribute('inert', '')
+ await expect(linkedContent).toHaveAttribute('aria-hidden', 'true')
+ await expect(hiddenTextarea).toBeHidden()
+ await expect(hiddenTextarea).toBeDisabled()
+ await expect(clipNode.getByRole('textbox', { name: 'text' })).toHaveCount(0)
+ await expect(hiddenTextarea).toHaveValue('stale local prompt')
+
+ await hiddenTextarea.evaluate((element) => element.focus())
+ await expect
+ .poll(() =>
+ hiddenTextarea.evaluate((element) => document.activeElement === element)
+ )
+ .toBe(false)
+
+ const [clipNodeRef] =
+ await comfyPage.nodeOps.getNodeRefsByType('CLIPTextEncode')
+ if (!clipNodeRef || !nodeBounds) {
+ throw new Error('Linked CLIPTextEncode node did not render')
+ }
+ const textInput = await clipNodeRef.getInput(1)
+ await textInput.removeLinks()
+ await comfyPage.nextFrame()
+
+ await expect(placeholder).toHaveCount(0)
+ const restoredTextarea = getFirstMultilineStringWidget(comfyPage)
+ await expect(restoredTextarea).toBeVisible()
+ await expect(restoredTextarea).toHaveValue('stale local prompt')
+ await restoredTextarea.fill('restored local prompt')
+ await expect(restoredTextarea).toHaveValue('restored local prompt')
+ await expect
+ .poll(async () => (await clipNode.boundingBox())?.height)
+ .toBeCloseTo(nodeBounds.height, 0)
+ })
+
test('should use native context menu when focused', async ({ comfyPage }) => {
const textarea = getFirstMultilineStringWidget(comfyPage)
const vueContextMenu = comfyPage.page.locator('.p-contextmenu')
diff --git a/src/components/rightSidePanel/parameters/WidgetItem.test.ts b/src/components/rightSidePanel/parameters/WidgetItem.test.ts
index 05fc2e07c13..34bac70f690 100644
--- a/src/components/rightSidePanel/parameters/WidgetItem.test.ts
+++ b/src/components/rightSidePanel/parameters/WidgetItem.test.ts
@@ -1,32 +1,63 @@
-import { render } from '@testing-library/vue'
import { fromAny } from '@total-typescript/shoehorn'
+import userEvent from '@testing-library/user-event'
+import { render, screen } from '@testing-library/vue'
import { nextTick } from 'vue'
-import { describe, expect, it, vi } from 'vitest'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
import { createI18n } from 'vue-i18n'
import type { INodeInputSlot } from '@/lib/litegraph/src/interfaces'
import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
import type { IBaseWidget } from '@/lib/litegraph/src/types/widgets'
+import type * as WidgetRegistry from '@/renderer/extensions/vueNodes/widgets/registry/widgetRegistry'
import { useLinkStore } from '@/stores/linkStore'
import { useWidgetValueStore } from '@/stores/widgetValueStore'
import { graphScopeOf } from '@/types/graphScopeId'
-import { widgetId } from '@/types/widgetId'
-import WidgetItem from './WidgetItem.vue'
import { toLinkId } from '@/types/linkId'
import { toNodeId } from '@/types/nodeId'
+import { widgetId } from '@/types/widgetId'
+
+import WidgetItem from './WidgetItem.vue'
-const { mockGetInputSpecForWidget, StubWidgetComponent } = vi.hoisted(() => ({
+const {
+ mockFromLGraphNode,
+ mockGetInputSpecForWidget,
+ mockIsAssetAPIEnabled,
+ mockShouldUseAssetBrowser,
+ StubWidgetComponent
+} = vi.hoisted(() => ({
+ mockFromLGraphNode: vi.fn<() => { isCoreNode: boolean; name: string } | null>(
+ () => null
+ ),
mockGetInputSpecForWidget: vi.fn(),
+ mockIsAssetAPIEnabled: vi.fn(() => false),
+ mockShouldUseAssetBrowser: vi.fn(() => false),
StubWidgetComponent: {
name: 'StubWidget',
props: ['widget', 'modelValue', 'nodeId', 'nodeType'],
template:
- '
'
+ ''
+ }
+}))
+
+vi.mock('@/platform/assets/services/assetService', () => ({
+ assetService: {
+ isAssetAPIEnabled: mockIsAssetAPIEnabled,
+ shouldUseAssetBrowser: mockShouldUseAssetBrowser
+ }
+}))
+
+vi.mock('primevue/inputtext', () => ({
+ default: {
+ props: ['disabled', 'modelValue', 'readonly'],
+ emits: ['update:modelValue'],
+ template:
+ ''
}
}))
vi.mock('@/stores/nodeDefStore', () => ({
useNodeDefStore: () => ({
+ fromLGraphNode: mockFromLGraphNode,
getInputSpecForWidget: mockGetInputSpecForWidget
})
}))
@@ -46,10 +77,17 @@ vi.mock('@/stores/workspace/favoritedWidgetsStore', () => ({
vi.mock(
'@/renderer/extensions/vueNodes/widgets/registry/widgetRegistry',
- () => ({
- getComponent: () => StubWidgetComponent,
- shouldExpand: () => false
- })
+ async (importOriginal) => {
+ const original = await importOriginal()
+ const { default: WidgetInputText } =
+ await import('@/renderer/extensions/vueNodes/widgets/components/WidgetInputText.vue')
+ return {
+ ...original,
+ getComponent: (type: string) =>
+ type === 'text' ? WidgetInputText : StubWidgetComponent,
+ shouldExpand: () => false
+ }
+ }
)
vi.mock(
@@ -71,7 +109,9 @@ const i18n = createI18n({
}
})
-function createMockNode(overrides: Partial = {}): LGraphNode {
+function createMockNode(
+ overrides: Partial> = {}
+): LGraphNode {
return fromAny({
id: 1,
type: 'TestNode',
@@ -98,6 +138,22 @@ function renderWidgetItem(
widget: IBaseWidget,
node: LGraphNode = createMockNode()
) {
+ if (node.graph) {
+ const scope = graphScopeOf(node.graph)
+ node.inputs?.forEach((input, targetSlot) => {
+ if (input.link == null) return
+ useLinkStore().registerLink(scope, {
+ id: input.link,
+ graphId: scope.owningGraphId,
+ originNodeId: toNodeId(2),
+ originSlot: 0,
+ targetNodeId: node.id,
+ targetSlot,
+ type: String(input.type)
+ })
+ })
+ }
+
return render(WidgetItem, {
props: { widget, node },
global: {
@@ -116,6 +172,7 @@ function getStubWidget(container: Element) {
if (!el) throw new Error('stub-widget not found')
return {
options: JSON.parse(el.getAttribute('data-widget-options') ?? 'null'),
+ linkedDisplay: el.getAttribute('data-linked-display'),
type: el.getAttribute('data-widget-type'),
name: el.getAttribute('data-widget-name'),
value: el.getAttribute('data-widget-value')
@@ -123,6 +180,13 @@ function getStubWidget(container: Element) {
}
describe('WidgetItem', () => {
+ beforeEach(() => {
+ mockIsAssetAPIEnabled.mockReturnValue(false)
+ mockShouldUseAssetBrowser.mockReturnValue(false)
+ mockFromLGraphNode.mockReturnValue(null)
+ mockGetInputSpecForWidget.mockReset()
+ })
+
describe('widget state rendering', () => {
it('passes options from a regular widget to the widget component', () => {
const widget = createMockWidget({
@@ -162,6 +226,9 @@ describe('WidgetItem', () => {
value: 'model_a.safetensors',
options: { values: ['model_a.safetensors'] }
})
+ Object.defineProperty(widget, 'type', {
+ get: () => useWidgetValueStore().getWidget(id)?.type ?? 'string'
+ })
const { container } = renderWidgetItem(widget)
const stub = getStubWidget(container)
@@ -199,6 +266,169 @@ describe('WidgetItem', () => {
expect(stub.value).toBe('model_a.safetensors')
})
+ it('restores a linked text control in Parameters after disconnect', async () => {
+ const widget = createMockWidget({
+ name: 'prompt',
+ type: 'text',
+ value: 'STALE PARAMETER TEXT'
+ })
+ const promptInput = {
+ name: 'prompt',
+ type: 'STRING',
+ link: toLinkId(1),
+ boundingRect: [0, 0, 0, 0],
+ widget: { name: 'prompt' }
+ }
+ const node = createMockNode({
+ inputs: [promptInput]
+ })
+
+ const view = renderWidgetItem(widget, node)
+
+ const content = screen.getByTestId('linked-widget-content')
+ const input = screen.getByRole('textbox', { hidden: true })
+ expect(content).toHaveAttribute('inert')
+ expect(content).toHaveAttribute('aria-hidden', 'true')
+ expect(input).toBeDisabled()
+ expect(screen.queryByRole('textbox')).toBeNull()
+ expect(
+ screen.getByRole('img', { name: 'prompt: Linked input' })
+ ).toBeVisible()
+
+ const scope = graphScopeOf(node.graph!)
+ const link = useLinkStore().getInputSlotLink(scope, node.id, 0)
+ expect(link).toBeDefined()
+ expect(useLinkStore().deleteLink(scope, link!)).toBe(true)
+ await view.rerender({
+ widget,
+ node: createMockNode({
+ inputs: [{ ...promptInput, link: null }]
+ })
+ })
+
+ expect(screen.queryByRole('img')).toBeNull()
+ const restoredInput = screen.getByRole('textbox', { name: 'prompt' })
+ expect(restoredInput).toBeVisible()
+ expect(restoredInput).toBeEnabled()
+ expect(restoredInput).toHaveValue('STALE PARAMETER TEXT')
+
+ const user = userEvent.setup()
+ await user.clear(restoredInput)
+ await user.type(restoredInput, 'restored parameter text')
+
+ expect(view.emitted()['update:widgetValue']).toContainEqual([
+ 'restored parameter text'
+ ])
+ })
+
+ it('uses the bounded linked resolver for ordinary combos', () => {
+ const widget = createMockWidget({ name: 'option', type: 'COMBO' })
+ const node = createMockNode({
+ inputs: [
+ {
+ name: 'option',
+ type: 'COMBO',
+ link: toLinkId(1),
+ boundingRect: [0, 0, 0, 0],
+ widget: { name: 'option' }
+ }
+ ]
+ })
+ const { container } = renderWidgetItem(widget, node)
+
+ expect(getStubWidget(container).linkedDisplay).toBe('control')
+ })
+
+ it('keeps upload combos on the disabled fallback', () => {
+ mockGetInputSpecForWidget.mockReturnValue({
+ type: 'COMBO',
+ name: 'option',
+ image_upload: true
+ })
+ const widget = createMockWidget({ name: 'option', type: 'COMBO' })
+ const node = createMockNode({
+ inputs: [
+ {
+ name: 'option',
+ type: 'COMBO',
+ link: toLinkId(1),
+ boundingRect: [0, 0, 0, 0],
+ widget: { name: 'option' }
+ }
+ ]
+ })
+ const { container } = renderWidgetItem(widget, node)
+
+ expect(getStubWidget(container).linkedDisplay).toBeNull()
+ expect(getStubWidget(container).options.disabled).toBe(true)
+ })
+
+ it.for(['LoadImage', 'LoadImageMask', 'LoadImageOutput'])(
+ 'uses the linked presentation for the exact core %s selector',
+ (nodeType) => {
+ mockGetInputSpecForWidget.mockReturnValue({
+ type: 'COMBO',
+ name: 'image',
+ image_upload: true
+ })
+ mockFromLGraphNode.mockReturnValue({
+ name: nodeType,
+ isCoreNode: true
+ })
+ const widget = createMockWidget({ name: 'image', type: 'asset' })
+ const node = createMockNode({
+ type: nodeType,
+ inputs: [
+ {
+ name: 'image',
+ type: 'COMBO',
+ link: toLinkId(1),
+ boundingRect: [0, 0, 0, 0],
+ widget: { name: 'image' }
+ }
+ ]
+ })
+
+ const { container } = renderWidgetItem(widget, node)
+ const stub = getStubWidget(container)
+
+ expect(stub.linkedDisplay).toBe('control')
+ expect(stub.options.disabled).toBe(true)
+ }
+ )
+
+ it('does not add linked presentation to a special widget', () => {
+ const id = widgetId('test-graph-id', toNodeId(1), 'gradient')
+ const widget = createMockWidget({
+ widgetId: id,
+ name: 'gradient',
+ type: 'gradientslider'
+ })
+ useWidgetValueStore().registerWidget(id, {
+ type: 'number',
+ value: 0.5,
+ options: {}
+ })
+ const node = createMockNode({
+ inputs: [
+ {
+ name: 'gradient',
+ type: 'FLOAT',
+ link: toLinkId(1),
+ boundingRect: [0, 0, 0, 0],
+ widget: { name: 'gradient' }
+ }
+ ]
+ })
+ const { container } = renderWidgetItem(widget, node)
+ const stub = getStubWidget(container)
+
+ expect(stub.linkedDisplay).toBeNull()
+ expect(stub.type).toBe('gradientslider')
+ expect(stub.options.disabled).toBe(true)
+ expect(screen.queryByTestId('linked-widget-placeholder')).toBeNull()
+ })
+
it('passes null from widget state to the widget component', () => {
const id = widgetId('test-graph-id', toNodeId(1), 'ckpt_name')
const widget = createMockWidget({ widgetId: id, value: 'source value' })
diff --git a/src/components/rightSidePanel/parameters/WidgetItem.vue b/src/components/rightSidePanel/parameters/WidgetItem.vue
index f2dce67e2a4..0004357a59f 100644
--- a/src/components/rightSidePanel/parameters/WidgetItem.vue
+++ b/src/components/rightSidePanel/parameters/WidgetItem.vue
@@ -6,12 +6,14 @@ import EditableText from '@/components/common/EditableText.vue'
import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
import type { SubgraphNode } from '@/lib/litegraph/src/subgraph/SubgraphNode'
import type { IBaseWidget } from '@/lib/litegraph/src/types/widgets'
+import { assetService } from '@/platform/assets/services/assetService'
import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
import WidgetLegacy from '@/renderer/extensions/vueNodes/widgets/components/WidgetLegacy.vue'
import {
getComponent,
shouldExpand
} from '@/renderer/extensions/vueNodes/widgets/registry/widgetRegistry'
+import { resolveLinkedWidgetDisplay } from '@/renderer/extensions/vueNodes/widgets/utils/linkedWidgetDisplay'
import { useLinkStore } from '@/stores/linkStore'
import { graphScopeOf } from '@/types/graphScopeId'
import { useNodeDefStore } from '@/stores/nodeDefStore'
@@ -88,9 +90,21 @@ const simplifiedWidget = computed((): SimplifiedWidget => {
? widgetValueStore.getWidget(widgetId(graphId, bareNodeId, widget.name))
: undefined
const widgetName = widgetState?.name ?? widget.name
- const widgetType = widgetState?.type ?? widget.type
+ const widgetType = widget.type
const baseOptions = widgetState?.options ?? widget.options
+ const spec = nodeDefStore.getInputSpecForWidget(node, widgetName)
+ const nodeDef = nodeDefStore.fromLGraphNode(node)
+ const linkedDisplay = resolveLinkedWidgetDisplay(
+ { name: widgetName, type: widgetType, spec },
+ baseOptions,
+ {
+ assetApiEnabled: assetService.isAssetAPIEnabled(),
+ coreNodeType: nodeDef?.isCoreNode ? nodeDef.name : undefined,
+ linked: isLinked.value,
+ useAssetBrowser: assetService.shouldUseAssetBrowser(node.type, widgetName)
+ }
+ )
const disabled = isLinked.value || !!widget.disabled || undefined
return {
name: widgetName,
@@ -99,8 +113,9 @@ const simplifiedWidget = computed((): SimplifiedWidget => {
? widgetState.value
: widget.value) as SimplifiedWidgetValue,
label: widgetState?.label ?? widget.label,
+ linkedDisplay,
options: { ...baseOptions, disabled },
- spec: nodeDefStore.getInputSpecForWidget(node, widgetName),
+ spec,
controlWidget: getControlWidget(widget)
}
})
diff --git a/src/components/ui/color-picker/ColorPicker.test.ts b/src/components/ui/color-picker/ColorPicker.test.ts
new file mode 100644
index 00000000000..bec44b9c9e3
--- /dev/null
+++ b/src/components/ui/color-picker/ColorPicker.test.ts
@@ -0,0 +1,77 @@
+import { render, screen, waitFor } from '@testing-library/vue'
+import userEvent from '@testing-library/user-event'
+import { describe, expect, it } from 'vitest'
+import { createI18n } from 'vue-i18n'
+
+import ColorPicker from './ColorPicker.vue'
+
+const i18n = createI18n({
+ legacy: false,
+ locale: 'en',
+ messages: {
+ en: {
+ color: {
+ alpha: 'Alpha',
+ hex: 'Hex',
+ hue: 'Hue',
+ rgba: 'RGBA',
+ saturationBrightness: 'Color saturation and brightness'
+ }
+ }
+ }
+})
+
+describe('ColorPicker', () => {
+ it('closes an open popover when disabled', async () => {
+ const user = userEvent.setup()
+ const { rerender } = render(ColorPicker, {
+ global: { plugins: [i18n] },
+ props: { modelValue: '#112233' }
+ })
+ const trigger = screen.getByRole('button')
+
+ await user.click(trigger)
+ expect(
+ await screen.findByRole('textbox', { name: 'Hex' })
+ ).toBeInTheDocument()
+
+ await rerender({ disabled: true, modelValue: '#112233' })
+
+ await waitFor(() => {
+ expect(
+ screen.queryByRole('textbox', { name: 'Hex' })
+ ).not.toBeInTheDocument()
+ })
+ expect(trigger).toBeDisabled()
+ })
+
+ it('does not reopen from a custom trigger when disabled', async () => {
+ const user = userEvent.setup()
+ const { rerender } = render(ColorPicker, {
+ global: { plugins: [i18n] },
+ props: { modelValue: '#112233' },
+ slots: {
+ trigger: ''
+ }
+ })
+ const trigger = screen.getByRole('button', { name: 'Custom trigger' })
+
+ await user.click(trigger)
+ expect(
+ await screen.findByRole('textbox', { name: 'Hex' })
+ ).toBeInTheDocument()
+
+ await rerender({ disabled: true, modelValue: '#112233' })
+ await waitFor(() => {
+ expect(
+ screen.queryByRole('textbox', { name: 'Hex' })
+ ).not.toBeInTheDocument()
+ })
+
+ await user.click(trigger)
+
+ expect(
+ screen.queryByRole('textbox', { name: 'Hex' })
+ ).not.toBeInTheDocument()
+ })
+})
diff --git a/src/components/ui/color-picker/ColorPicker.vue b/src/components/ui/color-picker/ColorPicker.vue
index 8215e4e7a3f..057c3908785 100644
--- a/src/components/ui/color-picker/ColorPicker.vue
+++ b/src/components/ui/color-picker/ColorPicker.vue
@@ -14,7 +14,7 @@ import { cn } from '@comfyorg/tailwind-utils'
import ColorPickerPanel from './ColorPickerPanel.vue'
-const { alpha = true } = defineProps<{
+const { alpha = true, disabled = false } = defineProps<{
class?: string
disabled?: boolean
alpha?: boolean
@@ -69,15 +69,26 @@ const displayHex = computed(() => rgbToHex(baseRgb.value).toLowerCase())
const isOpen = ref(false)
const contentStyle = useModalLiftedZIndex(isOpen)
+
+function updateOpen(open: boolean) {
+ isOpen.value = open && !disabled
+}
+
+watch(
+ () => disabled,
+ (isDisabled) => {
+ if (isDisabled) isOpen.value = false
+ }
+)
-
+
diff --git a/src/renderer/extensions/vueNodes/composables/processedWidgetRenderModel.ts b/src/renderer/extensions/vueNodes/composables/processedWidgetRenderModel.ts
index c09570c137e..f4e16b12737 100644
--- a/src/renderer/extensions/vueNodes/composables/processedWidgetRenderModel.ts
+++ b/src/renderer/extensions/vueNodes/composables/processedWidgetRenderModel.ts
@@ -8,6 +8,7 @@ import type {
IBaseWidget,
IWidgetOptions
} from '@/lib/litegraph/src/types/widgets'
+import { assetService } from '@/platform/assets/services/assetService'
import { useMissingMediaStore } from '@/platform/missingMedia/missingMediaStore'
import { useMissingModelStore } from '@/platform/missingModel/missingModelStore'
import type {
@@ -20,6 +21,7 @@ import {
getComponent,
shouldRenderAsVue
} from '@/renderer/extensions/vueNodes/widgets/registry/widgetRegistry'
+import { resolveLinkedWidgetDisplay } from '@/renderer/extensions/vueNodes/widgets/utils/linkedWidgetDisplay'
import { app } from '@/scripts/app'
import { useLinkStore } from '@/stores/linkStore'
import { graphScopeOf } from '@/types/graphScopeId'
@@ -334,6 +336,7 @@ function widgetNodeLocatorId(
interface WidgetProcessingContext {
nodeData: NodeState
+ coreNodeType?: string
showAdvanced: boolean
rootGraph: LGraph | null
/** Root graph id, known even before `app.isGraphReady`. */
@@ -378,6 +381,22 @@ function processWidget(
const widgetOptions = isDisabled ? { ...options, disabled: true } : options
const value = normalizeWidgetValue(widgetState.value)
const bareWidgetId = stripGraphPrefix(widgetState.nodeId)
+ const spec = live
+ ? ctx.nodeDefStore.getInputSpecForWidget(live.node, live.widget.name)
+ : undefined
+ const linkedDisplay = resolveLinkedWidgetDisplay(
+ { name: widgetState.name, type, spec },
+ options,
+ {
+ assetApiEnabled: assetService.isAssetAPIEnabled(),
+ coreNodeType: ctx.coreNodeType,
+ linked: Boolean(slotInfo?.linked),
+ useAssetBrowser: assetService.shouldUseAssetBrowser(
+ ctx.nodeData.type,
+ widgetState.name
+ )
+ }
+ )
const linkedUpstream: LinkedUpstreamInfo | undefined =
slotInfo?.linked && slotInfo.originNodeId
? { nodeId: slotInfo.originNodeId, outputName: slotInfo.originOutputName }
@@ -404,22 +423,23 @@ function processWidget(
callback: updateHandler,
controlWidget,
label: widgetState.label,
+ linkedDisplay,
linkedUpstream,
nodeLocatorId: widgetNodeLocatorId(ctx, bareWidgetId, sourceExecutionId),
options: widgetOptions,
- spec: live
- ? ctx.nodeDefStore.getInputSpecForWidget(live.node, live.widget.name)
- : undefined
+ spec
}
const valueTooltip =
isTooltipValueType(type) && String(value).length > 10
? String(value)
: undefined
- const tooltipConfig = ctx.ui.getTooltipConfig(
- { name: widgetState.name, tooltip: renderState?.tooltip },
- valueTooltip
- )
+ const tooltipConfig = linkedDisplay
+ ? { disabled: true }
+ : ctx.ui.getTooltipConfig(
+ { name: widgetState.name, tooltip: renderState?.tooltip },
+ valueTooltip
+ )
const handleContextMenu = (e: PointerEvent) => {
e.preventDefault()
e.stopPropagation()
@@ -497,8 +517,12 @@ export function computeProcessedWidgets({
graphRef,
nodeData.id
)
+ const nodeDef = hostNode
+ ? nodeDefStore.fromLGraphNode(hostNode)
+ : nodeDefStore.nodeDefsByName[nodeData.type]
const ctx: WidgetProcessingContext = {
nodeData,
+ coreNodeType: nodeDef?.isCoreNode ? nodeDef.name : undefined,
showAdvanced,
rootGraph,
rootGraphId: graphId,
diff --git a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts
index 00787a78b51..e127b30988f 100644
--- a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts
+++ b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts
@@ -1,4 +1,5 @@
import type { TooltipOptions } from 'primevue'
+import { fromAny } from '@total-typescript/shoehorn'
import { createTestingPinia } from '@pinia/testing'
import { setActivePinia } from 'pinia'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
@@ -17,6 +18,7 @@ import WidgetDOM from '@/renderer/extensions/vueNodes/widgets/components/WidgetD
import WidgetLegacy from '@/renderer/extensions/vueNodes/widgets/components/WidgetLegacy.vue'
import { useExecutionErrorStore } from '@/stores/executionErrorStore'
import { useLinkStore } from '@/stores/linkStore'
+import { useNodeDefStore } from '@/stores/nodeDefStore'
import { useWidgetValueStore } from '@/stores/widgetValueStore'
import type { WidgetRenderState } from '@/stores/widgetValueStore'
import {
@@ -25,12 +27,26 @@ import {
} from '@/types/nodeIdentification'
import { toOwningGraphId, toRootGraphId } from '@/types/graphScopeId'
import { toLinkId } from '@/types/linkId'
+import type { LinkId } from '@/types/linkId'
import { toNodeId } from '@/types/nodeId'
import type { NodeId } from '@/types/nodeId'
import { widgetId } from '@/types/widgetId'
import type { WidgetId } from '@/types/widgetId'
const GRAPH_ID = 'graph-test'
+const NODE_ID = toNodeId(1)
+
+const { isAssetAPIEnabled, shouldUseAssetBrowser, showNodeOptions } =
+ vi.hoisted(() => ({
+ isAssetAPIEnabled: vi.fn(() => false),
+ shouldUseAssetBrowser: vi.fn(() => false),
+ showNodeOptions: vi.fn()
+ }))
+
+vi.mock('@/composables/graph/useMoreOptionsMenu', () => ({ showNodeOptions }))
+vi.mock('@/platform/assets/services/assetService', () => ({
+ assetService: { isAssetAPIEnabled, shouldUseAssetBrowser }
+}))
vi.mock('@/renderer/core/canvas/canvasStore', () => ({
useCanvasStore: () => ({
@@ -73,10 +89,11 @@ function createNode(
function createGraphWithNode(
widgets: IBaseWidget[],
id: NodeId = toNodeId(1),
- type = 'TestNode'
+ type = 'TestNode',
+ graphId = GRAPH_ID
): { graph: LGraph; node: LGraphNode } {
const graph = new LGraph()
- graph.id = GRAPH_ID
+ graph.id = graphId
const node = createNode(widgets, id, type)
graph.add(node)
return { graph, node }
@@ -115,7 +132,8 @@ function processWidgets({
nodeType = 'TestNode',
showAdvanced = false,
subgraphId,
- rootGraph = null
+ rootGraph = null,
+ ui = noopUi
}: {
widgetIds: readonly WidgetId[]
nodeId?: NodeId
@@ -123,11 +141,13 @@ function processWidgets({
showAdvanced?: boolean
subgraphId?: string | null
rootGraph?: LGraph | null
+ ui?: typeof noopUi
}) {
+ const graphId = rootGraph?.id ?? GRAPH_ID
return computeProcessedWidgets({
nodeData: {
id: nodeId,
- graphId: subgraphId ?? GRAPH_ID,
+ graphId: subgraphId ?? graphId,
type: nodeType,
title: 'Test',
mode: 0,
@@ -137,14 +157,82 @@ function processWidgets({
properties: {}
},
widgetIds,
- graphId: GRAPH_ID,
+ graphId,
showAdvanced,
isGraphReady: rootGraph !== null,
rootGraph,
- ui: noopUi
+ ui
})
}
+function createLinkedWidgetFixture({
+ name = 'prompt',
+ type = 'text',
+ nodeType = 'TestNode',
+ value = 'local value',
+ options = {},
+ renderState = {},
+ linkId = toLinkId(1),
+ nodeId = NODE_ID,
+ graphId = GRAPH_ID
+}: {
+ name?: string
+ type?: string
+ nodeType?: string
+ value?: IBaseWidget['value']
+ options?: IBaseWidget['options']
+ renderState?: WidgetRenderState
+ linkId?: LinkId
+ nodeId?: NodeId
+ graphId?: string
+} = {}) {
+ const id = widgetId(graphId, nodeId, name)
+ const widget = createMockWidget({ name, type, value, widgetId: id })
+ const { graph, node } = createGraphWithNode(
+ [widget],
+ nodeId,
+ nodeType,
+ graphId
+ )
+ const originNode = createNode([], toNodeId(2), 'OriginNode')
+ originNode.outputs = [
+ {
+ name: 'value',
+ type: 'STRING',
+ links: [linkId],
+ boundingRect: [0, 0, 0, 0]
+ }
+ ]
+ graph.add(originNode)
+ node.inputs = [
+ {
+ name,
+ type: 'STRING',
+ link: linkId,
+ boundingRect: [0, 0, 0, 0],
+ widget: { name }
+ }
+ ]
+ registerWidgetState(id, { type, value, options }, renderState)
+
+ const scope = {
+ rootGraphId: toRootGraphId(graphId),
+ owningGraphId: toOwningGraphId(graphId)
+ }
+ const topology = {
+ id: linkId,
+ graphId: scope.owningGraphId,
+ originNodeId: originNode.id,
+ originSlot: 0,
+ targetNodeId: nodeId,
+ targetSlot: 0,
+ type: 'STRING'
+ }
+ useLinkStore().registerLink(scope, topology)
+
+ return { graph, id, nodeId, scope, topology, widget }
+}
+
describe('widget slot ownership', () => {
beforeEach(() => {
setActivePinia(createTestingPinia({ stubActions: false }))
@@ -572,6 +660,248 @@ describe('computeProcessedWidgets', () => {
})
})
+describe('computeProcessedWidgets linked presentation', () => {
+ beforeEach(() => {
+ setActivePinia(createTestingPinia({ stubActions: false }))
+ isAssetAPIEnabled.mockReturnValue(false)
+ shouldUseAssetBrowser.mockReturnValue(false)
+ showNodeOptions.mockClear()
+ })
+
+ it('hides a linked standard value and disables its mounted control', () => {
+ const { graph, id } = createLinkedWidgetFixture({
+ type: 'text',
+ value: 'stale local prompt'
+ })
+
+ const [linked] = processWidgets({
+ widgetIds: [id],
+ rootGraph: graph
+ })
+
+ expect(linked.simplified.linkedDisplay).toBe('control')
+ expect(linked.simplified.value).toBe('stale local prompt')
+ expect(linked.simplified.options?.disabled).toBe(true)
+ expect(linked.tooltipConfig.disabled).toBe(true)
+ expect(linked.simplified.linkedUpstream).toEqual({
+ nodeId: toNodeId(2),
+ outputName: 'value'
+ })
+ })
+
+ it('uses the live widget type for linked display policy', () => {
+ const { graph, id, widget } = createLinkedWidgetFixture({
+ type: 'number'
+ })
+ widget.type = 'gradientslider'
+
+ const [linked] = processWidgets({
+ widgetIds: [id],
+ rootGraph: graph
+ })
+
+ expect(linked.simplified.type).toBe('gradientslider')
+ expect(linked.simplified.linkedDisplay).toBeUndefined()
+ })
+
+ it('restores the standard widget state after disconnect', () => {
+ const { graph, id, scope, topology } = createLinkedWidgetFixture({
+ type: 'text',
+ value: 'local prompt'
+ })
+
+ expect(
+ processWidgets({ widgetIds: [id], rootGraph: graph })[0].simplified
+ .linkedDisplay
+ ).toBe('control')
+
+ useLinkStore().deleteLink(scope, topology)
+ const [unlinked] = processWidgets({ widgetIds: [id], rootGraph: graph })
+
+ expect(unlinked.simplified.linkedDisplay).toBeUndefined()
+ expect(unlinked.simplified.value).toBe('local prompt')
+ expect(unlinked.simplified.options?.disabled).toBeUndefined()
+ expect(unlinked.simplified.linkedUpstream).toBeUndefined()
+ expect(unlinked.tooltipConfig.disabled).toBeUndefined()
+ })
+
+ it('distinguishes unlabeled switches from labeled toggle groups', () => {
+ const switchFixture = createLinkedWidgetFixture({
+ name: 'enabled',
+ type: 'boolean'
+ })
+ const [linkedSwitch] = processWidgets({
+ widgetIds: [switchFixture.id],
+ rootGraph: switchFixture.graph,
+ nodeId: switchFixture.nodeId
+ })
+
+ const toggleFixture = createLinkedWidgetFixture({
+ name: 'mode',
+ type: 'boolean',
+ value: false,
+ options: { off: 'Disabled', on: 'Enabled' },
+ linkId: toLinkId(2),
+ nodeId: toNodeId(3),
+ graphId: 'graph-toggle'
+ })
+ const [linkedToggle] = processWidgets({
+ widgetIds: [toggleFixture.id],
+ rootGraph: toggleFixture.graph,
+ nodeId: toggleFixture.nodeId
+ })
+
+ expect(linkedSwitch.simplified.linkedDisplay).toBe('switch')
+ expect(linkedToggle.simplified.linkedDisplay).toBe('control')
+ })
+
+ it.for([
+ ['String', false, WidgetLegacy],
+ ['CoMbO', true, WidgetDOM]
+ ] as const)(
+ 'keeps the unregistered mixed-case %s fallback visible',
+ ([type, isDOMWidget, component]) => {
+ const fixture = createLinkedWidgetFixture({
+ type,
+ renderState: { isDOMWidget }
+ })
+
+ const [processed] = processWidgets({
+ widgetIds: [fixture.id],
+ rootGraph: fixture.graph
+ })
+
+ expect(processed.simplified.linkedDisplay).toBeUndefined()
+ expect(processed.simplified.options?.disabled).toBe(true)
+ expect(processed.vueComponent).toBe(component)
+ }
+ )
+
+ it.for([
+ { name: 'asset alias', type: 'asset', spec: undefined },
+ {
+ name: 'upload-media COMBO',
+ type: 'COMBO',
+ spec: {
+ type: 'COMBO',
+ name: 'image',
+ image_upload: true
+ }
+ }
+ ] as const)('keeps the linked $name rendered', ({ type, spec }) => {
+ const fixture = createLinkedWidgetFixture({ name: 'image', type })
+ vi.spyOn(useNodeDefStore(), 'getInputSpecForWidget').mockReturnValue(spec)
+
+ const [processed] = processWidgets({
+ widgetIds: [fixture.id],
+ rootGraph: fixture.graph
+ })
+
+ expect(processed.simplified.linkedDisplay).toBeUndefined()
+ expect(processed.simplified.options?.disabled).toBe(true)
+ })
+
+ it.for(['LoadImage', 'LoadImageMask', 'LoadImageOutput'])(
+ 'hides and disables a linked core %s selector',
+ (nodeType) => {
+ const fixture = createLinkedWidgetFixture({
+ name: 'image',
+ type: 'asset',
+ nodeType
+ })
+ vi.spyOn(useNodeDefStore(), 'fromLGraphNode').mockReturnValue(
+ fromAny({ name: nodeType, isCoreNode: true })
+ )
+ vi.spyOn(useNodeDefStore(), 'getInputSpecForWidget').mockReturnValue({
+ type: 'COMBO',
+ name: 'image',
+ image_upload: true
+ })
+
+ const [processed] = processWidgets({
+ widgetIds: [fixture.id],
+ nodeType,
+ rootGraph: fixture.graph
+ })
+
+ expect(processed.simplified.linkedDisplay).toBe('control')
+ expect(processed.simplified.options?.disabled).toBe(true)
+ }
+ )
+
+ it('keeps an asset-browser combo rendered while hiding an ordinary combo', () => {
+ shouldUseAssetBrowser.mockReturnValue(true)
+ const fixture = createLinkedWidgetFixture({
+ name: 'ckpt_name',
+ type: 'combo'
+ })
+
+ expect(
+ processWidgets({
+ widgetIds: [fixture.id],
+ rootGraph: fixture.graph
+ })[0].simplified.linkedDisplay
+ ).toBeUndefined()
+
+ shouldUseAssetBrowser.mockReturnValue(false)
+ expect(
+ processWidgets({
+ widgetIds: [fixture.id],
+ rootGraph: fixture.graph
+ })[0].simplified.linkedDisplay
+ ).toBe('control')
+ })
+
+ it('keeps upstream metadata for a linked relay widget', () => {
+ const fixture = createLinkedWidgetFixture({ type: 'range' })
+ const [processed] = processWidgets({
+ widgetIds: [fixture.id],
+ rootGraph: fixture.graph
+ })
+
+ expect(processed.simplified.linkedDisplay).toBeUndefined()
+ expect(processed.simplified.options?.disabled).toBe(true)
+ expect(processed.simplified.linkedUpstream).toEqual({
+ nodeId: toNodeId(2),
+ outputName: 'value'
+ })
+ })
+
+ it('retains widget actions for a hidden linked widget', () => {
+ const handleNodeRightClick = vi.fn()
+ const event = fromAny({
+ preventDefault: vi.fn(),
+ stopPropagation: vi.fn()
+ })
+ const fixture = createLinkedWidgetFixture({ type: 'text' })
+
+ processWidgets({
+ widgetIds: [fixture.id],
+ rootGraph: fixture.graph,
+ ui: { ...noopUi, handleNodeRightClick }
+ })[0].handleContextMenu(event)
+
+ expect(handleNodeRightClick).toHaveBeenCalledWith(event, NODE_ID)
+ expect(showNodeOptions).toHaveBeenCalledWith(event, 'prompt')
+ })
+
+ it('retains widget actions when the widget is unlinked', () => {
+ const event = fromAny({
+ preventDefault: vi.fn(),
+ stopPropagation: vi.fn()
+ })
+ const id = widgetId(GRAPH_ID, NODE_ID, 'prompt')
+ registerWidgetState(id, { type: 'text' })
+
+ processWidgets({
+ widgetIds: [id],
+ ui: noopUi
+ })[0].handleContextMenu(event)
+
+ expect(showNodeOptions).toHaveBeenCalledWith(event, 'prompt')
+ })
+})
+
describe('createWidgetUpdateHandler (via computeProcessedWidgets)', () => {
const NODE_ID = toNodeId(1)
diff --git a/src/renderer/extensions/vueNodes/widgets/components/LinkedWidgetStatus.test.ts b/src/renderer/extensions/vueNodes/widgets/components/LinkedWidgetStatus.test.ts
new file mode 100644
index 00000000000..056e5946ab7
--- /dev/null
+++ b/src/renderer/extensions/vueNodes/widgets/components/LinkedWidgetStatus.test.ts
@@ -0,0 +1,72 @@
+import { render, screen } from '@testing-library/vue'
+import userEvent from '@testing-library/user-event'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { defineComponent, nextTick } from 'vue'
+
+import { i18n } from '@/i18n'
+
+import LinkedWidgetStatus from './LinkedWidgetStatus.vue'
+
+const originalLocale = i18n.global.locale.value
+const originalFrenchMessages = i18n.global.getLocaleMessage('fr')
+
+afterEach(() => {
+ i18n.global.locale.value = originalLocale
+ i18n.global.setLocaleMessage('fr', originalFrenchMessages)
+})
+
+describe('LinkedWidgetStatus', () => {
+ it('exposes the linked state as a named image', () => {
+ render(LinkedWidgetStatus, {
+ props: {
+ display: 'control',
+ widget: { name: 'prompt', label: 'Prompt' }
+ }
+ })
+
+ expect(
+ screen.getByRole('img', { name: 'Prompt: Linked input' })
+ ).toBeVisible()
+ })
+
+ it('allows pointer gestures to bubble to the canvas surface', async () => {
+ const onPointerdown = vi.fn()
+ const Harness = defineComponent({
+ components: { LinkedWidgetStatus },
+ setup: () => ({ onPointerdown }),
+ template: `
+
+
+
+ `
+ })
+ render(Harness)
+ const user = userEvent.setup()
+
+ await user.pointer({ keys: '[MouseLeft]', target: screen.getByRole('img') })
+
+ expect(onPointerdown).toHaveBeenCalledTimes(1)
+ })
+
+ it('updates its accessible name when the locale changes', async () => {
+ render(LinkedWidgetStatus, {
+ props: {
+ display: 'control',
+ widget: { name: 'prompt' }
+ }
+ })
+ i18n.global.mergeLocaleMessage('fr', {
+ widgets: { linkedInput: 'Entrée liée' }
+ })
+ i18n.global.locale.value = 'fr'
+
+ await nextTick()
+
+ expect(
+ screen.getByRole('img', { name: 'prompt: Entrée liée' })
+ ).toBeVisible()
+ })
+})
diff --git a/src/renderer/extensions/vueNodes/widgets/components/LinkedWidgetStatus.vue b/src/renderer/extensions/vueNodes/widgets/components/LinkedWidgetStatus.vue
new file mode 100644
index 00000000000..abae29536a0
--- /dev/null
+++ b/src/renderer/extensions/vueNodes/widgets/components/LinkedWidgetStatus.vue
@@ -0,0 +1,53 @@
+
+
+
+
+
+
+
diff --git a/src/renderer/extensions/vueNodes/widgets/components/ValueControlButton.vue b/src/renderer/extensions/vueNodes/widgets/components/ValueControlButton.vue
index 0abffea10d8..c4b371e46b3 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/ValueControlButton.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/ValueControlButton.vue
@@ -33,7 +33,7 @@ const textMap: Record = {
:aria-label="t('widgets.valueControl.' + mode)"
:class="
cn(
- 'flex shrink-0 cursor-pointer items-center justify-center border-none focus-visible:ring-2 focus-visible:ring-primary-background focus-visible:ring-offset-1 focus-visible:outline-none',
+ 'flex shrink-0 cursor-pointer items-center justify-center border-none focus-visible:ring-2 focus-visible:ring-primary-background focus-visible:ring-offset-1 focus-visible:outline-none disabled:cursor-default disabled:opacity-50',
variant === 'badge' ? 'h-4.5 w-8 rounded-full' : 'size-6 rounded-sm',
mode !== 'fixed'
? 'bg-primary-background/30 hover:bg-primary-background-hover/30'
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetColorPicker.test.ts b/src/renderer/extensions/vueNodes/widgets/components/WidgetColorPicker.test.ts
index ea438d7cadd..e5fc5b9a5d5 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetColorPicker.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetColorPicker.test.ts
@@ -19,12 +19,14 @@ const WidgetLayoutFieldStub = defineComponent({
const ColorPickerStub = defineComponent({
name: 'ColorPicker',
props: {
+ disabled: { type: Boolean, default: false },
modelValue: { type: String, default: '' }
},
emits: ['update:modelValue'],
template: ``
})
@@ -99,6 +101,13 @@ describe('WidgetColorPicker Value Binding', () => {
expect(screen.getByTestId('color-picker-input')).toBeInTheDocument()
})
+ it('disables the color picker from widget options', () => {
+ const widget = createColorWidget('#ff0000', { disabled: true })
+ renderComponent(widget, '#ff0000')
+
+ expect(screen.getByTestId('color-picker-input')).toBeDisabled()
+ })
+
it('renders layout field wrapper', () => {
const widget = createColorWidget('#ff0000')
renderComponent(widget, '#ff0000')
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetColorPicker.vue b/src/renderer/extensions/vueNodes/widgets/components/WidgetColorPicker.vue
index d71ae699296..4e619e4d2b4 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetColorPicker.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetColorPicker.vue
@@ -1,6 +1,10 @@
-
-
+
+
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetInputText.test.ts b/src/renderer/extensions/vueNodes/widgets/components/WidgetInputText.test.ts
index bdbeb10e6a3..da5b0744e1f 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetInputText.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetInputText.test.ts
@@ -169,6 +169,34 @@ describe('WidgetInputText Value Binding', () => {
expect(textarea).not.toBeInTheDocument()
})
+ it('restores the same text control after a link is removed', async () => {
+ const widget = createInputTextWidget('stale prompt', {
+ disabled: true
+ })
+ widget.linkedDisplay = 'control'
+ const { rerender } = renderComponent(widget, 'stale prompt')
+
+ const linkedInput = screen.getByRole('textbox', { hidden: true })
+ expect(linkedInput).toBeDisabled()
+ expect(screen.queryByRole('textbox')).toBeNull()
+ expect(screen.getByTestId('linked-widget-content')).toHaveAttribute(
+ 'inert'
+ )
+ expect(
+ screen.getByRole('img', { name: 'test_input: Linked input' })
+ ).toBeVisible()
+
+ await rerender({
+ widget: createInputTextWidget('stale prompt'),
+ modelValue: 'stale prompt'
+ })
+
+ expect(screen.queryByRole('img')).toBeNull()
+ expect(screen.getByRole('textbox')).toBeVisible()
+ expect(screen.getByRole('textbox')).toBeEnabled()
+ expect(screen.getByRole('textbox')).toHaveValue('stale prompt')
+ })
+
it('marks the text input as invalid', () => {
const widget = createInputTextWidget('invalid value')
renderComponent(widget, 'invalid value', { invalid: true })
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetInputText.vue b/src/renderer/extensions/vueNodes/widgets/components/WidgetInputText.vue
index d4a604ea656..c1f166dcce2 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetInputText.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetInputText.vue
@@ -68,6 +68,7 @@ const isReadOnly = computed(() =>
const layoutWidget = computed(() => ({
name: widget.name,
label: widget.label,
+ linkedDisplay: widget.linkedDisplay,
borderStyle: cn(
widget.borderStyle,
invalid && 'border border-destructive-background'
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetSelect.vue b/src/renderer/extensions/vueNodes/widgets/components/WidgetSelect.vue
index 1fef32bdd89..22fe423fd59 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetSelect.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetSelect.vue
@@ -28,15 +28,13 @@ import WidgetSelectDefault from '@/renderer/extensions/vueNodes/widgets/componen
import WidgetSelectDropdown from '@/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.vue'
import WidgetWithControl from '@/renderer/extensions/vueNodes/widgets/components/WidgetWithControl.vue'
import type { LayoutMode } from '@/renderer/extensions/vueNodes/widgets/components/form/dropdown/types'
+import { resolveWidgetSelectMode } from '@/renderer/extensions/vueNodes/widgets/utils/widgetSelectMode'
import type { ResultItemType } from '@/schemas/apiSchema'
-import { isComboInputSpec } from '@/schemas/nodeDef/nodeDefSchemaV2'
-import type { ComboInputSpec } from '@/schemas/nodeDef/nodeDefSchemaV2'
import type {
SimplifiedControlWidget,
SimplifiedWidget,
WidgetValue
} from '@/types/simplifiedWidget'
-import type { AssetKind } from '@/types/widgetTypes'
type SelectControlWidget = SimplifiedControlWidget
@@ -47,84 +45,24 @@ const props = defineProps<{
const modelValue = defineModel()
-const comboSpec = computed(() => {
- if (props.widget.spec && isComboInputSpec(props.widget.spec)) {
- return props.widget.spec
- }
- return undefined
-})
-
-const specDescriptor = computed<{
- kind: AssetKind
- allowUpload: boolean
- folder: ResultItemType | undefined
- subfolder: string | undefined
-}>(() => {
- const spec = comboSpec.value
- if (!spec) {
- return {
- kind: 'unknown',
- allowUpload: false,
- folder: undefined,
- subfolder: undefined
- }
- }
-
- const {
- image_upload,
- animated_image_upload,
- video_upload,
- image_folder,
- audio_upload,
- mesh_upload,
- upload_subfolder
- } = spec
-
- let kind: AssetKind = 'unknown'
- if (video_upload) {
- kind = 'video'
- } else if (image_upload || animated_image_upload) {
- kind = 'image'
- } else if (audio_upload) {
- kind = 'audio'
- } else if (mesh_upload) {
- kind = 'mesh'
- }
-
- // TODO: add support for models (checkpoints, VAE, LoRAs, etc.) -- get widgetType from spec
-
- const allowUpload =
- image_upload === true ||
- animated_image_upload === true ||
- video_upload === true ||
- audio_upload === true ||
- mesh_upload === true
-
- const folder = mesh_upload ? 'input' : image_folder
-
- return {
- kind,
- allowUpload,
- folder,
- subfolder: upload_subfolder
- }
-})
-
-const isAssetMode = computed(
- () =>
- assetService.shouldUseAssetBrowser(props.nodeType, props.widget.name) ||
- (assetService.isAssetAPIEnabled() && props.widget.type === 'asset')
+const mode = computed(() =>
+ resolveWidgetSelectMode(props.widget, {
+ assetApiEnabled: assetService.isAssetAPIEnabled(),
+ useAssetBrowser: assetService.shouldUseAssetBrowser(
+ props.nodeType,
+ props.widget.name
+ )
+ })
)
-const assetKind = computed(() => specDescriptor.value.kind)
-const isDropdownUIWidget = computed(
- () => isAssetMode.value || assetKind.value !== 'unknown'
-)
-const allowUpload = computed(() => specDescriptor.value.allowUpload)
+const assetKind = computed(() => mode.value.assetKind)
+const isAssetMode = computed(() => mode.value.isAssetMode)
+const isDropdownUIWidget = computed(() => mode.value.isDropdownUIWidget)
+const allowUpload = computed(() => mode.value.allowUpload)
const uploadFolder = computed(() => {
- return specDescriptor.value.folder ?? 'input'
+ return mode.value.uploadFolder ?? 'input'
})
-const uploadSubfolder = computed(() => specDescriptor.value.subfolder)
+const uploadSubfolder = computed(() => mode.value.uploadSubfolder)
const defaultLayoutMode = computed(() => {
return isAssetMode.value ? 'list' : 'grid'
})
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDefault.test.ts b/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDefault.test.ts
index bc79b6e0924..e7966e74e8a 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDefault.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDefault.test.ts
@@ -426,6 +426,26 @@ describe('WidgetSelectDefault', () => {
expect(screen.getByTestId('widget-select-default-trigger')).toBeDisabled()
})
+ it('closes an open overlay when widget options become disabled', async () => {
+ const { rerender, user } = renderComponent(createWidget(['a', 'b']), 'a')
+
+ await openDropdown(user)
+ expect(
+ screen.getByTestId('widget-select-default-overlay')
+ ).toBeInTheDocument()
+
+ await rerender({
+ widget: createWidget(['a', 'b'], { disabled: true })
+ })
+
+ await waitFor(() => {
+ expect(
+ screen.queryByTestId('widget-select-default-overlay')
+ ).not.toBeInTheDocument()
+ })
+ expect(screen.getByTestId('widget-select-default-trigger')).toBeDisabled()
+ })
+
it('uses getOptionLabel for trigger and option labels', async () => {
const { user } = renderComponent(
createWidget(['hash-a'], {
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDefault.vue b/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDefault.vue
index 5ba039de40b..ab7a2a51dbe 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDefault.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDefault.vue
@@ -162,7 +162,7 @@ import {
ComboboxRoot,
ComboboxTrigger
} from 'reka-ui'
-import { computed, ref } from 'vue'
+import { computed, ref, watch } from 'vue'
import type { CSSProperties } from 'vue'
import { useRestoreFocusOnViewportPointer } from '@/renderer/extensions/vueNodes/widgets/composables/useRestoreFocusOnViewportPointer'
@@ -378,4 +378,8 @@ function handleOpenChange(open: boolean) {
searchQuery.value = ''
}
}
+
+watch(disabled, (isDisabled) => {
+ if (isDisabled) handleOpenChange(false)
+})
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.test.ts b/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.test.ts
index 7e6c42ec7c4..b85e54def56 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.test.ts
@@ -1,7 +1,8 @@
import { fromPartial } from '@total-typescript/shoehorn'
import { createTestingPinia } from '@pinia/testing'
-import { render, screen } from '@testing-library/vue'
+import { render, screen, waitFor, within } from '@testing-library/vue'
+import userEvent from '@testing-library/user-event'
import PrimeVue from 'primevue/config'
import { computed, nextTick, ref } from 'vue'
import type { Ref } from 'vue'
@@ -14,6 +15,12 @@ import WidgetSelectDropdown from '@/renderer/extensions/vueNodes/widgets/compone
import type { SimplifiedWidget } from '@/types/simplifiedWidget'
import { createMockWidget } from './widgetTestUtils'
+vi.mock('@/composables/useFeatureFlags', () => ({
+ useFeatureFlags: () => ({
+ flags: { modelUploadButtonEnabled: false }
+ })
+}))
+
const mockCheckState = vi.hoisted(() => vi.fn())
const mockAssetsData = vi.hoisted(() => ({ items: [] as AssetItem[] }))
@@ -198,6 +205,52 @@ describe('WidgetSelectDropdown', () => {
expect(screen.getByText('model_a.safetensors')).toBeDefined()
})
+ it('closes an open core selector when it becomes linked', async () => {
+ mockItemsRef.value = [
+ { id: 'input-0', name: 'stale.png', label: 'stale.png' }
+ ]
+ mockSelectedSetRef.value = new Set(['input-0'])
+ const widget = createMockWidget({
+ value: 'stale.png',
+ name: 'image',
+ type: 'asset',
+ options: {
+ values: ['stale.png']
+ }
+ })
+ const { rerender } = renderComponent(widget, 'stale.png')
+ const user = userEvent.setup()
+
+ await user.click(screen.getByRole('button', { name: 'stale.png' }))
+ expect(await screen.findByTestId('form-dropdown-menu')).toBeVisible()
+
+ const linkedWidget: SimplifiedWidget = {
+ ...widget,
+ linkedDisplay: 'control',
+ options: { ...widget.options, disabled: true }
+ }
+ await rerender({ widget: linkedWidget, modelValue: 'stale.png' })
+
+ await waitFor(() =>
+ expect(screen.queryByTestId('form-dropdown-menu')).not.toBeInTheDocument()
+ )
+
+ const content = screen.getByTestId('linked-widget-content')
+ expect(content).toHaveAttribute('inert')
+ expect(content).toHaveAttribute('aria-hidden', 'true')
+ expect(
+ screen.queryByRole('button', { name: 'stale.png' })
+ ).not.toBeInTheDocument()
+ expect(
+ screen.getByRole('img', { name: 'image: Linked input' })
+ ).toBeVisible()
+ for (const button of within(content).getAllByRole('button', {
+ hidden: true
+ })) {
+ expect(button).toBeDisabled()
+ }
+ })
+
describe('composable wiring', () => {
const items: FormDropdownItem[] = [
{ id: 'input-0', name: 'cat.png', label: 'cat.png' },
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.vue b/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.vue
index 3ba7bbc0774..5f3093fb032 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetSelectDropdown.vue
@@ -183,6 +183,7 @@ async function updateFiles(files: File[]) {
:show-base-model-filter
:base-model-options
:is-uploading
+ :close-on-disable="Boolean(widget.linkedDisplay)"
v-bind="combinedProps"
:loading-more="toValue(outputAssets.isLoading)"
class="w-full"
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.test.ts b/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.test.ts
index a3c29304537..3a8cd6df0cc 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.test.ts
@@ -174,6 +174,49 @@ describe('WidgetTextarea Value Binding', () => {
expect(textarea.value).toBe('initial content')
})
+ it('keeps an unlinked disabled textarea disabled and readonly', () => {
+ const widget = createTextareaWidget('readable content', {
+ disabled: true
+ })
+ renderComponent(widget, 'readable content')
+
+ const textarea = screen.getByRole('textbox')
+ expect(textarea).toHaveAttribute('readonly')
+ expect(textarea).toBeDisabled()
+ })
+
+ it('restores the textarea after a link is removed', async () => {
+ const widget = createTextareaWidget('stale multiline', {
+ disabled: true
+ })
+ widget.linkedDisplay = 'expanding'
+ const { rerender } = renderComponent(widget, 'stale multiline')
+ const textarea = screen.getByTestId('linked-widget-content')
+
+ expect(textarea).toBeDisabled()
+ expect(textarea).toHaveAttribute('inert')
+ expect(textarea).toHaveAttribute('aria-hidden', 'true')
+ expect(screen.queryByRole('textbox')).toBeNull()
+ textarea.focus()
+ expect(textarea).not.toHaveFocus()
+ expect(
+ screen.getByRole('img', {
+ name: 'test_textarea: Linked input'
+ })
+ ).toBeVisible()
+ expect(screen.queryByRole('button')).toBeNull()
+
+ await rerender({
+ widget: createTextareaWidget('stale multiline'),
+ modelValue: 'stale multiline'
+ })
+
+ expect(screen.queryByRole('img')).toBeNull()
+ expect(screen.getByRole('textbox')).toBeVisible()
+ expect(screen.getByRole('textbox')).toBeEnabled()
+ expect(screen.getByRole('textbox')).toHaveValue('stale multiline')
+ })
+
it('uses widget name as placeholder when no placeholder provided', () => {
const widget = createTextareaWidget('test')
const { container } = renderComponent(widget, 'test')
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.vue b/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.vue
index d93dc889531..4f79f933538 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetTextarea.vue
@@ -3,7 +3,9 @@
:class="
cn(
'group relative rounded-lg transition-all focus-within:ring focus-within:ring-component-node-widget-background-highlighted',
- !isReadOnly && 'hover:bg-component-node-widget-background-hovered',
+ !isReadOnly &&
+ !isLinked &&
+ 'hover:bg-component-node-widget-background-hovered',
widget.borderStyle
)
"
@@ -25,12 +27,18 @@
WidgetInputBaseClass,
'size-full resize-none text-(length:--comfy-textarea-font-size) leading-normal',
!hideLayoutField && 'pt-5',
+ isLinked && 'invisible',
// Avoid overflow-auto when idle to prevent per-textarea compositing layers.
'overflow-hidden hover:overflow-auto focus:overflow-auto'
)
"
:placeholder
:readonly="isReadOnly"
+ :disabled="isLinked || filteredProps.disabled"
+ :aria-hidden="isLinked ? 'true' : undefined"
+ :inert="isLinked ? true : undefined"
+ :tabindex="isLinked ? -1 : undefined"
+ :data-testid="isLinked ? 'linked-widget-content' : undefined"
data-capture-wheel="true"
@pointerdown.capture.stop="trackFocus"
@pointermove.capture.stop
@@ -38,7 +46,7 @@
@contextmenu.capture="handleContextMenu"
/>
+
@@ -68,6 +77,7 @@ import {
} from '@/utils/widgetPropFilter'
import { WidgetInputBaseClass } from './layout'
+import LinkedWidgetStatus from './LinkedWidgetStatus.vue'
const { widget, placeholder = '' } = defineProps<{
widget: SimplifiedWidget
@@ -96,6 +106,7 @@ const id = useId()
const isReadOnly = computed(() =>
Boolean(widget.options?.read_only || widget.options?.disabled)
)
+const isLinked = computed(() => widget.linkedDisplay === 'expanding')
function handleContextMenu(e: MouseEvent) {
if (isNodeOptionsOpen() || isFocused.value) {
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.test.ts b/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.test.ts
index e0517fcc4f0..5956ff8e576 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.test.ts
@@ -286,6 +286,20 @@ describe('WidgetToggleSwitch Value Binding', () => {
}
})
+ it('disables ToggleGroup when disabled is set', () => {
+ const widget = createToggleWidget(false, {
+ on: 'yes',
+ off: 'no',
+ disabled: true
+ })
+ mountComponent(widget, false)
+
+ const buttons = screen.getAllByRole('button')
+ for (const button of buttons) {
+ expect(button).toBeDisabled()
+ }
+ })
+
it('keeps an implicit switch unchanged when read_only is set', async () => {
const widget = createToggleWidget(false, { read_only: true })
const onModelUpdate = vi.fn()
@@ -314,6 +328,47 @@ describe('WidgetToggleSwitch Value Binding', () => {
expect(control).not.toBeChecked()
})
+ it('exposes a linked status on the implicit switch surface', () => {
+ const widget = createToggleWidget(false)
+ widget.linkedDisplay = 'switch'
+ mountComponent(widget, false)
+
+ const content = screen.getByTestId('linked-widget-content')
+ const control = screen.getByRole('switch', { hidden: true })
+ expect(content).toHaveAttribute('inert')
+ expect(content).toHaveAttribute('aria-hidden', 'true')
+ expect(control).toBeDisabled()
+ expect(screen.queryByRole('switch')).toBeNull()
+ control.focus()
+ expect(control).not.toHaveFocus()
+ expect(
+ screen.getByRole('img', {
+ name: 'test_toggle: Linked input'
+ })
+ ).toHaveAttribute('data-linked-display', 'switch')
+ })
+
+ it('keeps labeled linked toggles disabled behind one control status', () => {
+ const widget = createToggleWidget(false, {
+ on: 'enabled',
+ off: 'disabled'
+ })
+ widget.linkedDisplay = 'control'
+ mountComponent(widget, false)
+
+ const content = screen.getByTestId('linked-widget-content')
+ const controls = screen.getAllByRole('button', { hidden: true })
+ expect(content).toHaveAttribute('inert')
+ expect(content).toHaveAttribute('aria-hidden', 'true')
+ expect(screen.queryByRole('button')).toBeNull()
+ for (const control of controls) expect(control).toBeDisabled()
+ expect(
+ screen.getByRole('img', {
+ name: 'test_toggle: Linked input'
+ })
+ ).toHaveAttribute('data-linked-display', 'control')
+ })
+
it('does not emit when clicking already-selected option', async () => {
const widget = createToggleWidget(false, { on: 'yes', off: 'no' })
const onModelUpdate = vi.fn()
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.vue b/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.vue
index 30a02c1e14d..69b2bad114d 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetToggleSwitch.vue
@@ -4,7 +4,13 @@
v-if="hasLabels"
type="single"
:model-value="modelValue ? 'on' : 'off'"
- :disabled="Boolean(widget.options?.read_only)"
+ :disabled="
+ Boolean(
+ widget.linkedDisplay ||
+ widget.options?.read_only ||
+ widget.options?.disabled
+ )
+ "
:class="
cn(
WidgetInputBaseClass,
@@ -25,18 +31,26 @@
v-else
:class="
cn(
- '-m-1 flex w-fit items-center gap-2 rounded-full p-1',
+ 'relative -m-1 flex w-fit items-center gap-2 rounded-full p-1',
hideLayoutField || 'ml-auto',
borderStyle
)
"
>
-
+
+
+
+
@@ -53,6 +67,7 @@ import { useHideLayoutField } from '@/types/widgetTypes'
import { cn } from '@comfyorg/tailwind-utils'
import { WidgetInputBaseClass } from './layout'
+import LinkedWidgetStatus from './LinkedWidgetStatus.vue'
import WidgetLayoutField from './layout/WidgetLayoutField.vue'
const { widget } = defineProps<{
@@ -67,6 +82,7 @@ const { t } = useI18n()
const hasLabels = computed(() => {
return widget.options?.on != null || widget.options?.off != null
})
+const isLinkedSwitch = computed(() => widget.linkedDisplay === 'switch')
function handleOptionChange(value: string | undefined) {
if (value) {
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetWithControl.test.ts b/src/renderer/extensions/vueNodes/widgets/components/WidgetWithControl.test.ts
index 4e66ae4ba4a..c1496ea06b3 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetWithControl.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetWithControl.test.ts
@@ -1,7 +1,9 @@
-import { render, screen } from '@testing-library/vue'
+import { createTestingPinia } from '@pinia/testing'
+import { render, screen, waitFor } from '@testing-library/vue'
import userEvent from '@testing-library/user-event'
import { describe, expect, it, vi } from 'vitest'
-import { defineComponent, nextTick } from 'vue'
+import { defineComponent, nextTick, ref } from 'vue'
+import { createI18n } from 'vue-i18n'
import type {
SafeControlWidget,
@@ -10,8 +12,18 @@ import type {
} from '@/types/simplifiedWidget'
import WidgetWithControl from './WidgetWithControl.vue'
+import ValueControlPopover from './ValueControlPopover.vue'
import { createMockWidget } from './widgetTestUtils'
+vi.mock('primevue/radiobutton', () => ({
+ default: {
+ props: ['inputId', 'modelValue', 'value'],
+ emits: ['update:modelValue'],
+ template:
+ ''
+ }
+}))
+
const PopoverStub = defineComponent({
name: 'Popover',
template: `
@@ -24,9 +36,12 @@ const PopoverStub = defineComponent({
const ValueControlButtonStub = defineComponent({
name: 'ValueControlButton',
- props: { mode: { type: String, default: '' } },
+ props: {
+ disabled: { type: Boolean, default: false },
+ mode: { type: String, default: '' }
+ },
template:
- '{{ mode }}'
+ '{{ mode }}'
})
const ValueControlPopoverStub = defineComponent({
@@ -43,6 +58,23 @@ const ValueControlPopoverStub = defineComponent({
`
})
+const PortaledPopoverStub = defineComponent({
+ name: 'Popover',
+ components: { ValueControlPopover },
+ setup() {
+ const open = ref(false)
+ return { open }
+ },
+ template: `
+
+
+
+
+
+
+ `
+})
+
const RenderedComponent = defineComponent({
name: 'RenderedComponent',
props: {
@@ -58,6 +90,12 @@ const RenderedComponent = defineComponent({
`
})
+const i18n = createI18n({
+ legacy: false,
+ locale: 'en',
+ messages: { en: {} }
+})
+
const makeControlWidget = (
update: (value: WidgetValue) => void = () => {},
initial = 'randomize'
@@ -87,6 +125,15 @@ const mount = (widget: SimplifiedControlWidget, modelValue = 0) =>
props: { widget, modelValue, component: RenderedComponent }
})
+const mountWithPortal = (widget: SimplifiedControlWidget, modelValue = 0) =>
+ render(WidgetWithControl, {
+ global: {
+ plugins: [createTestingPinia(), i18n],
+ stubs: { Popover: PortaledPopoverStub }
+ },
+ props: { widget, modelValue, component: RenderedComponent }
+ })
+
describe('WidgetWithControl', () => {
it('renders the passed component with widget and modelValue', () => {
mount(makeControlWidget(), 42)
@@ -119,4 +166,64 @@ describe('WidgetWithControl', () => {
mount(makeControlWidget(update, 'randomize'))
expect(update).not.toHaveBeenCalled()
})
+
+ it('disables the value control with the wrapped widget', () => {
+ const widget = makeControlWidget()
+ widget.options = { disabled: true }
+ mount(widget)
+
+ expect(screen.getByTestId('control-button')).toBeDisabled()
+ })
+
+ it('unmounts an open value-control portal when linked', async () => {
+ const update = vi.fn<(value: WidgetValue) => void>()
+ const widget = makeControlWidget(update, 'randomize')
+ const { rerender } = mountWithPortal(widget)
+ const user = userEvent.setup()
+
+ await user.click(await screen.findByTestId('value-control'))
+ expect(await screen.findAllByRole('radio')).toHaveLength(4)
+
+ const linkedWidget: SimplifiedControlWidget = {
+ ...widget,
+ linkedDisplay: 'control',
+ options: { ...widget.options, disabled: true }
+ }
+ update.mockClear()
+ await rerender({
+ widget: linkedWidget,
+ modelValue: 0,
+ component: RenderedComponent
+ })
+
+ await waitFor(() => expect(screen.queryAllByRole('radio')).toHaveLength(0))
+ const linkedButton = screen.getByTestId('value-control')
+ expect(linkedButton).toBeDisabled()
+ linkedButton.focus()
+ expect(linkedButton).not.toHaveFocus()
+ await user.click(linkedButton)
+ await user.keyboard('{Enter}')
+ expect(update).not.toHaveBeenCalled()
+ })
+
+ it('unmounts an open value-control portal when disabled', async () => {
+ const widget = makeControlWidget()
+ const { rerender } = mountWithPortal(widget)
+ const user = userEvent.setup()
+
+ await user.click(await screen.findByTestId('value-control'))
+ expect(await screen.findAllByRole('radio')).toHaveLength(4)
+
+ await rerender({
+ widget: {
+ ...widget,
+ options: { ...widget.options, disabled: true }
+ },
+ modelValue: 0,
+ component: RenderedComponent
+ })
+
+ await waitFor(() => expect(screen.queryAllByRole('radio')).toHaveLength(0))
+ expect(screen.getByTestId('value-control')).toBeDisabled()
+ })
})
diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetWithControl.vue b/src/renderer/extensions/vueNodes/widgets/components/WidgetWithControl.vue
index 13e35d916da..70549fdd720 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/WidgetWithControl.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetWithControl.vue
@@ -28,12 +28,18 @@ watch(controlModel, props.widget.controlWidget.update)
diff --git a/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.test.ts b/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.test.ts
index 01115dc8fb0..87ff7e36af7 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.test.ts
+++ b/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.test.ts
@@ -81,6 +81,9 @@ const MockPopover = {
}
interface MountDropdownOptions {
+ closeOnDisable?: boolean
+ disabled?: boolean
+ isOpen?: boolean
searcher?: (
query: string,
items: FormDropdownItem[],
@@ -105,6 +108,9 @@ function mountDropdown(
const result = render(FormDropdown, {
props: {
items,
+ closeOnDisable: options.closeOnDisable,
+ disabled: options.disabled,
+ ...(options.isOpen === undefined ? {} : { isOpen: options.isOpen }),
multiple: options.multiple,
selected: options.selected,
searcher: options.searcher,
@@ -457,6 +463,56 @@ describe('FormDropdown', () => {
expect(onUpdateIsOpen).toHaveBeenLastCalledWith(false)
})
+ it('closes when a linked display disables the dropdown', async () => {
+ const onUpdateIsOpen = vi.fn()
+ const items = [createItem('1', 'alpha')]
+ const { rerender, user } = mountDropdown(items, {
+ closeOnDisable: true,
+ onUpdateIsOpen
+ })
+ await openDropdown(user)
+
+ expect(onUpdateIsOpen).toHaveBeenLastCalledWith(true)
+
+ await rerender({
+ items,
+ closeOnDisable: true,
+ disabled: true,
+ 'onUpdate:isOpen': onUpdateIsOpen
+ })
+
+ expect(onUpdateIsOpen).toHaveBeenLastCalledWith(false)
+ })
+
+ it('closes when mounted disabled with closeOnDisable', () => {
+ const onUpdateIsOpen = vi.fn()
+ mountDropdown([createItem('1', 'alpha')], {
+ closeOnDisable: true,
+ disabled: true,
+ isOpen: true,
+ onUpdateIsOpen
+ })
+
+ expect(onUpdateIsOpen).toHaveBeenCalledWith(false)
+ })
+
+ it('stays open when disabled without closeOnDisable', async () => {
+ const onUpdateIsOpen = vi.fn()
+ const items = [createItem('1', 'alpha')]
+ const { rerender, user } = mountDropdown(items, { onUpdateIsOpen })
+ await openDropdown(user)
+
+ expect(onUpdateIsOpen).toHaveBeenLastCalledWith(true)
+
+ await rerender({
+ items,
+ disabled: true,
+ 'onUpdate:isOpen': onUpdateIsOpen
+ })
+
+ expect(onUpdateIsOpen).toHaveBeenLastCalledWith(true)
+ })
+
it('stays open on a pointerdown inside the menu', async () => {
const onUpdateIsOpen = vi.fn()
const { user } = mountDropdown([createItem('1', 'alpha')], {
diff --git a/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.vue b/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.vue
index 81136a03c7f..a65aa12a13b 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdown.vue
@@ -7,7 +7,7 @@ import {
} from '@vueuse/core'
import Popover from 'primevue/popover'
import type { ComponentPublicInstance } from 'vue'
-import { computed, ref, useTemplateRef } from 'vue'
+import { computed, ref, useTemplateRef, watch } from 'vue'
import { useI18n } from 'vue-i18n'
import { useToastStore } from '@/platform/updates/common/toastStore'
@@ -41,6 +41,7 @@ interface Props {
uploadable?: boolean
disabled?: boolean
+ closeOnDisable?: boolean
accept?: string
filterOptions?: FilterOption[]
sortOptions?: SortOption[]
@@ -69,6 +70,7 @@ const {
multiple = false,
uploadable = false,
disabled = false,
+ closeOnDisable = false,
accept,
filterOptions = [],
sortOptions = getDefaultSortOptions(),
@@ -210,12 +212,20 @@ function focusTrigger() {
const closeDropdown = ({ restoreFocus = false } = {}) => {
if (popoverRef.value) {
popoverRef.value.hide?.()
- isOpen.value = false
}
+ isOpen.value = false
if (restoreFocus) focusTrigger()
}
+watch(
+ [() => disabled, () => closeOnDisable],
+ ([isDisabled, shouldClose]) => {
+ if (isDisabled && shouldClose) closeDropdown()
+ },
+ { immediate: true }
+)
+
/**
* Dismiss on `pointerdown` rather than PrimeVue's default `click` (mouseup) so
* the dropdown closes the instant an outside press lands, and a focused inner
diff --git a/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdownInput.vue b/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdownInput.vue
index 66486215045..248134d9e11 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdownInput.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/form/dropdown/FormDropdownInput.vue
@@ -78,6 +78,7 @@ defineExpose({ focus, showPicker })
>
stale prompt'
+ }
+ })
+
+ const content = screen.getByTestId('linked-widget-content')
+ const control = screen.getByRole('button', { hidden: true })
+ expect(content).toHaveAttribute('inert')
+ expect(content).toHaveAttribute('aria-hidden', 'true')
+ expect(control).toBeDisabled()
+ expect(screen.queryByRole('button')).toBeNull()
+ expect(
+ screen.getByRole('img', { name: 'prompt: Linked input' })
+ ).toBeVisible()
+
+ await rerender({ widget: { name: 'prompt' } })
+
+ expect(screen.queryByRole('img')).toBeNull()
+ expect(screen.getByRole('button', { name: 'stale prompt' })).toBeVisible()
+ })
})
// user-event models clicks/keyboard but not raw pointerdown/move/up.
@@ -106,11 +133,14 @@ describe('WidgetLayoutField', () => {
describe('Pointer-event isolation', () => {
// The slot wrapper stops pointerdown/move/up so inner controls can capture
// drags without triggering node selection/drag on the outer canvas.
- function renderInsideParent(onParentPointer: (type: string) => void) {
+ function renderInsideParent(
+ onParentPointer: (type: string) => void,
+ widget: WidgetShape = { name: 'seed' }
+ ) {
const Harness = defineComponent({
components: { WidgetLayoutField },
setup: () => ({
- widget: { name: 'seed' },
+ widget,
onDown: () => onParentPointer('pointerdown'),
onMove: () => onParentPointer('pointermove'),
onUp: () => onParentPointer('pointerup')
@@ -148,6 +178,26 @@ describe('WidgetLayoutField', () => {
}
)
+ it.for([
+ ['pointerdown', fireEvent.pointerDown],
+ ['pointermove', fireEvent.pointerMove],
+ ['pointerup', fireEvent.pointerUp]
+ ] as const)(
+ 'allows linked status %s to propagate to the parent',
+ async ([type, dispatch]) => {
+ renderInsideParent(vi.fn(), {
+ name: 'seed',
+ linkedDisplay: 'control'
+ })
+ const parentSpy = vi.fn()
+ screen.getByTestId('parent').addEventListener(type, parentSpy)
+
+ await dispatch(screen.getByRole('img', { name: 'seed: Linked input' }))
+
+ expect(parentSpy).toHaveBeenCalledTimes(1)
+ }
+ )
+
it('still allows the inner control itself to observe the event', async () => {
const parentSpy = vi.fn<(type: string) => void>()
const innerSpy = vi.fn()
diff --git a/src/renderer/extensions/vueNodes/widgets/components/layout/WidgetLayoutField.vue b/src/renderer/extensions/vueNodes/widgets/components/layout/WidgetLayoutField.vue
index d7824b8e482..dd3111ef3c0 100644
--- a/src/renderer/extensions/vueNodes/widgets/components/layout/WidgetLayoutField.vue
+++ b/src/renderer/extensions/vueNodes/widgets/components/layout/WidgetLayoutField.vue
@@ -5,13 +5,20 @@ import type { SimplifiedWidget } from '@/types/simplifiedWidget'
import { useHideLayoutField } from '@/types/widgetTypes'
import { cn } from '@comfyorg/tailwind-utils'
-const { widget, rootClass } = defineProps<{
+import LinkedWidgetStatus from '../LinkedWidgetStatus.vue'
+
+const {
+ widget,
+ rootClass,
+ linkedStatusRounded = 'md'
+} = defineProps<{
widget: Pick<
SimplifiedWidget,
- 'name' | 'label' | 'borderStyle'
+ 'name' | 'label' | 'borderStyle' | 'linkedDisplay'
>
rootClass?: string
noBorder?: boolean
+ linkedStatusRounded?: 'md' | 'lg'
}>()
const hideLayoutField = useHideLayoutField()
@@ -21,6 +28,13 @@ const borderStyle = computed(() =>
widget.borderStyle
)
)
+const linkedDisplay = computed(() =>
+ widget.linkedDisplay === 'control' ? widget.linkedDisplay : undefined
+)
+
+function stopWidgetPointer(event: PointerEvent) {
+ if (!linkedDisplay.value) event.stopPropagation()
+}
@@ -46,15 +60,28 @@ const borderStyle = computed(() =>
diff --git a/src/renderer/extensions/vueNodes/widgets/registry/widgetRegistry.ts b/src/renderer/extensions/vueNodes/widgets/registry/widgetRegistry.ts
index 60a6b21f12d..b79a2078da7 100644
--- a/src/renderer/extensions/vueNodes/widgets/registry/widgetRegistry.ts
+++ b/src/renderer/extensions/vueNodes/widgets/registry/widgetRegistry.ts
@@ -320,6 +320,28 @@ export const shouldRenderAsVue = (widget: {
return !widget.options?.canvasOnly && !!widget.type
}
+export type LinkedWidgetFamily = 'boolean' | 'combo' | 'control' | 'textarea'
+
+const linkedWidgetFamilies = new Map([
+ [WidgetInputText, 'control'],
+ [WidgetInputNumber, 'control'],
+ [WidgetToggleSwitch, 'boolean'],
+ [WidgetSelect, 'combo'],
+ [WidgetColorPicker, 'control'],
+ [WidgetTextarea, 'textarea']
+])
+
+const LINKED_WIDGET_EXCLUDED_ALIASES = new Set(['asset', 'gradientslider'])
+
+export function getLinkedWidgetFamily(
+ type: string
+): LinkedWidgetFamily | undefined {
+ if (LINKED_WIDGET_EXCLUDED_ALIASES.has(type)) return undefined
+
+ const component = getComponent(type)
+ return component ? linkedWidgetFamilies.get(component) : undefined
+}
+
const EXPANDING_TYPES = [
'textarea',
'markdown',
diff --git a/src/renderer/extensions/vueNodes/widgets/utils/linkedWidgetDisplay.test.ts b/src/renderer/extensions/vueNodes/widgets/utils/linkedWidgetDisplay.test.ts
new file mode 100644
index 00000000000..cacbb28946b
--- /dev/null
+++ b/src/renderer/extensions/vueNodes/widgets/utils/linkedWidgetDisplay.test.ts
@@ -0,0 +1,200 @@
+import { describe, expect, it } from 'vitest'
+
+import type { InputSpec } from '@/schemas/nodeDef/nodeDefSchemaV2'
+
+import { resolveLinkedWidgetDisplay } from './linkedWidgetDisplay'
+
+const linkedContext = {
+ assetApiEnabled: false,
+ linked: true,
+ useAssetBrowser: false
+}
+
+describe('resolveLinkedWidgetDisplay', () => {
+ it.for([
+ ['text', 'control'],
+ ['string', 'control'],
+ ['STRING', 'control'],
+ ['int', 'control'],
+ ['INT', 'control'],
+ ['float', 'control'],
+ ['FLOAT', 'control'],
+ ['number', 'control'],
+ ['slider', 'control'],
+ ['boolean', 'switch'],
+ ['BOOLEAN', 'switch'],
+ ['toggle', 'switch'],
+ ['combo', 'control'],
+ ['COMBO', 'control'],
+ ['color', 'control'],
+ ['COLOR', 'control'],
+ ['textarea', 'expanding'],
+ ['TEXTAREA', 'expanding'],
+ ['multiline', 'expanding'],
+ ['customtext', 'expanding']
+ ] as const)('maps the registered %s type to %s', ([type, display]) => {
+ expect(
+ resolveLinkedWidgetDisplay(
+ { name: 'value', type },
+ undefined,
+ linkedContext
+ )
+ ).toBe(display)
+ })
+
+ it.for([
+ 'String',
+ 'CoMbO',
+ 'asset',
+ 'gradientslider',
+ 'range',
+ 'curve',
+ 'imagecrop',
+ 'boundingbox',
+ 'chart',
+ 'galleria',
+ 'colors',
+ 'audiorecord',
+ 'markdown',
+ 'load3D',
+ 'painter',
+ 'imagecompare',
+ 'boundingboxes',
+ 'videoedit',
+ 'legacy',
+ 'custom_widget'
+ ])('leaves the linked %s type rendered', (type) => {
+ expect(
+ resolveLinkedWidgetDisplay(
+ { name: 'value', type },
+ undefined,
+ linkedContext
+ )
+ ).toBeUndefined()
+ })
+
+ it('leaves upload and asset-browser combos rendered', () => {
+ expect(
+ resolveLinkedWidgetDisplay(
+ {
+ name: 'image',
+ type: 'COMBO',
+ spec: { type: 'COMBO', name: 'image', image_upload: true }
+ },
+ undefined,
+ linkedContext
+ )
+ ).toBeUndefined()
+ expect(
+ resolveLinkedWidgetDisplay(
+ { name: 'ckpt_name', type: 'COMBO' },
+ undefined,
+ { ...linkedContext, useAssetBrowser: true }
+ )
+ ).toBeUndefined()
+ })
+
+ it.for([
+ {
+ nodeType: 'LoadImage',
+ name: 'image',
+ type: 'asset',
+ spec: { type: 'COMBO', name: 'image', image_upload: true }
+ },
+ {
+ nodeType: 'LoadImageMask',
+ name: 'image',
+ type: 'COMBO',
+ spec: { type: 'COMBO', name: 'image', image_upload: true }
+ },
+ {
+ nodeType: 'LoadImageOutput',
+ name: 'image',
+ type: 'asset',
+ spec: { type: 'COMBO', name: 'image', image_upload: true }
+ },
+ {
+ nodeType: 'LoadVideo',
+ name: 'file',
+ type: 'COMBO',
+ spec: { type: 'COMBO', name: 'file', video_upload: true }
+ },
+ {
+ nodeType: 'LoadAudio',
+ name: 'audio',
+ type: 'combo',
+ spec: { type: 'COMBO', name: 'audio', audio_upload: true }
+ }
+ ] satisfies Array<{
+ nodeType: string
+ name: string
+ type: string
+ spec: InputSpec
+ }>)(
+ 'includes the linked core $nodeType $name selector',
+ ({ nodeType, name, type, spec }) => {
+ expect(
+ resolveLinkedWidgetDisplay({ name, type, spec }, undefined, {
+ ...linkedContext,
+ assetApiEnabled: type === 'asset',
+ coreNodeType: nodeType,
+ useAssetBrowser: type === 'asset'
+ })
+ ).toBe('control')
+ }
+ )
+
+ it.for([
+ {
+ label: 'custom node with a core type name',
+ widget: {
+ name: 'image',
+ type: 'COMBO',
+ spec: { type: 'COMBO', name: 'image', image_upload: true }
+ },
+ coreNodeType: undefined
+ },
+ {
+ label: 'core node with the wrong widget name',
+ widget: {
+ name: 'custom_image',
+ type: 'COMBO',
+ spec: {
+ type: 'COMBO',
+ name: 'custom_image',
+ image_upload: true
+ }
+ },
+ coreNodeType: 'LoadImage'
+ },
+ {
+ label: 'core node with an unregistered mixed-case widget',
+ widget: {
+ name: 'image',
+ type: 'CoMbO',
+ spec: { type: 'COMBO', name: 'image', image_upload: true }
+ },
+ coreNodeType: 'LoadImage'
+ },
+ {
+ label: 'out-of-scope core 3D loader',
+ widget: {
+ name: 'model_file',
+ type: 'load3D',
+ spec: { type: 'COMBO', name: 'model_file' }
+ },
+ coreNodeType: 'Load3D'
+ }
+ ] satisfies Array<{
+ label: string
+ widget: { name: string; type: string; spec: InputSpec }
+ coreNodeType: string | undefined
+ }>)('excludes a $label', ({ widget, coreNodeType }) => {
+ expect(
+ resolveLinkedWidgetDisplay(widget, undefined, {
+ ...linkedContext,
+ coreNodeType
+ })
+ ).toBeUndefined()
+ })
+})
diff --git a/src/renderer/extensions/vueNodes/widgets/utils/linkedWidgetDisplay.ts b/src/renderer/extensions/vueNodes/widgets/utils/linkedWidgetDisplay.ts
new file mode 100644
index 00000000000..01d3434b70d
--- /dev/null
+++ b/src/renderer/extensions/vueNodes/widgets/utils/linkedWidgetDisplay.ts
@@ -0,0 +1,62 @@
+import type { IWidgetOptions } from '@/lib/litegraph/src/types/widgets'
+import { getLinkedWidgetFamily } from '@/renderer/extensions/vueNodes/widgets/registry/widgetRegistry'
+import { resolveWidgetSelectMode } from '@/renderer/extensions/vueNodes/widgets/utils/widgetSelectMode'
+import type { InputSpec } from '@/schemas/nodeDef/nodeDefSchemaV2'
+import type { LinkedWidgetDisplay } from '@/types/simplifiedWidget'
+
+interface LinkedWidgetDisplayWidget {
+ name: string
+ type: string
+ spec?: InputSpec
+}
+
+interface LinkedWidgetDisplayContext {
+ assetApiEnabled: boolean
+ coreNodeType?: string
+ linked: boolean
+ useAssetBrowser: boolean
+}
+
+const CORE_MEDIA_SELECTOR_WIDGETS = new Map([
+ ['LoadImage', 'image'],
+ ['LoadImageMask', 'image'],
+ ['LoadImageOutput', 'image'],
+ ['LoadVideo', 'file'],
+ ['LoadAudio', 'audio']
+])
+
+function isCoreMediaSelector(
+ widget: LinkedWidgetDisplayWidget,
+ context: LinkedWidgetDisplayContext
+): boolean {
+ return (
+ CORE_MEDIA_SELECTOR_WIDGETS.get(context.coreNodeType ?? '') ===
+ widget.name &&
+ (widget.type === 'asset' || getLinkedWidgetFamily(widget.type) === 'combo')
+ )
+}
+
+export function resolveLinkedWidgetDisplay(
+ widget: LinkedWidgetDisplayWidget,
+ options: IWidgetOptions | undefined,
+ context: LinkedWidgetDisplayContext
+): LinkedWidgetDisplay | undefined {
+ if (!context.linked) return undefined
+
+ const family = getLinkedWidgetFamily(widget.type)
+ if (isCoreMediaSelector(widget, context)) return 'control'
+ if (!family) return undefined
+
+ if (family === 'combo') {
+ const mode = resolveWidgetSelectMode(widget, context)
+ if (mode.isDropdownUIWidget) return undefined
+ }
+
+ if (family === 'textarea') return 'expanding'
+
+ if (family === 'boolean' && options?.on == null && options?.off == null) {
+ return 'switch'
+ }
+
+ return 'control'
+}
diff --git a/src/renderer/extensions/vueNodes/widgets/utils/widgetSelectMode.ts b/src/renderer/extensions/vueNodes/widgets/utils/widgetSelectMode.ts
new file mode 100644
index 00000000000..b1cdaeae409
--- /dev/null
+++ b/src/renderer/extensions/vueNodes/widgets/utils/widgetSelectMode.ts
@@ -0,0 +1,54 @@
+import { isComboInputSpec } from '@/schemas/nodeDef/nodeDefSchemaV2'
+import type { InputSpec } from '@/schemas/nodeDef/nodeDefSchemaV2'
+import type { ResultItemType } from '@/schemas/resultItemTypeSchema'
+import type { AssetKind } from '@/types/widgetTypes'
+
+interface WidgetSelectModeWidget {
+ type: string
+ spec?: InputSpec
+}
+
+interface WidgetSelectModeContext {
+ assetApiEnabled: boolean
+ useAssetBrowser: boolean
+}
+
+export function resolveWidgetSelectMode(
+ widget: WidgetSelectModeWidget,
+ { assetApiEnabled, useAssetBrowser }: WidgetSelectModeContext
+) {
+ const spec =
+ widget.spec && isComboInputSpec(widget.spec) ? widget.spec : undefined
+
+ let assetKind: AssetKind = 'unknown'
+ if (spec?.video_upload) {
+ assetKind = 'video'
+ } else if (spec?.image_upload || spec?.animated_image_upload) {
+ assetKind = 'image'
+ } else if (spec?.audio_upload) {
+ assetKind = 'audio'
+ } else if (spec?.mesh_upload) {
+ assetKind = 'mesh'
+ }
+
+ const allowUpload =
+ spec?.image_upload === true ||
+ spec?.animated_image_upload === true ||
+ spec?.video_upload === true ||
+ spec?.audio_upload === true ||
+ spec?.mesh_upload === true
+ const uploadFolder: ResultItemType | undefined = spec?.mesh_upload
+ ? 'input'
+ : spec?.image_folder
+ const isAssetMode =
+ useAssetBrowser || (assetApiEnabled && widget.type === 'asset')
+
+ return {
+ allowUpload,
+ assetKind,
+ isAssetMode,
+ isDropdownUIWidget: isAssetMode || assetKind !== 'unknown',
+ uploadFolder,
+ uploadSubfolder: spec?.upload_subfolder
+ }
+}
diff --git a/src/types/simplifiedWidget.ts b/src/types/simplifiedWidget.ts
index d5629a45e13..f15bd0754d8 100644
--- a/src/types/simplifiedWidget.ts
+++ b/src/types/simplifiedWidget.ts
@@ -52,6 +52,8 @@ export interface LinkedUpstreamInfo {
outputName?: string
}
+export type LinkedWidgetDisplay = 'control' | 'expanding' | 'switch'
+
export interface SimplifiedWidget<
T extends WidgetValue = WidgetValue,
O extends IWidgetOptions = IWidgetOptions
@@ -96,6 +98,8 @@ export interface SimplifiedWidget<
controlWidget?: SafeControlWidget
linkedUpstream?: LinkedUpstreamInfo
+
+ linkedDisplay?: LinkedWidgetDisplay
}
export interface SimplifiedControlWidget<
diff --git a/tools/devtools/dev_nodes.py b/tools/devtools/dev_nodes.py
index ffa7f9822c5..333dca03325 100644
--- a/tools/devtools/dev_nodes.py
+++ b/tools/devtools/dev_nodes.py
@@ -7,6 +7,8 @@
ErrorRaiseNodeWithMessage,
ExperimentalNode,
LoadAnimatedImageTest,
+ LinkedStandardWidgetSource,
+ LinkedStandardWidgets,
LongComboDropdown,
MultiSelectNode,
NodeWithBooleanInput,
@@ -41,6 +43,8 @@
"ErrorRaiseNodeWithMessage",
"ExperimentalNode",
"LoadAnimatedImageTest",
+ "LinkedStandardWidgetSource",
+ "LinkedStandardWidgets",
"LongComboDropdown",
"MultiSelectNode",
"NodeWithBooleanInput",
diff --git a/tools/devtools/nodes/__init__.py b/tools/devtools/nodes/__init__.py
index f0935576e1e..82dd2e3ca5e 100644
--- a/tools/devtools/nodes/__init__.py
+++ b/tools/devtools/nodes/__init__.py
@@ -9,6 +9,8 @@
NODE_DISPLAY_NAME_MAPPINGS as errors_display_name_mappings,
)
from .inputs import (
+ LinkedStandardWidgetSource,
+ LinkedStandardWidgets,
LongComboDropdown,
NodeWithBooleanInput,
NodeWithColorInput,
@@ -67,6 +69,8 @@
"ErrorRaiseNodeWithMessage",
"ExperimentalNode",
"LoadAnimatedImageTest",
+ "LinkedStandardWidgetSource",
+ "LinkedStandardWidgets",
"LongComboDropdown",
"MultiSelectNode",
"NodeWithBooleanInput",
diff --git a/tools/devtools/nodes/inputs.py b/tools/devtools/nodes/inputs.py
index 003ea718df0..07a062a1233 100644
--- a/tools/devtools/nodes/inputs.py
+++ b/tools/devtools/nodes/inputs.py
@@ -257,6 +257,113 @@ def execute(self, value):
return (value,)
+class LinkedStandardWidgetSource:
+ @classmethod
+ def INPUT_TYPES(cls):
+ return {"required": {}}
+
+ RETURN_TYPES = (
+ "STRING",
+ "INT",
+ "FLOAT",
+ "FLOAT",
+ "BOOLEAN",
+ "BOOLEAN",
+ "COMBO",
+ "COLOR",
+ "STRING",
+ )
+ RETURN_NAMES = (
+ "plain_text",
+ "integer",
+ "number",
+ "slider",
+ "switch",
+ "labeled_toggle",
+ "select",
+ "color",
+ "textarea",
+ )
+ FUNCTION = "source_values"
+ CATEGORY = "DevTools"
+
+ def source_values(self):
+ return (
+ "upstream text",
+ 1,
+ 2.5,
+ 0.5,
+ False,
+ True,
+ "Option 1",
+ "#ffffff",
+ "upstream multiline text",
+ )
+
+
+class LinkedStandardWidgets:
+ @classmethod
+ def INPUT_TYPES(cls):
+ return {
+ "required": {
+ "plain_text": (
+ "STRING",
+ {"default": "STALE PLAIN TEXT"},
+ ),
+ "integer": (
+ "INT",
+ {"default": 314, "min": 0, "max": 1_000, "step": 1},
+ ),
+ "number": (
+ "FLOAT",
+ {"default": 9.875, "min": 0, "max": 10, "step": 0.125},
+ ),
+ "slider": (
+ "FLOAT",
+ {
+ "default": 0.73,
+ "display": "slider",
+ "min": 0,
+ "max": 1,
+ "step": 0.01,
+ },
+ ),
+ "switch": ("BOOLEAN", {"default": True}),
+ "labeled_toggle": (
+ "BOOLEAN",
+ {
+ "default": False,
+ "label_on": "STALE ON",
+ "label_off": "STALE OFF",
+ },
+ ),
+ "select": (
+ "COMBO",
+ {
+ "default": "STALE SELECT VALUE",
+ "options": ["Option 1", "STALE SELECT VALUE"],
+ },
+ ),
+ "color": ("COLOR", {"default": "#22c55d"}),
+ "textarea": (
+ "STRING",
+ {
+ "default": "STALE MULTILINE PROMPT",
+ "multiline": True,
+ },
+ ),
+ }
+ }
+
+ RETURN_TYPES = ()
+ OUTPUT_NODE = True
+ FUNCTION = "inspect"
+ CATEGORY = "DevTools"
+
+ def inspect(self, **_inputs):
+ return ()
+
+
class NodeWithSeedInput:
@classmethod
def INPUT_TYPES(cls):
@@ -458,6 +565,8 @@ async def execute(cls):
"DevToolsNodeWithBooleanInput": NodeWithBooleanInput,
"DevToolsNodeWithColorInput": NodeWithColorInput,
"DevToolsSimpleSlider": SimpleSlider,
+ "DevToolsLinkedStandardWidgetSource": LinkedStandardWidgetSource,
+ "DevToolsLinkedStandardWidgets": LinkedStandardWidgets,
"DevToolsNodeWithSeedInput": NodeWithSeedInput,
"DevToolsNodeWithValidation": NodeWithValidation,
"DevToolsNodeWithV2ComboInput": NodeWithV2ComboInput,
@@ -483,6 +592,8 @@ async def execute(cls):
"DevToolsNodeWithBooleanInput": "Node With Boolean Input",
"DevToolsNodeWithColorInput": "Node With Color Input",
"DevToolsSimpleSlider": "Simple Slider",
+ "DevToolsLinkedStandardWidgetSource": "Linked Standard Widget Source",
+ "DevToolsLinkedStandardWidgets": "Linked Standard Widgets",
"DevToolsNodeWithSeedInput": "Node With Seed Input",
"DevToolsNodeWithValidation": "Node With Validation",
"DevToolsNodeWithV2ComboInput": "Node With V2 Combo Input",
@@ -506,6 +617,8 @@ async def execute(cls):
"NodeWithStringInput",
"NodeWithUnionInput",
"NodeWithBooleanInput",
+ "LinkedStandardWidgetSource",
+ "LinkedStandardWidgets",
"NodeWithColorInput",
"SimpleSlider",
"NodeWithSeedInput",