@flowdrop/flowdrop 2.2.0 → 2.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -27,6 +27,7 @@
27
27
  <script lang="ts">
28
28
  import Icon from '@iconify/svelte';
29
29
  import { m } from '../messages/index.js';
30
+ import WorkflowInterfaceEntryCard from './WorkflowInterfaceEntryCard.svelte';
30
31
  import { buildHandleId } from '../utils/handleIds.js';
31
32
  import { DEFAULT_PORT_CONFIG } from '../config/defaultPortConfig.js';
32
33
  import type {
@@ -36,9 +37,7 @@
36
37
  WorkflowInterfaceEntry
37
38
  } from '../types/index.js';
38
39
  import {
39
- describeInterfaceEntryStatus,
40
40
  listBindablePorts,
41
- pullEntryFieldsFromPort,
42
41
  resolveInterface,
43
42
  validateWorkflowInterface,
44
43
  type InterfaceIssue,
@@ -62,19 +61,6 @@
62
61
  dataTypes = DEFAULT_PORT_CONFIG.dataTypes.filter((dt) => dt.enabled !== false)
63
62
  }: Props = $props();
64
63
 
65
- /**
66
- * Options for one entry's dataType select: the configured vocabulary, plus
67
- * the entry's current value when it isn't in it (a host-custom or legacy
68
- * type) — a select must never silently rewrite a stored value it can't list.
69
- */
70
- function dataTypeOptions(current: string): Array<{ id: string; name: string }> {
71
- const options = dataTypes.map((dt) => ({ id: dt.id, name: dt.name }));
72
- if (current && !dataTypes.some((dt) => dt.id === current || dt.aliases?.includes(current))) {
73
- options.push({ id: current, name: current });
74
- }
75
- return options;
76
- }
77
-
78
64
  type Direction = 'inputs' | 'outputs';
79
65
 
80
66
  const SECTIONS: Array<{ key: Direction; entryDirection: 'input' | 'output' }> = [
@@ -129,11 +115,6 @@
129
115
  );
130
116
  }
131
117
 
132
- /** The bound port's own dataType, when the single binding resolves. */
133
- function boundPortType(status: ResolvedInterfaceEntry | undefined): string | undefined {
134
- return status?.targets[0]?.port.dataType;
135
- }
136
-
137
118
  function hasIssue(direction: Direction, entryId: string, code: string): boolean {
138
119
  return issuesFor(direction, entryId).some((issue) => issue.code === code);
139
120
  }
@@ -153,21 +134,54 @@
153
134
  return source?.data?.label ?? edge.source;
154
135
  }
155
136
 
156
- /** Statuses still explained in the card footer (the rest render inline or as the dot). */
157
- const FOOTER_STATUSES = new Set(['unbound', 'dangling', 'hidden', 'over-bound']);
137
+ /**
138
+ * Client-side row identity for the two entry lists.
139
+ *
140
+ * Interface entries have no identity of their own to key on. `id` is a field
141
+ * the author edits, and every patch replaces the entry object wholesale, so
142
+ * neither the field nor the object reference survives an edit. Keyed by
143
+ * position instead, an `{#each}` reuses a row's DOM and its card component
144
+ * for whichever entry lands in that slot — so `WorkflowInterfaceEntryCard`'s
145
+ * per-row state (its open/closed disclosure) would belong to the slot rather
146
+ * than to the entry, and reordering two cards would leave the open one
147
+ * behind.
148
+ *
149
+ * So identity is minted here, kept out of the wire format entirely, and moved
150
+ * in lockstep with the lists by the mutators below. Initialised eagerly
151
+ * rather than in an effect so the `{#each}` never renders against ids that
152
+ * have not caught up yet.
153
+ */
154
+ let rowIdSeq = 0;
158
155
 
159
- function bindablePorts(direction: Direction) {
160
- return listBindablePorts(workflow, entryDirectionOf(direction));
156
+ function mintRowId(): string {
157
+ rowIdSeq += 1;
158
+ return `row-${rowIdSeq}`;
161
159
  }
162
160
 
163
- function bindingKey(nodeId: string, portId: string): string {
164
- return `${nodeId}::${portId}`;
165
- }
161
+ let rowIds = $state<Record<Direction, string[]>>({
162
+ inputs: entriesFor('inputs').map(mintRowId),
163
+ outputs: entriesFor('outputs').map(mintRowId)
164
+ });
166
165
 
167
- /** The entry's current single binding, as a picker value (`''` = unbound). */
168
- function currentBindingValue(entry: WorkflowInterfaceEntry): string {
169
- const binding = entry.bindings[0];
170
- return binding ? bindingKey(binding.nodeId, binding.portId) : '';
166
+ /**
167
+ * Re-key a side whose list changed length from outside this component — undo,
168
+ * redo, a reload, another authoring surface. The mutators below keep ids and
169
+ * entries in step, so this never fires for a local edit.
170
+ *
171
+ * Converges: it writes only while the lengths disagree, and they agree once
172
+ * it has. `$effect.pre` so the new ids are in place before the `{#each}`
173
+ * reads them rather than one frame later.
174
+ */
175
+ $effect.pre(() => {
176
+ for (const { key } of SECTIONS) {
177
+ if (rowIds[key].length !== entriesFor(key).length) {
178
+ rowIds[key] = entriesFor(key).map(mintRowId);
179
+ }
180
+ }
181
+ });
182
+
183
+ function bindablePorts(direction: Direction) {
184
+ return listBindablePorts(workflow, entryDirectionOf(direction));
171
185
  }
172
186
 
173
187
  function nextId(direction: Direction): string {
@@ -201,10 +215,16 @@
201
215
 
202
216
  function addEntry(direction: Direction): void {
203
217
  const entry: WorkflowInterfaceEntry = { id: nextId(direction), dataType: '', bindings: [] };
218
+ // A row id of its own, so adding an entry leaves every other card — and
219
+ // every other card's disclosure — exactly as the author left it.
220
+ rowIds[direction] = [...rowIds[direction], mintRowId()];
204
221
  commit(direction, [...entriesFor(direction), entry]);
205
222
  }
206
223
 
207
224
  function removeEntry(direction: Direction, index: number): void {
225
+ // Dropping the row id destroys that card's component, and its disclosure
226
+ // state with it — no bookkeeping to keep in step.
227
+ rowIds[direction].splice(index, 1);
208
228
  commit(
209
229
  direction,
210
230
  entriesFor(direction).filter((_, i) => i !== index)
@@ -216,6 +236,10 @@
216
236
  const target = index + delta;
217
237
  if (target < 0 || target >= list.length) return;
218
238
  [list[index], list[target]] = [list[target], list[index]];
239
+ // Row ids ride along, so a card's disclosure travels with the entry
240
+ // instead of staying behind in the slot it used to occupy.
241
+ const ids = rowIds[direction];
242
+ [ids[index], ids[target]] = [ids[target], ids[index]];
219
243
  commit(direction, list);
220
244
  }
221
245
 
@@ -229,71 +253,6 @@
229
253
  );
230
254
  commit(direction, list);
231
255
  }
232
-
233
- function handleBindingChange(direction: Direction, index: number, value: string): void {
234
- if (!value) {
235
- patchEntry(direction, index, { bindings: [] });
236
- return;
237
- }
238
- const [nodeId, portId] = value.split('::');
239
- const patch: Partial<WorkflowInterfaceEntry> = { bindings: [{ nodeId, portId }] };
240
- // Convenience default: prefill an empty dataType from the picked port's own
241
- // type. The field stays freely editable afterward — this only saves the
242
- // common case of typing out what the port already declares.
243
- const entry = entriesFor(direction)[index];
244
- if (entry && !entry.dataType) {
245
- const match = bindablePorts(direction).find(
246
- (b) => b.nodeId === nodeId && b.port.id === portId
247
- );
248
- if (match) patch.dataType = match.port.dataType;
249
- }
250
- patchEntry(direction, index, patch);
251
- }
252
-
253
- /**
254
- * Write one example slot back, dropping empties and collapsing an empty
255
- * list to `undefined` so an untouched entry stores no `examples` key.
256
- */
257
- function patchExample(
258
- direction: Direction,
259
- index: number,
260
- entry: WorkflowInterfaceEntry,
261
- exampleIndex: number,
262
- raw: string
263
- ): void {
264
- const next = [...(entry.examples ?? [])];
265
- if (raw === '') next.splice(exampleIndex, 1);
266
- else next[exampleIndex] = parseDefaultValue(raw);
267
- patchEntry(direction, index, { examples: next.length > 0 ? next : undefined });
268
- }
269
-
270
- function addExample(direction: Direction, index: number, entry: WorkflowInterfaceEntry): void {
271
- patchEntry(direction, index, { examples: [...(entry.examples ?? []), ''] });
272
- }
273
-
274
- function removeExample(
275
- direction: Direction,
276
- index: number,
277
- entry: WorkflowInterfaceEntry,
278
- exampleIndex: number
279
- ): void {
280
- const next = (entry.examples ?? []).filter((_, i) => i !== exampleIndex);
281
- patchEntry(direction, index, { examples: next.length > 0 ? next : undefined });
282
- }
283
-
284
- function parseDefaultValue(raw: string): unknown {
285
- if (raw === '') return undefined;
286
- try {
287
- return JSON.parse(raw);
288
- } catch {
289
- return raw;
290
- }
291
- }
292
-
293
- function formatDefaultValue(value: unknown): string {
294
- if (value === undefined) return '';
295
- return typeof value === 'string' ? value : JSON.stringify(value);
296
- }
297
256
  </script>
298
257
 
299
258
  <div class="wf-interface">
@@ -322,262 +281,28 @@
322
281
  </p>
323
282
  {:else}
324
283
  <ul class="wf-interface__list">
325
- {#each list as entry, index (index)}
284
+ {#each list as entry, index (rowIds[section.key][index] ?? `pending-${index}`)}
326
285
  {@const status = statusFor(section.key, entry.id)}
327
- <li
328
- class="wf-interface__entry"
329
- class:wf-interface__entry--error={status?.status &&
330
- status.status !== 'ok' &&
331
- status.status !== 'unbound'}
332
- >
333
- {#if status}
334
- <span
335
- class="wf-interface__dot wf-interface__dot--{status.status}"
336
- title={describeInterfaceEntryStatus(status)}
337
- ></span>
338
- {/if}
339
- <div class="wf-interface__reorder">
340
- <button
341
- type="button"
342
- disabled={index === 0}
343
- onclick={() => moveEntry(section.key, index, -1)}
344
- aria-label={m().workflowInterface.moveUp({ id: entry.id })}
345
- >
346
- <Icon icon="heroicons:chevron-up" />
347
- </button>
348
- <button
349
- type="button"
350
- disabled={index === list.length - 1}
351
- onclick={() => moveEntry(section.key, index, 1)}
352
- aria-label={m().workflowInterface.moveDown({ id: entry.id })}
353
- >
354
- <Icon icon="heroicons:chevron-down" />
355
- </button>
356
- </div>
357
-
358
- <div class="wf-interface__fields">
359
- <div class="wf-interface__row">
360
- <label class="wf-interface__field wf-interface__field--id">
361
- <span class="wf-interface__label">{m().workflowInterface.idLabel}</span>
362
- <input
363
- type="text"
364
- value={entry.id}
365
- onchange={(e) =>
366
- patchEntry(section.key, index, { id: e.currentTarget.value })}
367
- />
368
- </label>
369
- <label class="wf-interface__field wf-interface__field--wide">
370
- <span class="wf-interface__label">{m().workflowInterface.bindingLabel}</span>
371
- <select
372
- value={currentBindingValue(entry)}
373
- onchange={(e) =>
374
- handleBindingChange(section.key, index, e.currentTarget.value)}
375
- >
376
- <option value="">{m().workflowInterface.bindingUnbound}</option>
377
- {#each bindablePorts(section.key) as candidate (bindingKey(candidate.nodeId, candidate.port.id))}
378
- <option value={bindingKey(candidate.nodeId, candidate.port.id)}>
379
- {candidate.nodeLabel} — {candidate.port.name} ({candidate.port.dataType})
380
- </option>
381
- {/each}
382
- </select>
383
- {#if section.key === 'inputs' && hasIssue(section.key, entry.id, 'interface-input-already-connected')}
384
- <span class="wf-interface__inline wf-interface__inline--error">
385
- {m().workflowInterface.alreadyConnectedInline({
386
- source: conflictingSourceLabel(entry) ?? ''
387
- })}
388
- </span>
389
- {/if}
390
- </label>
391
- {#if status?.targets[0]}
392
- <button
393
- type="button"
394
- class="wf-interface__pull"
395
- title={m().workflowInterface.pullFromPortTitle}
396
- onclick={() =>
397
- patchEntry(
398
- section.key,
399
- index,
400
- pullEntryFieldsFromPort(status.targets[0].port)
401
- )}
402
- >
403
- <Icon icon="heroicons:arrow-down-tray" />
404
- {m().workflowInterface.pullFromPort}
405
- </button>
406
- {/if}
407
- </div>
408
-
409
- <details
410
- class="wf-interface__more"
411
- open={status?.status === 'type-mismatch' || undefined}
412
- >
413
- <summary>{m().workflowInterface.moreOptions}</summary>
414
- <div class="wf-interface__row">
415
- <label class="wf-interface__field">
416
- <span class="wf-interface__label">{m().workflowInterface.nameLabel}</span>
417
- <input
418
- type="text"
419
- value={entry.name ?? ''}
420
- placeholder={m().workflowInterface.namePlaceholder}
421
- onchange={(e) =>
422
- patchEntry(section.key, index, {
423
- name: e.currentTarget.value || undefined
424
- })}
425
- />
426
- </label>
427
- <label class="wf-interface__field">
428
- <span class="wf-interface__label">{m().workflowInterface.dataTypeLabel}</span>
429
- <select
430
- value={entry.dataType}
431
- onchange={(e) =>
432
- patchEntry(section.key, index, { dataType: e.currentTarget.value })}
433
- >
434
- {#if !entry.dataType}
435
- <option value="" disabled selected>
436
- {m().workflowInterface.dataTypePlaceholder}
437
- </option>
438
- {/if}
439
- {#each dataTypeOptions(entry.dataType) as option (option.id)}
440
- <option value={option.id}>{option.name}</option>
441
- {/each}
442
- </select>
443
- {#if status?.status === 'type-mismatch' && boundPortType(status)}
444
- <span class="wf-interface__inline wf-interface__inline--warning">
445
- {m().workflowInterface.typeMismatchInline({
446
- portType: boundPortType(status) ?? ''
447
- })}
448
- <button
449
- type="button"
450
- class="wf-interface__quickfix"
451
- onclick={() =>
452
- patchEntry(section.key, index, {
453
- dataType: boundPortType(status) ?? entry.dataType
454
- })}
455
- >
456
- {m().workflowInterface.useMatchPortType}
457
- </button>
458
- </span>
459
- {/if}
460
- </label>
461
- {#if section.key === 'inputs'}
462
- <label class="wf-interface__field wf-interface__field--checkbox">
463
- <input
464
- type="checkbox"
465
- checked={entry.required ?? false}
466
- onchange={(e) =>
467
- patchEntry(section.key, index, {
468
- required: e.currentTarget.checked || undefined
469
- })}
470
- />
471
- <span class="wf-interface__label"
472
- >{m().workflowInterface.requiredLabel}</span
473
- >
474
- </label>
475
- {/if}
476
- </div>
477
-
478
- <div class="wf-interface__row">
479
- <label class="wf-interface__field wf-interface__field--wide">
480
- <span class="wf-interface__label"
481
- >{m().workflowInterface.descriptionLabel}</span
482
- >
483
- <input
484
- type="text"
485
- value={entry.description ?? ''}
486
- onchange={(e) =>
487
- patchEntry(section.key, index, {
488
- description: e.currentTarget.value || undefined
489
- })}
490
- />
491
- </label>
492
- <label class="wf-interface__field">
493
- <span class="wf-interface__label"
494
- >{m().workflowInterface.defaultValueLabel}</span
495
- >
496
- <input
497
- type="text"
498
- value={formatDefaultValue(entry.defaultValue)}
499
- onchange={(e) =>
500
- patchEntry(section.key, index, {
501
- defaultValue: parseDefaultValue(e.currentTarget.value)
502
- })}
503
- />
504
- </label>
505
- </div>
506
-
507
- {#if section.key === 'inputs'}
508
- <div class="wf-interface__examples">
509
- <span class="wf-interface__label">
510
- {m().workflowInterface.examplesLabel}
511
- </span>
512
- {#each entry.examples ?? [] as example, exampleIndex (exampleIndex)}
513
- <div class="wf-interface__example-row">
514
- <input
515
- type="text"
516
- value={formatDefaultValue(example)}
517
- onchange={(e) =>
518
- patchExample(
519
- section.key,
520
- index,
521
- entry,
522
- exampleIndex,
523
- e.currentTarget.value
524
- )}
525
- />
526
- <button
527
- type="button"
528
- class="wf-interface__example-remove"
529
- onclick={() => removeExample(section.key, index, entry, exampleIndex)}
530
- aria-label={m().workflowInterface.removeExample}
531
- >
532
- <Icon icon="heroicons:x-mark" />
533
- </button>
534
- </div>
535
- {/each}
536
- <button
537
- type="button"
538
- class="wf-interface__example-add"
539
- onclick={() => addExample(section.key, index, entry)}
540
- >
541
- <Icon icon="heroicons:plus" />
542
- {m().workflowInterface.addExample}
543
- </button>
544
- </div>
545
- {/if}
546
- </details>
547
-
548
- <!-- Every resolveInterface status renders in words somewhere in
549
- this card — the obligation that makes this surface
550
- canonical. `ok` lives on the header dot; type-mismatch and
551
- already-connected render inline next to their own field;
552
- the rest are explained here. -->
553
- {#if status && FOOTER_STATUSES.has(status.status)}
554
- <p class="wf-interface__status wf-interface__status--{status.status}">
555
- {describeInterfaceEntryStatus(status)}
556
- </p>
557
- {/if}
558
- {#each footerIssues(section.key, entry.id, status) as issue (issue.code)}
559
- <p class="wf-interface__status wf-interface__status--{issue.severity}">
560
- {issue.message}
561
- </p>
562
- {/each}
563
-
564
- {#if entry.meta && Object.keys(entry.meta).length > 0}
565
- <details class="wf-interface__meta">
566
- <summary>{m().workflowInterface.metaDisclosure}</summary>
567
- <pre>{JSON.stringify(entry.meta, null, 2)}</pre>
568
- </details>
569
- {/if}
570
- </div>
571
-
572
- <button
573
- type="button"
574
- class="wf-interface__remove"
575
- onclick={() => removeEntry(section.key, index)}
576
- aria-label={m().workflowInterface.removeEntry({ id: entry.id })}
577
- >
578
- <Icon icon="heroicons:trash" />
579
- </button>
580
- </li>
286
+ <WorkflowInterfaceEntryCard
287
+ {entry}
288
+ {status}
289
+ {dataTypes}
290
+ direction={section.key}
291
+ candidates={bindablePorts(section.key)}
292
+ footerIssues={footerIssues(section.key, entry.id, status)}
293
+ alreadyConnected={hasIssue(
294
+ section.key,
295
+ entry.id,
296
+ 'interface-input-already-connected'
297
+ )}
298
+ conflictingSource={conflictingSourceLabel(entry)}
299
+ isFirst={index === 0}
300
+ isLast={index === list.length - 1}
301
+ onPatch={(patch: Partial<WorkflowInterfaceEntry>) =>
302
+ patchEntry(section.key, index, patch)}
303
+ onMove={(delta: -1 | 1) => moveEntry(section.key, index, delta)}
304
+ onRemove={() => removeEntry(section.key, index)}
305
+ />
581
306
  {/each}
582
307
  </ul>
583
308
  {/if}
@@ -645,297 +370,4 @@
645
370
  flex-direction: column;
646
371
  gap: var(--fd-space-xs);
647
372
  }
648
-
649
- .wf-interface__entry {
650
- display: flex;
651
- align-items: flex-start;
652
- gap: var(--fd-space-xs);
653
- padding: var(--fd-space-xs);
654
- border: 1px solid var(--fd-border-muted);
655
- border-radius: var(--fd-radius-md);
656
- }
657
-
658
- .wf-interface__entry--error {
659
- border-color: color-mix(in srgb, var(--fd-error) 40%, var(--fd-border-muted));
660
- }
661
-
662
- .wf-interface__reorder {
663
- display: flex;
664
- flex-direction: column;
665
- flex-shrink: 0;
666
- }
667
-
668
- .wf-interface__reorder button {
669
- display: flex;
670
- align-items: center;
671
- justify-content: center;
672
- padding: 0;
673
- border: none;
674
- background: none;
675
- color: var(--fd-muted-foreground);
676
- cursor: pointer;
677
- }
678
-
679
- .wf-interface__reorder button:disabled {
680
- opacity: 0.3;
681
- cursor: default;
682
- }
683
-
684
- .wf-interface__fields {
685
- flex: 1;
686
- min-width: 0;
687
- display: flex;
688
- flex-direction: column;
689
- gap: var(--fd-space-xs);
690
- }
691
-
692
- .wf-interface__row {
693
- display: flex;
694
- flex-wrap: wrap;
695
- gap: var(--fd-space-xs);
696
- }
697
-
698
- .wf-interface__field {
699
- display: flex;
700
- flex-direction: column;
701
- gap: 0.125rem;
702
- flex: 1;
703
- min-width: 6rem;
704
- }
705
-
706
- .wf-interface__field--id {
707
- flex: 0 0 8rem;
708
- }
709
-
710
- .wf-interface__field--wide {
711
- flex: 1 1 100%;
712
- }
713
-
714
- .wf-interface__field--checkbox {
715
- flex-direction: row;
716
- align-items: center;
717
- gap: 0.375rem;
718
- flex: 0 0 auto;
719
- }
720
-
721
- .wf-interface__label {
722
- font-size: var(--fd-text-xs);
723
- color: var(--fd-muted-foreground);
724
- }
725
-
726
- .wf-interface__field input[type='text'],
727
- .wf-interface__field select {
728
- padding: 0.25rem 0.375rem;
729
- border: 1px solid var(--fd-border);
730
- border-radius: var(--fd-radius-sm);
731
- background-color: var(--fd-background);
732
- color: var(--fd-foreground);
733
- font-size: var(--fd-text-xs);
734
- }
735
-
736
- /* Selects size to their longest option instead of truncating it. */
737
- .wf-interface__field select {
738
- min-width: 8rem;
739
- width: max-content;
740
- max-width: 100%;
741
- }
742
-
743
- /* Entry health at a glance; the title tooltip carries the words. */
744
- .wf-interface__dot {
745
- flex-shrink: 0;
746
- width: 0.5rem;
747
- height: 0.5rem;
748
- margin-top: 0.5rem;
749
- border-radius: 50%;
750
- background-color: var(--fd-muted-foreground);
751
- }
752
-
753
- .wf-interface__dot--ok {
754
- background-color: var(--fd-success);
755
- }
756
-
757
- .wf-interface__dot--type-mismatch,
758
- .wf-interface__dot--unbound {
759
- background-color: var(--fd-warning);
760
- }
761
-
762
- .wf-interface__dot--dangling,
763
- .wf-interface__dot--hidden,
764
- .wf-interface__dot--over-bound {
765
- background-color: var(--fd-error);
766
- }
767
-
768
- /* Field-anchored feedback: one short line under the field it belongs to. */
769
- .wf-interface__inline {
770
- display: inline-flex;
771
- align-items: baseline;
772
- gap: 0.375rem;
773
- font-size: var(--fd-text-xs);
774
- line-height: 1.4;
775
- }
776
-
777
- .wf-interface__inline--warning {
778
- color: var(--fd-warning);
779
- }
780
-
781
- .wf-interface__inline--error {
782
- color: var(--fd-error);
783
- }
784
-
785
- .wf-interface__quickfix {
786
- padding: 0 0.25rem;
787
- border: 1px solid var(--fd-border);
788
- border-radius: var(--fd-radius-sm);
789
- background-color: var(--fd-background);
790
- color: var(--fd-foreground);
791
- font-size: var(--fd-text-xs);
792
- cursor: pointer;
793
- }
794
-
795
- .wf-interface__quickfix:hover {
796
- background-color: var(--fd-muted);
797
- }
798
-
799
- /* The secondary fields live behind a disclosure so a card's resting state
800
- is just identity + binding. Auto-opened when a field inside needs eyes. */
801
- .wf-interface__more {
802
- font-size: var(--fd-text-xs);
803
- }
804
-
805
- .wf-interface__more > summary {
806
- color: var(--fd-muted-foreground);
807
- cursor: pointer;
808
- user-select: none;
809
- }
810
-
811
- .wf-interface__more[open] > summary {
812
- margin-bottom: var(--fd-space-xs);
813
- }
814
-
815
- .wf-interface__more > :global(.wf-interface__row + .wf-interface__row),
816
- .wf-interface__more .wf-interface__examples {
817
- margin-top: var(--fd-space-xs);
818
- }
819
-
820
- .wf-interface__pull {
821
- display: inline-flex;
822
- align-items: center;
823
- gap: 0.25rem;
824
- align-self: flex-end;
825
- padding: 0.25rem 0.375rem;
826
- border: 1px solid var(--fd-border);
827
- border-radius: var(--fd-radius-sm);
828
- background-color: var(--fd-background);
829
- color: var(--fd-foreground);
830
- font-size: var(--fd-text-xs);
831
- white-space: nowrap;
832
- cursor: pointer;
833
- }
834
-
835
- .wf-interface__pull:hover {
836
- background-color: var(--fd-muted);
837
- }
838
-
839
- .wf-interface__examples {
840
- display: flex;
841
- flex-direction: column;
842
- gap: 0.25rem;
843
- }
844
-
845
- .wf-interface__example-row {
846
- display: flex;
847
- align-items: center;
848
- gap: 0.25rem;
849
- }
850
-
851
- .wf-interface__example-row input {
852
- flex: 1;
853
- padding: 0.25rem 0.375rem;
854
- border: 1px solid var(--fd-border);
855
- border-radius: var(--fd-radius-sm);
856
- background-color: var(--fd-background);
857
- color: var(--fd-foreground);
858
- font-size: var(--fd-text-xs);
859
- }
860
-
861
- .wf-interface__example-remove {
862
- display: inline-flex;
863
- padding: 0.125rem;
864
- border: none;
865
- background: none;
866
- color: var(--fd-muted-foreground);
867
- cursor: pointer;
868
- }
869
-
870
- .wf-interface__example-remove:hover {
871
- color: var(--fd-error);
872
- }
873
-
874
- .wf-interface__example-add {
875
- display: inline-flex;
876
- align-items: center;
877
- gap: 0.25rem;
878
- align-self: flex-start;
879
- padding: 0.125rem 0.25rem;
880
- border: none;
881
- background: none;
882
- color: var(--fd-muted-foreground);
883
- font-size: var(--fd-text-xs);
884
- cursor: pointer;
885
- }
886
-
887
- .wf-interface__example-add:hover {
888
- color: var(--fd-foreground);
889
- }
890
-
891
- .wf-interface__status {
892
- margin: 0;
893
- font-size: var(--fd-text-xs);
894
- line-height: 1.5;
895
- color: var(--fd-muted-foreground);
896
- }
897
-
898
- .wf-interface__status--error,
899
- .wf-interface__status--dangling,
900
- .wf-interface__status--hidden,
901
- .wf-interface__status--over-bound {
902
- color: var(--fd-error);
903
- }
904
-
905
- .wf-interface__status--warning,
906
- .wf-interface__status--unbound,
907
- .wf-interface__status--type-mismatch {
908
- color: var(--fd-warning);
909
- }
910
-
911
- .wf-interface__meta {
912
- font-size: var(--fd-text-xs);
913
- color: var(--fd-muted-foreground);
914
- }
915
-
916
- .wf-interface__meta pre {
917
- margin: 0.25rem 0 0;
918
- padding: 0.375rem;
919
- background: var(--fd-muted);
920
- border-radius: var(--fd-radius-sm);
921
- overflow-x: auto;
922
- }
923
-
924
- .wf-interface__remove {
925
- flex-shrink: 0;
926
- display: flex;
927
- align-items: center;
928
- justify-content: center;
929
- padding: 0.25rem;
930
- border: none;
931
- background: none;
932
- color: var(--fd-muted-foreground);
933
- cursor: pointer;
934
- border-radius: var(--fd-radius-sm);
935
- }
936
-
937
- .wf-interface__remove:hover {
938
- color: var(--fd-error);
939
- background-color: color-mix(in srgb, var(--fd-error) 10%, transparent);
940
- }
941
373
  </style>