@effect-app/vue 2.82.0 → 2.84.0

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.
Files changed (6) hide show
  1. package/CHANGELOG.md +12 -0
  2. package/dist/experimental/commander.d.ts +66 -58
  3. package/dist/experimental/commander.d.ts.map +1 -1
  4. package/dist/experimental/commander.js +31 -4
  5. package/package.json +2 -2
  6. package/src/experimental/commander.ts +333 -252
package/src/experimental/commander.ts CHANGED
@@ -10,7 +10,7 @@ import { type RuntimeFiber } from "effect/Fiber"
10
10
  import { type NoInfer } from "effect/Types"
11
11
  import { isGeneratorFunction, type YieldWrap } from "effect/Utils"
12
12
  import { type FormatXMLElementFn, type PrimitiveType } from "intl-messageformat"
13
- import { computed, type ComputedRef, reactive } from "vue"
13
+ import { computed, type ComputedRef, reactive, ref } from "vue"
14
14
  import { Confirm } from "./confirm.js"
15
15
  import { I18n } from "./intl.js"
16
16
  import { WithToast } from "./withToast.js"
@@ -25,6 +25,7 @@ type FnOptions<I18nCustomKey extends string, State extends IntlRecord | undefine
25
25
  * provided as Command.state tag, so you can access it in the function.
26
26
  */
27
27
  state?: ComputedRef<State> | (() => State)
28
+ disableSharedWaiting?: boolean
28
29
  }
29
30
 
30
31
  type FnOptionsInternal<I18nCustomKey extends string> = {
@@ -91,20 +92,30 @@ export const wrapEmit = <A, Event extends string>(
91
92
  (value: A) => new Promise<void>((resolve) => emit(event, value, resolve))
92
93
 
93
94
  export declare namespace Commander {
94
- export type CommanderBase<RT, Id extends string, I18nKey extends string, State> =
95
- & Commander.Gen<RT, Id, I18nKey>
96
- & Commander.NonGen<RT, Id, I18nKey>
95
+ export type CommanderBase<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> =
96
+ & Commander.Gen<RT, Id, I18nKey, State>
97
+ & Commander.NonGen<RT, Id, I18nKey, State>
97
98
  & Commander.CommandContextLocal<Id, I18nKey>
98
99
  & {
99
100
  state: Context.Tag<`Commander.Command.${Id}.state`, State>
100
101
  }
101
102
 
102
- export type CommanderFn<RT, Id extends string, I18nKey extends string, State> = CommanderBase<RT, Id, I18nKey, State>
103
+ export type CommanderFn<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> =
104
+ CommanderBase<RT, Id, I18nKey, State>
103
105
 
104
- export type CommanderWrap<RT, Id extends string, I18nCustomKey extends string, State, I extends any[], A, E, R> =
106
+ export type CommanderWrap<
107
+ RT,
108
+ Id extends string,
109
+ I18nCustomKey extends string,
110
+ State extends IntlRecord | undefined,
111
+ I extends any[],
112
+ A,
113
+ E,
114
+ R
115
+ > =
105
116
  & CommandContextLocal<Id, I18nCustomKey>
106
- & GenWrap<RT, Id, I18nCustomKey, I, A, E, R>
107
- & NonGenWrap<RT, Id, I18nCustomKey, I, A, E, R>
117
+ & GenWrap<RT, Id, I18nCustomKey, I, A, E, R, State>
118
+ & NonGenWrap<RT, Id, I18nCustomKey, I, A, E, R, State>
108
119
  & {
109
120
  state: Context.Tag<`Commander.Command.${Id}.state`, State>
110
121
  }
@@ -116,18 +127,34 @@ export declare namespace Commander {
116
127
  namespaced: <K extends string>(k: K) => `action.${I18nKey}.${K}`
117
128
  }
118
129
 
119
- export interface CommandProps<A, E, Id extends string, I18nKey extends string>
120
- extends CommandContextLocal<Id, I18nKey>
121
- {
130
+ export interface CommandProps<
131
+ A,
132
+ E,
133
+ Id extends string,
134
+ I18nKey extends string,
135
+ State extends IntlRecord | undefined
136
+ > extends CommandContextLocal<Id, I18nKey> {
137
+ /** reactive */
122
138
  action: string
139
+ /** reactive */
123
140
  label: string
141
+ /** reactive */
124
142
  result: Result<A, E>
143
+ /** reactive */
125
144
  waiting: boolean
145
+ /** reactive */
146
+ state: ComputedRef<State>
126
147
  }
127
148
 
128
- export interface CommandOut<Args extends Array<unknown>, A, E, R, Id extends string, I18nKey extends string>
129
- extends CommandProps<A, E, Id, I18nKey>
130
- {
149
+ export interface CommandOut<
150
+ Args extends Array<unknown>,
151
+ A,
152
+ E,
153
+ R,
154
+ Id extends string,
155
+ I18nKey extends string,
156
+ State extends IntlRecord | undefined
157
+ > extends CommandProps<A, E, Id, I18nKey, State> {
131
158
  new(): {}
132
159
 
133
160
  /** click handlers */
@@ -156,17 +183,19 @@ export declare namespace Commander {
156
183
  Args extends Array<unknown>,
157
184
  Eff extends Effect.Effect<any, any, any>,
158
185
  Id extends string,
159
- I18nKey extends string
186
+ I18nKey extends string,
187
+ State extends IntlRecord | undefined
160
188
  > = CommandOut<
161
189
  Args,
162
190
  Effect.Effect.Success<Eff>,
163
191
  Effect.Effect.Error<Eff>,
164
192
  Effect.Effect.Context<Eff>,
165
193
  Id,
166
- I18nKey
194
+ I18nKey,
195
+ State
167
196
  >
168
197
 
169
- export type Gen<RT, Id extends string, I18nKey extends string> = {
198
+ export type Gen<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> = {
170
199
  <
171
200
  Eff extends YieldWrap<Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>,
172
201
  AEff,
@@ -183,7 +212,8 @@ export declare namespace Commander {
183
212
  : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
184
213
  : never,
185
214
  Id,
186
- I18nKey
215
+ I18nKey,
216
+ State
187
217
  >
188
218
  <
189
219
  Eff extends YieldWrap<Effect.Effect<any, any, any>>,
@@ -204,7 +234,7 @@ export declare namespace Commander {
204
234
  >,
205
235
  ...args: NoInfer<Args>
206
236
  ) => A
207
- ): CommandOutHelper<Args, A, Id, I18nKey>
237
+ ): CommandOutHelper<Args, A, Id, I18nKey, State>
208
238
  <
209
239
  Eff extends YieldWrap<Effect.Effect<any, any, any>>,
210
240
  AEff,
@@ -226,7 +256,7 @@ export declare namespace Commander {
226
256
  ...args: NoInfer<Args>
227
257
  ) => A,
228
258
  b: (_: A, ...args: NoInfer<Args>) => B
229
- ): CommandOutHelper<Args, B, Id, I18nKey>
259
+ ): CommandOutHelper<Args, B, Id, I18nKey, State>
230
260
  <
231
261
  Eff extends YieldWrap<Effect.Effect<any, any, any>>,
232
262
  AEff,
@@ -250,7 +280,7 @@ export declare namespace Commander {
250
280
  ) => A,
251
281
  b: (_: A, ...args: NoInfer<Args>) => B,
252
282
  c: (_: B, ...args: NoInfer<Args>) => C
253
- ): CommandOutHelper<Args, C, Id, I18nKey>
283
+ ): CommandOutHelper<Args, C, Id, I18nKey, State>
254
284
  <
255
285
  Eff extends YieldWrap<Effect.Effect<any, any, any>>,
256
286
  AEff,
@@ -276,7 +306,7 @@ export declare namespace Commander {
276
306
  b: (_: A, ...args: NoInfer<Args>) => B,
277
307
  c: (_: B, ...args: NoInfer<Args>) => C,
278
308
  d: (_: C, ...args: NoInfer<Args>) => D
279
- ): CommandOutHelper<Args, D, Id, I18nKey>
309
+ ): CommandOutHelper<Args, D, Id, I18nKey, State>
280
310
  <
281
311
  Eff extends YieldWrap<Effect.Effect<any, any, any>>,
282
312
  AEff,
@@ -304,7 +334,7 @@ export declare namespace Commander {
304
334
  c: (_: B, ...args: NoInfer<Args>) => C,
305
335
  d: (_: C, ...args: NoInfer<Args>) => D,
306
336
  e: (_: D, ...args: NoInfer<Args>) => E
307
- ): CommandOutHelper<Args, E, Id, I18nKey>
337
+ ): CommandOutHelper<Args, E, Id, I18nKey, State>
308
338
  <
309
339
  Eff extends YieldWrap<Effect.Effect<any, any, any>>,
310
340
  AEff,
@@ -334,7 +364,7 @@ export declare namespace Commander {
334
364
  d: (_: C, ...args: NoInfer<Args>) => D,
335
365
  e: (_: D, ...args: NoInfer<Args>) => E,
336
366
  f: (_: E, ...args: NoInfer<Args>) => F
337
- ): CommandOutHelper<Args, F, Id, I18nKey>
367
+ ): CommandOutHelper<Args, F, Id, I18nKey, State>
338
368
  <
339
369
  Eff extends YieldWrap<Effect.Effect<any, any, any>>,
340
370
  AEff,
@@ -366,7 +396,7 @@ export declare namespace Commander {
366
396
  e: (_: D, ...args: NoInfer<Args>) => E,
367
397
  f: (_: E, ...args: NoInfer<Args>) => F,
368
398
  g: (_: F, ...args: NoInfer<Args>) => G
369
- ): CommandOutHelper<Args, G, Id, I18nKey>
399
+ ): CommandOutHelper<Args, G, Id, I18nKey, State>
370
400
  <
371
401
  Eff extends YieldWrap<Effect.Effect<any, any, any>>,
372
402
  AEff,
@@ -400,7 +430,7 @@ export declare namespace Commander {
400
430
  f: (_: E, ...args: NoInfer<Args>) => F,
401
431
  g: (_: F, ...args: NoInfer<Args>) => G,
402
432
  h: (_: G, ...args: NoInfer<Args>) => H
403
- ): CommandOutHelper<Args, H, Id, I18nKey>
433
+ ): CommandOutHelper<Args, H, Id, I18nKey, State>
404
434
  <
405
435
  Eff extends YieldWrap<Effect.Effect<any, any, any>>,
406
436
  AEff,
@@ -436,16 +466,16 @@ export declare namespace Commander {
436
466
  g: (_: F, ...args: NoInfer<Args>) => G,
437
467
  h: (_: G, ...args: NoInfer<Args>) => H,
438
468
  i: (_: H, ...args: NoInfer<Args>) => I
439
- ): CommandOutHelper<Args, I, Id, I18nKey>
469
+ ): CommandOutHelper<Args, I, Id, I18nKey, State>
440
470
  }
441
471
 
442
- export type NonGen<RT, Id extends string, I18nKey extends string> = {
472
+ export type NonGen<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> = {
443
473
  <
444
474
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
445
475
  Args extends Array<unknown>
446
476
  >(
447
477
  body: (...args: Args) => Eff
448
- ): CommandOutHelper<Args, Eff, Id, I18nKey>
478
+ ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
449
479
  <
450
480
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
451
481
  A,
@@ -453,7 +483,7 @@ export declare namespace Commander {
453
483
  >(
454
484
  body: (...args: Args) => A,
455
485
  a: (_: A, ...args: NoInfer<Args>) => Eff
456
- ): CommandOutHelper<Args, Eff, Id, I18nKey>
486
+ ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
457
487
  <
458
488
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
459
489
  A,
@@ -463,7 +493,7 @@ export declare namespace Commander {
463
493
  body: (...args: Args) => A,
464
494
  a: (_: A, ...args: NoInfer<Args>) => B,
465
495
  b: (_: B, ...args: NoInfer<Args>) => Eff
466
- ): CommandOutHelper<Args, Eff, Id, I18nKey>
496
+ ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
467
497
  <
468
498
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
469
499
  A,
@@ -475,7 +505,7 @@ export declare namespace Commander {
475
505
  a: (_: A, ...args: NoInfer<Args>) => B,
476
506
  b: (_: B, ...args: NoInfer<Args>) => C,
477
507
  c: (_: C, ...args: NoInfer<Args>) => Eff
478
- ): CommandOutHelper<Args, Eff, Id, I18nKey>
508
+ ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
479
509
  <
480
510
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
481
511
  A,
@@ -489,7 +519,7 @@ export declare namespace Commander {
489
519
  b: (_: B, ...args: NoInfer<Args>) => C,
490
520
  c: (_: C, ...args: NoInfer<Args>) => D,
491
521
  d: (_: D, ...args: NoInfer<Args>) => Eff
492
- ): CommandOutHelper<Args, Eff, Id, I18nKey>
522
+ ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
493
523
  <
494
524
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
495
525
  A,
@@ -505,7 +535,7 @@ export declare namespace Commander {
505
535
  c: (_: C, ...args: NoInfer<Args>) => D,
506
536
  d: (_: D, ...args: NoInfer<Args>) => E,
507
537
  e: (_: E, ...args: NoInfer<Args>) => Eff
508
- ): CommandOutHelper<Args, Eff, Id, I18nKey>
538
+ ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
509
539
  <
510
540
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
511
541
  A,
@@ -523,7 +553,7 @@ export declare namespace Commander {
523
553
  d: (_: D, ...args: NoInfer<Args>) => E,
524
554
  e: (_: E, ...args: NoInfer<Args>) => F,
525
555
  f: (_: F, ...args: NoInfer<Args>) => Eff
526
- ): CommandOutHelper<Args, Eff, Id, I18nKey>
556
+ ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
527
557
  <
528
558
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
529
559
  A,
@@ -543,7 +573,7 @@ export declare namespace Commander {
543
573
  e: (_: E, ...args: NoInfer<Args>) => F,
544
574
  f: (_: F, ...args: NoInfer<Args>) => G,
545
575
  g: (_: G, ...args: NoInfer<Args>) => Eff
546
- ): CommandOutHelper<Args, Eff, Id, I18nKey>
576
+ ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
547
577
  <
548
578
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
549
579
  A,
@@ -565,7 +595,7 @@ export declare namespace Commander {
565
595
  f: (_: F, ...args: NoInfer<Args>) => G,
566
596
  g: (_: G, ...args: NoInfer<Args>) => H,
567
597
  h: (_: H, ...args: NoInfer<Args>) => Eff
568
- ): CommandOutHelper<Args, Eff, Id, I18nKey>
598
+ ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
569
599
  <
570
600
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
571
601
  A,
@@ -589,17 +619,27 @@ export declare namespace Commander {
589
619
  g: (_: G, ...args: NoInfer<Args>) => H,
590
620
  h: (_: H, ...args: NoInfer<Args>) => I,
591
621
  i: (_: H, ...args: NoInfer<Args>) => Eff
592
- ): CommandOutHelper<Args, Eff, Id, I18nKey>
622
+ ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
593
623
  }
594
624
 
595
- export type GenWrap<RT, Id extends string, I18nKey extends string, Args extends Array<unknown>, AEff, EEff, REff> = {
625
+ export type GenWrap<
626
+ RT,
627
+ Id extends string,
628
+ I18nKey extends string,
629
+ Args extends Array<unknown>,
630
+ AEff,
631
+ EEff,
632
+ REff,
633
+ State extends IntlRecord | undefined
634
+ > = {
596
635
  (): Exclude<REff, RT> extends never ? CommandOut<
597
636
  Args,
598
637
  AEff,
599
638
  EEff,
600
639
  REff,
601
640
  Id,
602
- I18nKey
641
+ I18nKey,
642
+ State
603
643
  >
604
644
  : MissingDependencies<RT, REff> & {}
605
645
  <
@@ -613,7 +653,7 @@ export declare namespace Commander {
613
653
  >,
614
654
  ...args: NoInfer<Args>
615
655
  ) => A
616
- ): CommandOutHelper<Args, A, Id, I18nKey>
656
+ ): CommandOutHelper<Args, A, Id, I18nKey, State>
617
657
  <
618
658
  A,
619
659
  B extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
@@ -627,7 +667,7 @@ export declare namespace Commander {
627
667
  ...args: NoInfer<Args>
628
668
  ) => A,
629
669
  b: (_: A, ...args: NoInfer<Args>) => B
630
- ): CommandOutHelper<Args, B, Id, I18nKey>
670
+ ): CommandOutHelper<Args, B, Id, I18nKey, State>
631
671
  <
632
672
  A,
633
673
  B,
@@ -643,7 +683,7 @@ export declare namespace Commander {
643
683
  ) => A,
644
684
  b: (_: A, ...args: NoInfer<Args>) => B,
645
685
  c: (_: B, ...args: NoInfer<Args>) => C
646
- ): CommandOutHelper<Args, C, Id, I18nKey>
686
+ ): CommandOutHelper<Args, C, Id, I18nKey, State>
647
687
  <
648
688
  A,
649
689
  B,
@@ -661,7 +701,7 @@ export declare namespace Commander {
661
701
  b: (_: A, ...args: NoInfer<Args>) => B,
662
702
  c: (_: B, ...args: NoInfer<Args>) => C,
663
703
  d: (_: C, ...args: NoInfer<Args>) => D
664
- ): CommandOutHelper<Args, D, Id, I18nKey>
704
+ ): CommandOutHelper<Args, D, Id, I18nKey, State>
665
705
  <
666
706
  A,
667
707
  B,
@@ -681,7 +721,7 @@ export declare namespace Commander {
681
721
  c: (_: B, ...args: NoInfer<Args>) => C,
682
722
  d: (_: C, ...args: NoInfer<Args>) => D,
683
723
  e: (_: D, ...args: NoInfer<Args>) => E
684
- ): CommandOutHelper<Args, E, Id, I18nKey>
724
+ ): CommandOutHelper<Args, E, Id, I18nKey, State>
685
725
  <
686
726
  A,
687
727
  B,
@@ -703,7 +743,7 @@ export declare namespace Commander {
703
743
  d: (_: C, ...args: NoInfer<Args>) => D,
704
744
  e: (_: D, ...args: NoInfer<Args>) => E,
705
745
  f: (_: E, ...args: NoInfer<Args>) => F
706
- ): CommandOutHelper<Args, F, Id, I18nKey>
746
+ ): CommandOutHelper<Args, F, Id, I18nKey, State>
707
747
  <
708
748
  A,
709
749
  B,
@@ -727,7 +767,7 @@ export declare namespace Commander {
727
767
  e: (_: D, ...args: NoInfer<Args>) => E,
728
768
  f: (_: E, ...args: NoInfer<Args>) => F,
729
769
  g: (_: F, ...args: NoInfer<Args>) => G
730
- ): CommandOutHelper<Args, G, Id, I18nKey>
770
+ ): CommandOutHelper<Args, G, Id, I18nKey, State>
731
771
  <A, B, C, D, E, F, G, H extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>(
732
772
  a: (
733
773
  _: Effect.Effect<
@@ -744,7 +784,7 @@ export declare namespace Commander {
744
784
  f: (_: E, ...args: NoInfer<Args>) => F,
745
785
  g: (_: F, ...args: NoInfer<Args>) => G,
746
786
  h: (_: G, ...args: NoInfer<Args>) => H
747
- ): CommandOutHelper<Args, H, Id, I18nKey>
787
+ ): CommandOutHelper<Args, H, Id, I18nKey, State>
748
788
  <A, B, C, D, E, F, G, H, I extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>(
749
789
  a: (
750
790
  _: Effect.Effect<
@@ -762,203 +802,211 @@ export declare namespace Commander {
762
802
  g: (_: F, ...args: NoInfer<Args>) => G,
763
803
  h: (_: G, ...args: NoInfer<Args>) => H,
764
804
  i: (_: H, ...args: NoInfer<Args>) => I
765
- ): CommandOutHelper<Args, I, Id, I18nKey>
805
+ ): CommandOutHelper<Args, I, Id, I18nKey, State>
766
806
  }
767
807
 
768
- export type NonGenWrap<RT, Id extends string, I18nKey extends string, Args extends Array<unknown>, AEff, EEff, REff> =
769
- {
770
- (): Exclude<REff, RT> extends never ? CommandOutHelper<Args, Effect.Effect<AEff, EEff, REff>, Id, I18nKey>
771
- : MissingDependencies<RT, REff> & {}
772
- <
773
- Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
774
- Args extends Array<unknown>
775
- >(
776
- a: (
777
- _: Effect.Effect<
778
- AEff,
779
- EEff,
780
- REff
781
- >,
782
- ...args: NoInfer<Args>
783
- ) => Eff
784
- ): CommandOutHelper<Args, Eff, Id, I18nKey>
785
- <
786
- Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
787
- B,
788
- Args extends Array<unknown>
789
- >(
790
- a: (
791
- _: Effect.Effect<
792
- AEff,
793
- EEff,
794
- REff
795
- >,
796
- ...args: NoInfer<Args>
797
- ) => B,
798
- b: (_: B, ...args: NoInfer<Args>) => Eff
799
- ): CommandOutHelper<Args, Eff, Id, I18nKey>
800
- <
801
- Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
802
- B,
803
- C,
804
- Args extends Array<unknown>
805
- >(
806
- a: (
807
- _: Effect.Effect<
808
- AEff,
809
- EEff,
810
- REff
811
- >,
812
- ...args: NoInfer<Args>
813
- ) => B,
814
- b: (_: B, ...args: NoInfer<Args>) => C,
815
- c: (_: C, ...args: NoInfer<Args>) => Eff
816
- ): CommandOutHelper<Args, Eff, Id, I18nKey>
817
- <
818
- Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
819
- B,
820
- C,
821
- D,
822
- Args extends Array<unknown>
823
- >(
824
- a: (
825
- _: Effect.Effect<
826
- AEff,
827
- EEff,
828
- REff
829
- >,
830
- ...args: NoInfer<Args>
831
- ) => B,
832
- b: (_: B, ...args: NoInfer<Args>) => C,
833
- c: (_: C, ...args: NoInfer<Args>) => D,
834
- d: (_: D, ...args: NoInfer<Args>) => Eff
835
- ): CommandOutHelper<Args, Eff, Id, I18nKey>
836
- <
837
- Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
838
- B,
839
- C,
840
- D,
841
- E,
842
- Args extends Array<unknown>
843
- >(
844
- a: (
845
- _: Effect.Effect<
846
- AEff,
847
- EEff,
848
- REff
849
- >,
850
- ...args: NoInfer<Args>
851
- ) => B,
852
- b: (_: B, ...args: NoInfer<Args>) => C,
853
- c: (_: C, ...args: NoInfer<Args>) => D,
854
- d: (_: D, ...args: NoInfer<Args>) => E,
855
- e: (_: E, ...args: NoInfer<Args>) => Eff
856
- ): CommandOutHelper<Args, Eff, Id, I18nKey>
857
- <
858
- Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
859
- B,
860
- C,
861
- D,
862
- E,
863
- F,
864
- Args extends Array<unknown>
865
- >(
866
- a: (
867
- _: Effect.Effect<
868
- AEff,
869
- EEff,
870
- REff
871
- >,
872
- ...args: NoInfer<Args>
873
- ) => B,
874
- b: (_: B, ...args: NoInfer<Args>) => C,
875
- c: (_: C, ...args: NoInfer<Args>) => D,
876
- d: (_: D, ...args: NoInfer<Args>) => E,
877
- e: (_: E, ...args: NoInfer<Args>) => F,
878
- f: (_: F, ...args: NoInfer<Args>) => Eff
879
- ): CommandOutHelper<Args, Eff, Id, I18nKey>
880
- <
881
- Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
882
- B,
883
- C,
884
- D,
885
- E,
886
- F,
887
- G,
888
- Args extends Array<unknown>
889
- >(
890
- a: (
891
- _: Effect.Effect<
892
- AEff,
893
- EEff,
894
- REff
895
- >,
896
- ...args: NoInfer<Args>
897
- ) => B,
898
- b: (_: B, ...args: NoInfer<Args>) => C,
899
- c: (_: C, ...args: NoInfer<Args>) => D,
900
- d: (_: D, ...args: NoInfer<Args>) => E,
901
- e: (_: E, ...args: NoInfer<Args>) => F,
902
- f: (_: F, ...args: NoInfer<Args>) => G,
903
- g: (_: G, ...args: NoInfer<Args>) => Eff
904
- ): CommandOutHelper<Args, Eff, Id, I18nKey>
905
- <
906
- Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
907
- B,
908
- C,
909
- D,
910
- E,
911
- F,
912
- G,
913
- H,
914
- Args extends Array<unknown>
915
- >(
916
- a: (
917
- _: Effect.Effect<
918
- AEff,
919
- EEff,
920
- REff
921
- >,
922
- ...args: NoInfer<Args>
923
- ) => B,
924
- b: (_: B, ...args: NoInfer<Args>) => C,
925
- c: (_: C, ...args: NoInfer<Args>) => D,
926
- d: (_: D, ...args: NoInfer<Args>) => E,
927
- e: (_: E, ...args: NoInfer<Args>) => F,
928
- f: (_: F, ...args: NoInfer<Args>) => G,
929
- g: (_: G, ...args: NoInfer<Args>) => H,
930
- h: (_: H, ...args: NoInfer<Args>) => Eff
931
- ): CommandOutHelper<Args, Eff, Id, I18nKey>
932
- <
933
- Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
934
- B,
935
- C,
936
- D,
937
- E,
938
- F,
939
- G,
940
- H,
941
- I,
942
- Args extends Array<unknown>
943
- >(
944
- a: (
945
- _: Effect.Effect<
946
- AEff,
947
- EEff,
948
- REff
949
- >,
950
- ...args: NoInfer<Args>
951
- ) => B,
952
- b: (_: B, ...args: NoInfer<Args>) => C,
953
- c: (_: C, ...args: NoInfer<Args>) => D,
954
- d: (_: D, ...args: NoInfer<Args>) => E,
955
- e: (_: E, ...args: NoInfer<Args>) => F,
956
- f: (_: F, ...args: NoInfer<Args>) => G,
957
- g: (_: G, ...args: NoInfer<Args>) => H,
958
- h: (_: H, ...args: NoInfer<Args>) => I,
959
- i: (_: H, ...args: NoInfer<Args>) => Eff
960
- ): CommandOutHelper<Args, Eff, Id, I18nKey>
961
- }
808
+ export type NonGenWrap<
809
+ RT,
810
+ Id extends string,
811
+ I18nKey extends string,
812
+ Args extends Array<unknown>,
813
+ AEff,
814
+ EEff,
815
+ REff,
816
+ State extends IntlRecord | undefined
817
+ > = {
818
+ (): Exclude<REff, RT> extends never ? CommandOutHelper<Args, Effect.Effect<AEff, EEff, REff>, Id, I18nKey, State>
819
+ : MissingDependencies<RT, REff> & {}
820
+ <
821
+ Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
822
+ Args extends Array<unknown>
823
+ >(
824
+ a: (
825
+ _: Effect.Effect<
826
+ AEff,
827
+ EEff,
828
+ REff
829
+ >,
830
+ ...args: NoInfer<Args>
831
+ ) => Eff
832
+ ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
833
+ <
834
+ Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
835
+ B,
836
+ Args extends Array<unknown>
837
+ >(
838
+ a: (
839
+ _: Effect.Effect<
840
+ AEff,
841
+ EEff,
842
+ REff
843
+ >,
844
+ ...args: NoInfer<Args>
845
+ ) => B,
846
+ b: (_: B, ...args: NoInfer<Args>) => Eff
847
+ ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
848
+ <
849
+ Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
850
+ B,
851
+ C,
852
+ Args extends Array<unknown>
853
+ >(
854
+ a: (
855
+ _: Effect.Effect<
856
+ AEff,
857
+ EEff,
858
+ REff
859
+ >,
860
+ ...args: NoInfer<Args>
861
+ ) => B,
862
+ b: (_: B, ...args: NoInfer<Args>) => C,
863
+ c: (_: C, ...args: NoInfer<Args>) => Eff
864
+ ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
865
+ <
866
+ Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
867
+ B,
868
+ C,
869
+ D,
870
+ Args extends Array<unknown>
871
+ >(
872
+ a: (
873
+ _: Effect.Effect<
874
+ AEff,
875
+ EEff,
876
+ REff
877
+ >,
878
+ ...args: NoInfer<Args>
879
+ ) => B,
880
+ b: (_: B, ...args: NoInfer<Args>) => C,
881
+ c: (_: C, ...args: NoInfer<Args>) => D,
882
+ d: (_: D, ...args: NoInfer<Args>) => Eff
883
+ ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
884
+ <
885
+ Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
886
+ B,
887
+ C,
888
+ D,
889
+ E,
890
+ Args extends Array<unknown>
891
+ >(
892
+ a: (
893
+ _: Effect.Effect<
894
+ AEff,
895
+ EEff,
896
+ REff
897
+ >,
898
+ ...args: NoInfer<Args>
899
+ ) => B,
900
+ b: (_: B, ...args: NoInfer<Args>) => C,
901
+ c: (_: C, ...args: NoInfer<Args>) => D,
902
+ d: (_: D, ...args: NoInfer<Args>) => E,
903
+ e: (_: E, ...args: NoInfer<Args>) => Eff
904
+ ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
905
+ <
906
+ Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
907
+ B,
908
+ C,
909
+ D,
910
+ E,
911
+ F,
912
+ Args extends Array<unknown>
913
+ >(
914
+ a: (
915
+ _: Effect.Effect<
916
+ AEff,
917
+ EEff,
918
+ REff
919
+ >,
920
+ ...args: NoInfer<Args>
921
+ ) => B,
922
+ b: (_: B, ...args: NoInfer<Args>) => C,
923
+ c: (_: C, ...args: NoInfer<Args>) => D,
924
+ d: (_: D, ...args: NoInfer<Args>) => E,
925
+ e: (_: E, ...args: NoInfer<Args>) => F,
926
+ f: (_: F, ...args: NoInfer<Args>) => Eff
927
+ ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
928
+ <
929
+ Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
930
+ B,
931
+ C,
932
+ D,
933
+ E,
934
+ F,
935
+ G,
936
+ Args extends Array<unknown>
937
+ >(
938
+ a: (
939
+ _: Effect.Effect<
940
+ AEff,
941
+ EEff,
942
+ REff
943
+ >,
944
+ ...args: NoInfer<Args>
945
+ ) => B,
946
+ b: (_: B, ...args: NoInfer<Args>) => C,
947
+ c: (_: C, ...args: NoInfer<Args>) => D,
948
+ d: (_: D, ...args: NoInfer<Args>) => E,
949
+ e: (_: E, ...args: NoInfer<Args>) => F,
950
+ f: (_: F, ...args: NoInfer<Args>) => G,
951
+ g: (_: G, ...args: NoInfer<Args>) => Eff
952
+ ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
953
+ <
954
+ Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
955
+ B,
956
+ C,
957
+ D,
958
+ E,
959
+ F,
960
+ G,
961
+ H,
962
+ Args extends Array<unknown>
963
+ >(
964
+ a: (
965
+ _: Effect.Effect<
966
+ AEff,
967
+ EEff,
968
+ REff
969
+ >,
970
+ ...args: NoInfer<Args>
971
+ ) => B,
972
+ b: (_: B, ...args: NoInfer<Args>) => C,
973
+ c: (_: C, ...args: NoInfer<Args>) => D,
974
+ d: (_: D, ...args: NoInfer<Args>) => E,
975
+ e: (_: E, ...args: NoInfer<Args>) => F,
976
+ f: (_: F, ...args: NoInfer<Args>) => G,
977
+ g: (_: G, ...args: NoInfer<Args>) => H,
978
+ h: (_: H, ...args: NoInfer<Args>) => Eff
979
+ ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
980
+ <
981
+ Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
982
+ B,
983
+ C,
984
+ D,
985
+ E,
986
+ F,
987
+ G,
988
+ H,
989
+ I,
990
+ Args extends Array<unknown>
991
+ >(
992
+ a: (
993
+ _: Effect.Effect<
994
+ AEff,
995
+ EEff,
996
+ REff
997
+ >,
998
+ ...args: NoInfer<Args>
999
+ ) => B,
1000
+ b: (_: B, ...args: NoInfer<Args>) => C,
1001
+ c: (_: C, ...args: NoInfer<Args>) => D,
1002
+ d: (_: D, ...args: NoInfer<Args>) => E,
1003
+ e: (_: E, ...args: NoInfer<Args>) => F,
1004
+ f: (_: F, ...args: NoInfer<Args>) => G,
1005
+ g: (_: G, ...args: NoInfer<Args>) => H,
1006
+ h: (_: H, ...args: NoInfer<Args>) => I,
1007
+ i: (_: H, ...args: NoInfer<Args>) => Eff
1008
+ ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
1009
+ }
962
1010
  }
963
1011
 
964
1012
  type ErrorRenderer<E, Args extends readonly any[]> = (e: E, action: string, ...args: Args) => string | undefined
@@ -1162,6 +1210,21 @@ const makeBaseInfo = <const Id extends string, const I18nKey extends string = Id
1162
1210
  return context
1163
1211
  }
1164
1212
 
1213
+ const waitState = ref<Record<string, number>>({})
1214
+ const registerWait = (id: string) => {
1215
+ // console.debug("register wait", id)
1216
+ waitState.value[id] = waitState.value[id] ? waitState.value[id] + 1 : 1
1217
+ }
1218
+ const unregisterWait = (id: string) => {
1219
+ // console.debug("unregister wait", id)
1220
+ if (waitState.value[id]) {
1221
+ waitState.value[id] = waitState.value[id] - 1
1222
+ if (waitState.value[id] <= 0) {
1223
+ delete waitState.value[id]
1224
+ }
1225
+ }
1226
+ }
1227
+
1165
1228
  const getStateValues = <const I18nKey extends string, State extends IntlRecord | undefined>(
1166
1229
  options?: FnOptions<I18nKey, State>
1167
1230
  ): ComputedRef<State> => {
@@ -1299,9 +1362,20 @@ export class CommanderImpl<RT> {
1299
1362
  )
1300
1363
  )
1301
1364
 
1302
- const [result, exec] = asResult(theHandler)
1303
-
1304
- const waiting = computed(() => result.value.waiting)
1365
+ const [result, exec_] = asResult(theHandler)
1366
+ // probably could be nice to use a namespaced, computable wait key instead not unlike query invalidation?
1367
+ // ["Something.Update", { id }] for instance
1368
+ const exec = options?.disableSharedWaiting
1369
+ ? exec_
1370
+ : Effect
1371
+ .fnUntraced(function*(...args: Args) {
1372
+ registerWait(id)
1373
+ return yield* exec_(...args)
1374
+ }, Effect.onExit(() => Effect.sync(() => unregisterWait(id))))
1375
+
1376
+ const waiting = options?.disableSharedWaiting
1377
+ ? computed(() => result.value.waiting)
1378
+ : computed(() => result.value.waiting || (waitState.value[id] ?? 0) > 0)
1305
1379
 
1306
1380
  const handle = Object.assign((...args: Args) => {
1307
1381
  // we capture the call site stack here
@@ -1375,6 +1449,8 @@ export class CommanderImpl<RT> {
1375
1449
  action,
1376
1450
  /** reactive */
1377
1451
  label,
1452
+ /** reactive */
1453
+ state,
1378
1454
 
1379
1455
  handle
1380
1456
  })
@@ -1468,7 +1544,7 @@ export class CommanderImpl<RT> {
1468
1544
  >(
1469
1545
  id: Id | { id: Id },
1470
1546
  options?: FnOptions<I18nKey, State>
1471
- ): Commander.Gen<RT, Id, I18nKey> & Commander.NonGen<RT, Id, I18nKey> & {
1547
+ ): Commander.Gen<RT, Id, I18nKey, State> & Commander.NonGen<RT, Id, I18nKey, State> & {
1472
1548
  state: Context.Tag<`Commander.Command.${Id}.state`, State>
1473
1549
  } =>
1474
1550
  Object.assign(
@@ -1507,13 +1583,14 @@ export class CommanderImpl<RT> {
1507
1583
  MutA,
1508
1584
  MutE,
1509
1585
  MutR,
1510
- const I18nKey extends string = Id
1586
+ const I18nKey extends string = Id,
1587
+ State extends IntlRecord | undefined = undefined
1511
1588
  >(
1512
1589
  id:
1513
1590
  | Id
1514
1591
  | { id: Id; mutate: (...args: MutArgs) => Effect.Effect<MutA, MutE, MutR> }
1515
1592
  | ((...args: MutArgs) => Effect.Effect<MutA, MutE, MutR>) & { id: Id },
1516
- options?: FnOptions<I18nKey, IntlRecord>
1593
+ options?: FnOptions<I18nKey, State>
1517
1594
  ) =>
1518
1595
  & Commander.CommandContextLocal<Id, I18nKey>
1519
1596
  & (<Args extends Array<unknown>, A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`>(
@@ -1523,7 +1600,7 @@ export class CommanderImpl<RT> {
1523
1600
  mutate: (...args: MutArgs) => Effect.Effect<MutA, MutE, MutR>
1524
1601
  }
1525
1602
  ) => (...args: Args) => Effect.Effect<A, E, R>
1526
- ) => Commander.CommandOut<Args, A, E, R, Id, I18nKey>) = (
1603
+ ) => Commander.CommandOut<Args, A, E, R, Id, I18nKey, State>) = (
1527
1604
  _id,
1528
1605
  options?
1529
1606
  ) => {
@@ -1552,14 +1629,18 @@ export class CommanderImpl<RT> {
1552
1629
  }
1553
1630
 
1554
1631
  /** @experimental */
1555
- alt = this.makeCommand as unknown as <const Id extends string, const I18nKey extends string = Id>(
1632
+ alt = this.makeCommand as unknown as <
1633
+ const Id extends string,
1634
+ const I18nKey extends string = Id,
1635
+ State extends IntlRecord | undefined = undefined
1636
+ >(
1556
1637
  id: Id,
1557
1638
  customI18nKey?: I18nKey
1558
1639
  ) =>
1559
1640
  & Commander.CommandContextLocal<Id, I18nKey>
1560
1641
  & (<Args extends Array<unknown>, A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`>(
1561
1642
  handler: (...args: Args) => Effect.Effect<A, E, R>
1562
- ) => Commander.CommandOut<Args, A, E, R, Id, I18nKey>)
1643
+ ) => Commander.CommandOut<Args, A, E, R, Id, I18nKey, State>)
1563
1644
 
1564
1645
  /**
1565
1646
  * Define a Command for handling user actions with built-in error reporting and state management.