@valentin30/signal 0.0.8 → 0.1.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 (5) hide show
  1. package/dist/index.d.mts +111 -118
  2. package/dist/index.d.ts +111 -118
  3. package/dist/index.js +208 -187
  4. package/dist/index.mjs +208 -187
  5. package/package.json +1 -1
package/dist/index.d.mts CHANGED
@@ -1,41 +1,45 @@
1
- type Function = (...args: any[]) => any;
1
+ type Callable = (...args: any[]) => any;
2
2
 
3
3
  type Maybe<T> = T | null | undefined;
4
4
 
5
- type Factory<Fn extends Function> = Fn & {
5
+ type Factory<Fn extends Callable> = Fn & {
6
6
  factory(factory: Maybe<Fn>): void;
7
7
  default(factory: Maybe<Fn>): void;
8
8
  configured(): boolean;
9
9
  };
10
- declare function factory<Fn extends Function>(name: string): Factory<Fn>;
10
+ declare function factory<Fn extends Callable>(name: string): Factory<Fn>;
11
11
 
12
12
  type Callback = () => void;
13
13
 
14
- interface Collector$1<T> {
14
+ interface Collector<T> {
15
15
  add(value: T): void;
16
16
  collecting(): boolean;
17
17
  collect(callback: Callback): Readonly<Set<T>>;
18
18
  ignore(callback: Callback): void;
19
19
  }
20
- type CollectorFactory = <T>() => Collector$1<T>;
21
- declare const collector$1: Factory<CollectorFactory>;
20
+ type CollectorFactory = <T>() => Collector<T>;
21
+ declare const collector: Factory<CollectorFactory>;
22
22
 
23
- declare function batch$1(callback: Callback): void;
24
- declare function batch$1(callback: Callback, collector: Collector$1<Callback>): void;
25
- declare function batch$1(callback: Callback, collector?: Collector$1<Callback>): void;
26
- declare namespace batch$1 {
27
- var collector: Factory<BatchCollectorFactory>;
23
+ declare function internal_batch(callback: Callback): void;
24
+ declare function internal_batch(callback: Callback, collector: Collector<Callback>): void;
25
+ declare function internal_batch(callback: Callback, collector?: Collector<Callback>): void;
26
+ declare namespace internal_batch {
27
+ const collector: Factory<collector.Factory>;
28
+ namespace collector {
29
+ type Factory = () => Collector<Callback>;
30
+ }
28
31
  }
29
- type BatchCollectorFactory = () => Collector$1<Callback>;
30
32
 
31
- declare function collector<T>(): Collector$1<T>;
32
- declare class Collector<T> implements Collector$1<T> {
33
- #private;
34
- constructor(values: Set<T> | null);
35
- collecting(): boolean;
36
- add(value: T): void;
37
- collect(callback: Callback): Set<T>;
38
- ignore(callback: Callback): void;
33
+ declare function internal_collector<T>(): Collector<T>;
34
+ declare namespace internal_collector {
35
+ class Constructor<T> implements Collector<T> {
36
+ #private;
37
+ constructor(values: Set<T> | null);
38
+ collecting(): boolean;
39
+ add(value: T): void;
40
+ collect(callback: Callback): Set<T>;
41
+ ignore(callback: Callback): void;
42
+ }
39
43
  }
40
44
 
41
45
  interface Comparable<T> {
@@ -61,120 +65,109 @@ interface Peekable<T> {
61
65
  peek(): T;
62
66
  }
63
67
 
64
- interface Signal$1<T> extends Readable<T>, Writable<T>, Peekable<T>, Comparable<T>, Subscribable {
68
+ interface Signal<T> extends Readable<T>, Writable<T>, Peekable<T>, Comparable<T>, Subscribable {
65
69
  }
66
70
  interface ReadonlySignal<T> extends Readable<T>, Peekable<T>, Comparable<T>, Subscribable {
67
71
  }
68
- type SignalFactory = <T>(value: T, equals?: Equals<T>) => Signal$1<T>;
69
- declare const signal$1: Factory<SignalFactory>;
70
-
71
- declare function computed$1<T>(compute: () => T, equals?: Equals<T>): Computed<T>;
72
- declare namespace computed$1 {
73
- var collector: Factory<ComputedCollectorFactory>;
74
- }
75
- type ComputedCollectorFactory = () => Collector$1<ReadonlySignal<unknown>>;
76
- declare class Computed<T> implements ReadonlySignal<T> {
77
- #private;
78
- constructor(empty: boolean, value: T | undefined, values: [ReadonlySignal<unknown>, unknown][], dependencies: Set<ReadonlySignal<unknown>>, listeners: Set<Callback>, collector: Collector$1<ReadonlySignal<unknown>>, compute: () => T, equals: Maybe<Equals<T>>);
79
- read(): T;
80
- peek(): T;
81
- equals(other: T): boolean;
82
- subscribe(callback: Callback): Callback;
83
- unsubscribe(callback: Callback): void;
84
- }
85
-
86
- type ComposedBatcherFactory = () => Collector$1<Callback>;
87
- type ComposedCollectorFactory = () => Collector$1<ReadonlySignal<unknown>>;
88
- declare function composed$1<T>(compute: () => T, write: (value: T) => void, equals?: Equals<T>): Composed<T>;
89
- declare namespace composed$1 {
90
- var batcher: Factory<ComposedBatcherFactory>;
91
- var collector: Factory<ComposedCollectorFactory>;
92
- }
93
- declare class Composed<T> extends Computed<T> implements Signal$1<T> {
94
- #private;
95
- constructor(empty: boolean, value: T | undefined, values: [ReadonlySignal<unknown>, unknown][], dependencies: Set<ReadonlySignal<unknown>>, listeners: Set<Callback>, batcher: Collector$1<Callback>, collector: Collector$1<ReadonlySignal<unknown>>, compute: () => T, write: (value: T) => void, equals: Maybe<Equals<T>>);
96
- write(value: T): void;
72
+ type SignalFactory = <T>(value: T, equals?: Equals<T>) => Signal<T>;
73
+ declare const signal: Factory<SignalFactory>;
74
+
75
+ declare function internal_computed<T>(compute: () => T, equals?: Equals<T>): internal_computed.Constructor<T>;
76
+ declare namespace internal_computed {
77
+ const collector: Factory<collector.Factory>;
78
+ namespace collector {
79
+ type Factory = () => Collector<ReadonlySignal<unknown>>;
80
+ }
81
+ class Constructor<T> implements ReadonlySignal<T> {
82
+ #private;
83
+ constructor(empty: boolean, value: T | undefined, values: [ReadonlySignal<unknown>, unknown][], dependencies: Set<ReadonlySignal<unknown>>, listeners: Set<Callback>, collector: Collector<ReadonlySignal<unknown>>, compute: () => T, equals: Maybe<Equals<T>>);
84
+ read(): T;
85
+ peek(): T;
86
+ equals(other: T): boolean;
87
+ subscribe(callback: Callback): Callback;
88
+ unsubscribe(callback: Callback): void;
89
+ }
90
+ }
91
+
92
+ declare function internal_composed<T>(compute: () => T, write: (value: T) => void, equals?: Equals<T>): internal_composed.Constructor<T>;
93
+ declare namespace internal_composed {
94
+ const batcher: Factory<batcher.Factory>;
95
+ namespace batcher {
96
+ type Factory = () => Collector<Callback>;
97
+ }
98
+ const collector: Factory<collector.Factory>;
99
+ namespace collector {
100
+ type Factory = () => Collector<ReadonlySignal<unknown>>;
101
+ }
102
+ class Constructor<T> extends internal_computed.Constructor<T> implements Signal<T> {
103
+ #private;
104
+ constructor(empty: boolean, value: T | undefined, values: [ReadonlySignal<unknown>, unknown][], dependencies: Set<ReadonlySignal<unknown>>, listeners: Set<Callback>, batcher: Collector<Callback>, collector: Collector<ReadonlySignal<unknown>>, compute: () => T, write: (value: T) => void, equals: Maybe<Equals<T>>);
105
+ write(value: T): void;
106
+ }
97
107
  }
98
108
 
99
109
  type Effect = (callback: EffectCallback) => Callback;
100
110
  type EffectCallback = (init: boolean) => EffectCleanup | void;
101
111
  type EffectCleanup = (destroy: boolean) => void;
102
- declare const effect$1: Factory<Effect>;
103
-
104
- declare function effect(cb: EffectCallback): Callback;
105
- declare namespace effect {
106
- var collector: Factory<EffectCollectorFactory>;
107
- }
108
- type EffectCollectorFactory = () => Collector$1<ReadonlySignal<unknown>>;
109
-
110
- interface Ignore$1 {
111
- <Value>(value: ReadonlySignal<Value>): Value;
112
- <Value>(callback: () => Value): Value;
113
- <Value, Args extends any[]>(callback: (...args: Args) => Value, ...args: Args): Value;
114
- }
115
- declare function ignore$1<Value>(value: ReadonlySignal<Value>): Value;
116
- declare function ignore$1<Value>(callback: () => Value): Value;
117
- declare function ignore$1<Value, Args extends any[]>(callback: (...args: Args) => Value, ...args: Args): Value;
118
- declare namespace ignore$1 {
119
- var collector: Factory<IgnoreCollectorFactory>;
120
- }
121
- type IgnoreCollectorFactory = () => Collector$1<ReadonlySignal<unknown>>;
122
-
123
- declare const shared: {
124
- batcher(): Collector$1<Callback>;
125
- collector(): Collector$1<ReadonlySignal<unknown>>;
126
- };
127
-
128
- type SignalBatcherFactory = () => Collector$1<Callback>;
129
- type SignalCollectorFactory = () => Collector$1<ReadonlySignal<unknown>>;
130
- declare function signal<T>(value: T, equals?: Equals<T>): Signal$1<T>;
131
- declare namespace signal {
132
- var batcher: Factory<SignalBatcherFactory>;
133
- var collector: Factory<SignalCollectorFactory>;
134
- }
135
- declare class Signal<T> implements Signal$1<T> {
136
- #private;
137
- constructor(value: T, equals: Maybe<Equals<T>>, listeners: Set<Callback>, batcher: Collector$1<Callback>, collector: Collector$1<ReadonlySignal<unknown>>);
138
- read(): T;
139
- peek(): T;
140
- write(value: T): void;
141
- equals(other: T): boolean;
142
- subscribe(callback: Callback): Callback;
143
- unsubscribe(callback: Callback): void;
112
+ declare const effect: Factory<Effect>;
113
+
114
+ declare function internal_effect(cb: EffectCallback): Callback;
115
+ declare namespace internal_effect {
116
+ const collector: Factory<collector.Factory>;
117
+ namespace collector {
118
+ type Factory = () => Collector<ReadonlySignal<unknown>>;
119
+ }
120
+ }
121
+
122
+ declare function internal_ignore<Value>(value: ReadonlySignal<Value>): Value;
123
+ declare function internal_ignore<Value>(callback: () => Value): Value;
124
+ declare function internal_ignore<Value, Args extends any[]>(callback: (...args: Args) => Value, ...args: Args): Value;
125
+ declare namespace internal_ignore {
126
+ const collector: Factory<collector.Factory>;
127
+ namespace collector {
128
+ type Factory = () => Collector<ReadonlySignal<unknown>>;
129
+ }
130
+ }
131
+
132
+ declare namespace internal_shared {
133
+ function batcher(): Collector<Callback>;
134
+ function collector(): Collector<ReadonlySignal<unknown>>;
135
+ }
136
+
137
+ declare function internal_signal<T>(value: T, equals?: Equals<T>): Signal<T>;
138
+ declare namespace internal_signal {
139
+ const batcher: Factory<batcher.Factory>;
140
+ namespace batcher {
141
+ type Factory = () => Collector<Callback>;
142
+ }
143
+ const collector: Factory<collector.Factory>;
144
+ namespace collector {
145
+ type Factory = () => Collector<ReadonlySignal<unknown>>;
146
+ }
147
+ class Constructor<T> implements Signal<T> {
148
+ #private;
149
+ constructor(value: T, equals: Maybe<Equals<T>>, listeners: Set<Callback>, batcher: Collector<Callback>, collector: Collector<ReadonlySignal<unknown>>);
150
+ read(): T;
151
+ peek(): T;
152
+ write(value: T): void;
153
+ equals(other: T): boolean;
154
+ subscribe(callback: Callback): Callback;
155
+ unsubscribe(callback: Callback): void;
156
+ }
144
157
  }
145
158
 
146
- type index_BatchCollectorFactory = BatchCollectorFactory;
147
- type index_Collector<T> = Collector<T>;
148
- declare const index_Collector: typeof Collector;
149
- type index_Composed<T> = Composed<T>;
150
- declare const index_Composed: typeof Composed;
151
- type index_ComposedBatcherFactory = ComposedBatcherFactory;
152
- type index_ComposedCollectorFactory = ComposedCollectorFactory;
153
- type index_Computed<T> = Computed<T>;
154
- declare const index_Computed: typeof Computed;
155
- type index_ComputedCollectorFactory = ComputedCollectorFactory;
156
- type index_EffectCollectorFactory = EffectCollectorFactory;
157
- type index_IgnoreCollectorFactory = IgnoreCollectorFactory;
158
- type index_Signal<T> = Signal<T>;
159
- declare const index_Signal: typeof Signal;
160
- type index_SignalBatcherFactory = SignalBatcherFactory;
161
- type index_SignalCollectorFactory = SignalCollectorFactory;
162
- declare const index_collector: typeof collector;
163
- declare const index_effect: typeof effect;
164
- declare const index_shared: typeof shared;
165
- declare const index_signal: typeof signal;
166
159
  declare namespace index {
167
- export { type index_BatchCollectorFactory as BatchCollectorFactory, index_Collector as Collector, index_Composed as Composed, type index_ComposedBatcherFactory as ComposedBatcherFactory, type index_ComposedCollectorFactory as ComposedCollectorFactory, index_Computed as Computed, type index_ComputedCollectorFactory as ComputedCollectorFactory, type index_EffectCollectorFactory as EffectCollectorFactory, type Ignore$1 as Ignore, type index_IgnoreCollectorFactory as IgnoreCollectorFactory, index_Signal as Signal, type index_SignalBatcherFactory as SignalBatcherFactory, type index_SignalCollectorFactory as SignalCollectorFactory, batch$1 as batch, index_collector as collector, composed$1 as composed, computed$1 as computed, index_effect as effect, ignore$1 as ignore, index_shared as shared, index_signal as signal };
160
+ export { internal_batch as batch, internal_collector as collector, internal_composed as composed, internal_computed as computed, internal_effect as effect, internal_ignore as ignore, internal_shared as shared, internal_signal as signal };
168
161
  }
169
162
 
170
163
  interface Batch {
171
164
  (callback: Callback): void;
172
- (callback: Callback, collector: Collector$1<Callback>): void;
173
- (callback: Callback, collector?: Collector$1<Callback>): void;
165
+ (callback: Callback, collector: Collector<Callback>): void;
166
+ (callback: Callback, collector?: Collector<Callback>): void;
174
167
  }
175
168
  declare const batch: Factory<Batch>;
176
169
 
177
- type ComposedFactory = <T>(read: () => T, write: (value: T) => void, equals?: Equals<T>) => Signal$1<T>;
170
+ type ComposedFactory = <T>(read: () => T, write: (value: T) => void, equals?: Equals<T>) => Signal<T>;
178
171
  declare const composed: Factory<ComposedFactory>;
179
172
 
180
173
  type ComputedFactory = <T>(read: () => T, equals?: Equals<T>) => ReadonlySignal<T>;
@@ -194,8 +187,8 @@ interface Config {
194
187
  composed?: Maybe<ComposedFactory>;
195
188
  effect?: Maybe<Effect>;
196
189
  batch?: Maybe<Batch>;
197
- ignore?: Maybe<Ignore$1>;
190
+ ignore?: Maybe<Ignore>;
198
191
  }
199
192
  declare function config(config?: Config): void;
200
193
 
201
- export { type Batch, type Callback, type Collector$1 as Collector, type CollectorFactory, type Comparable, type ComposedFactory, type ComputedFactory, type Config, type Effect, type EffectCallback, type EffectCleanup, type Equals, type Factory, type Function, type Ignore, type Maybe, type Peekable, type Readable, type ReadonlySignal, type Signal$1 as Signal, type SignalFactory, type Subscribable, type Writable, batch, collector$1 as collector, composed, computed, config, effect$1 as effect, factory, ignore, index as internal, signal$1 as signal };
194
+ export { type Batch, type Callable, type Callback, type Collector, type CollectorFactory, type Comparable, type ComposedFactory, type ComputedFactory, type Config, type Effect, type EffectCallback, type EffectCleanup, type Equals, type Factory, type Ignore, type Maybe, type Peekable, type Readable, type ReadonlySignal, type Signal, type SignalFactory, type Subscribable, type Writable, batch, collector, composed, computed, config, effect, factory, ignore, index as internal, signal };
package/dist/index.d.ts CHANGED
@@ -1,41 +1,45 @@
1
- type Function = (...args: any[]) => any;
1
+ type Callable = (...args: any[]) => any;
2
2
 
3
3
  type Maybe<T> = T | null | undefined;
4
4
 
5
- type Factory<Fn extends Function> = Fn & {
5
+ type Factory<Fn extends Callable> = Fn & {
6
6
  factory(factory: Maybe<Fn>): void;
7
7
  default(factory: Maybe<Fn>): void;
8
8
  configured(): boolean;
9
9
  };
10
- declare function factory<Fn extends Function>(name: string): Factory<Fn>;
10
+ declare function factory<Fn extends Callable>(name: string): Factory<Fn>;
11
11
 
12
12
  type Callback = () => void;
13
13
 
14
- interface Collector$1<T> {
14
+ interface Collector<T> {
15
15
  add(value: T): void;
16
16
  collecting(): boolean;
17
17
  collect(callback: Callback): Readonly<Set<T>>;
18
18
  ignore(callback: Callback): void;
19
19
  }
20
- type CollectorFactory = <T>() => Collector$1<T>;
21
- declare const collector$1: Factory<CollectorFactory>;
20
+ type CollectorFactory = <T>() => Collector<T>;
21
+ declare const collector: Factory<CollectorFactory>;
22
22
 
23
- declare function batch$1(callback: Callback): void;
24
- declare function batch$1(callback: Callback, collector: Collector$1<Callback>): void;
25
- declare function batch$1(callback: Callback, collector?: Collector$1<Callback>): void;
26
- declare namespace batch$1 {
27
- var collector: Factory<BatchCollectorFactory>;
23
+ declare function internal_batch(callback: Callback): void;
24
+ declare function internal_batch(callback: Callback, collector: Collector<Callback>): void;
25
+ declare function internal_batch(callback: Callback, collector?: Collector<Callback>): void;
26
+ declare namespace internal_batch {
27
+ const collector: Factory<collector.Factory>;
28
+ namespace collector {
29
+ type Factory = () => Collector<Callback>;
30
+ }
28
31
  }
29
- type BatchCollectorFactory = () => Collector$1<Callback>;
30
32
 
31
- declare function collector<T>(): Collector$1<T>;
32
- declare class Collector<T> implements Collector$1<T> {
33
- #private;
34
- constructor(values: Set<T> | null);
35
- collecting(): boolean;
36
- add(value: T): void;
37
- collect(callback: Callback): Set<T>;
38
- ignore(callback: Callback): void;
33
+ declare function internal_collector<T>(): Collector<T>;
34
+ declare namespace internal_collector {
35
+ class Constructor<T> implements Collector<T> {
36
+ #private;
37
+ constructor(values: Set<T> | null);
38
+ collecting(): boolean;
39
+ add(value: T): void;
40
+ collect(callback: Callback): Set<T>;
41
+ ignore(callback: Callback): void;
42
+ }
39
43
  }
40
44
 
41
45
  interface Comparable<T> {
@@ -61,120 +65,109 @@ interface Peekable<T> {
61
65
  peek(): T;
62
66
  }
63
67
 
64
- interface Signal$1<T> extends Readable<T>, Writable<T>, Peekable<T>, Comparable<T>, Subscribable {
68
+ interface Signal<T> extends Readable<T>, Writable<T>, Peekable<T>, Comparable<T>, Subscribable {
65
69
  }
66
70
  interface ReadonlySignal<T> extends Readable<T>, Peekable<T>, Comparable<T>, Subscribable {
67
71
  }
68
- type SignalFactory = <T>(value: T, equals?: Equals<T>) => Signal$1<T>;
69
- declare const signal$1: Factory<SignalFactory>;
70
-
71
- declare function computed$1<T>(compute: () => T, equals?: Equals<T>): Computed<T>;
72
- declare namespace computed$1 {
73
- var collector: Factory<ComputedCollectorFactory>;
74
- }
75
- type ComputedCollectorFactory = () => Collector$1<ReadonlySignal<unknown>>;
76
- declare class Computed<T> implements ReadonlySignal<T> {
77
- #private;
78
- constructor(empty: boolean, value: T | undefined, values: [ReadonlySignal<unknown>, unknown][], dependencies: Set<ReadonlySignal<unknown>>, listeners: Set<Callback>, collector: Collector$1<ReadonlySignal<unknown>>, compute: () => T, equals: Maybe<Equals<T>>);
79
- read(): T;
80
- peek(): T;
81
- equals(other: T): boolean;
82
- subscribe(callback: Callback): Callback;
83
- unsubscribe(callback: Callback): void;
84
- }
85
-
86
- type ComposedBatcherFactory = () => Collector$1<Callback>;
87
- type ComposedCollectorFactory = () => Collector$1<ReadonlySignal<unknown>>;
88
- declare function composed$1<T>(compute: () => T, write: (value: T) => void, equals?: Equals<T>): Composed<T>;
89
- declare namespace composed$1 {
90
- var batcher: Factory<ComposedBatcherFactory>;
91
- var collector: Factory<ComposedCollectorFactory>;
92
- }
93
- declare class Composed<T> extends Computed<T> implements Signal$1<T> {
94
- #private;
95
- constructor(empty: boolean, value: T | undefined, values: [ReadonlySignal<unknown>, unknown][], dependencies: Set<ReadonlySignal<unknown>>, listeners: Set<Callback>, batcher: Collector$1<Callback>, collector: Collector$1<ReadonlySignal<unknown>>, compute: () => T, write: (value: T) => void, equals: Maybe<Equals<T>>);
96
- write(value: T): void;
72
+ type SignalFactory = <T>(value: T, equals?: Equals<T>) => Signal<T>;
73
+ declare const signal: Factory<SignalFactory>;
74
+
75
+ declare function internal_computed<T>(compute: () => T, equals?: Equals<T>): internal_computed.Constructor<T>;
76
+ declare namespace internal_computed {
77
+ const collector: Factory<collector.Factory>;
78
+ namespace collector {
79
+ type Factory = () => Collector<ReadonlySignal<unknown>>;
80
+ }
81
+ class Constructor<T> implements ReadonlySignal<T> {
82
+ #private;
83
+ constructor(empty: boolean, value: T | undefined, values: [ReadonlySignal<unknown>, unknown][], dependencies: Set<ReadonlySignal<unknown>>, listeners: Set<Callback>, collector: Collector<ReadonlySignal<unknown>>, compute: () => T, equals: Maybe<Equals<T>>);
84
+ read(): T;
85
+ peek(): T;
86
+ equals(other: T): boolean;
87
+ subscribe(callback: Callback): Callback;
88
+ unsubscribe(callback: Callback): void;
89
+ }
90
+ }
91
+
92
+ declare function internal_composed<T>(compute: () => T, write: (value: T) => void, equals?: Equals<T>): internal_composed.Constructor<T>;
93
+ declare namespace internal_composed {
94
+ const batcher: Factory<batcher.Factory>;
95
+ namespace batcher {
96
+ type Factory = () => Collector<Callback>;
97
+ }
98
+ const collector: Factory<collector.Factory>;
99
+ namespace collector {
100
+ type Factory = () => Collector<ReadonlySignal<unknown>>;
101
+ }
102
+ class Constructor<T> extends internal_computed.Constructor<T> implements Signal<T> {
103
+ #private;
104
+ constructor(empty: boolean, value: T | undefined, values: [ReadonlySignal<unknown>, unknown][], dependencies: Set<ReadonlySignal<unknown>>, listeners: Set<Callback>, batcher: Collector<Callback>, collector: Collector<ReadonlySignal<unknown>>, compute: () => T, write: (value: T) => void, equals: Maybe<Equals<T>>);
105
+ write(value: T): void;
106
+ }
97
107
  }
98
108
 
99
109
  type Effect = (callback: EffectCallback) => Callback;
100
110
  type EffectCallback = (init: boolean) => EffectCleanup | void;
101
111
  type EffectCleanup = (destroy: boolean) => void;
102
- declare const effect$1: Factory<Effect>;
103
-
104
- declare function effect(cb: EffectCallback): Callback;
105
- declare namespace effect {
106
- var collector: Factory<EffectCollectorFactory>;
107
- }
108
- type EffectCollectorFactory = () => Collector$1<ReadonlySignal<unknown>>;
109
-
110
- interface Ignore$1 {
111
- <Value>(value: ReadonlySignal<Value>): Value;
112
- <Value>(callback: () => Value): Value;
113
- <Value, Args extends any[]>(callback: (...args: Args) => Value, ...args: Args): Value;
114
- }
115
- declare function ignore$1<Value>(value: ReadonlySignal<Value>): Value;
116
- declare function ignore$1<Value>(callback: () => Value): Value;
117
- declare function ignore$1<Value, Args extends any[]>(callback: (...args: Args) => Value, ...args: Args): Value;
118
- declare namespace ignore$1 {
119
- var collector: Factory<IgnoreCollectorFactory>;
120
- }
121
- type IgnoreCollectorFactory = () => Collector$1<ReadonlySignal<unknown>>;
122
-
123
- declare const shared: {
124
- batcher(): Collector$1<Callback>;
125
- collector(): Collector$1<ReadonlySignal<unknown>>;
126
- };
127
-
128
- type SignalBatcherFactory = () => Collector$1<Callback>;
129
- type SignalCollectorFactory = () => Collector$1<ReadonlySignal<unknown>>;
130
- declare function signal<T>(value: T, equals?: Equals<T>): Signal$1<T>;
131
- declare namespace signal {
132
- var batcher: Factory<SignalBatcherFactory>;
133
- var collector: Factory<SignalCollectorFactory>;
134
- }
135
- declare class Signal<T> implements Signal$1<T> {
136
- #private;
137
- constructor(value: T, equals: Maybe<Equals<T>>, listeners: Set<Callback>, batcher: Collector$1<Callback>, collector: Collector$1<ReadonlySignal<unknown>>);
138
- read(): T;
139
- peek(): T;
140
- write(value: T): void;
141
- equals(other: T): boolean;
142
- subscribe(callback: Callback): Callback;
143
- unsubscribe(callback: Callback): void;
112
+ declare const effect: Factory<Effect>;
113
+
114
+ declare function internal_effect(cb: EffectCallback): Callback;
115
+ declare namespace internal_effect {
116
+ const collector: Factory<collector.Factory>;
117
+ namespace collector {
118
+ type Factory = () => Collector<ReadonlySignal<unknown>>;
119
+ }
120
+ }
121
+
122
+ declare function internal_ignore<Value>(value: ReadonlySignal<Value>): Value;
123
+ declare function internal_ignore<Value>(callback: () => Value): Value;
124
+ declare function internal_ignore<Value, Args extends any[]>(callback: (...args: Args) => Value, ...args: Args): Value;
125
+ declare namespace internal_ignore {
126
+ const collector: Factory<collector.Factory>;
127
+ namespace collector {
128
+ type Factory = () => Collector<ReadonlySignal<unknown>>;
129
+ }
130
+ }
131
+
132
+ declare namespace internal_shared {
133
+ function batcher(): Collector<Callback>;
134
+ function collector(): Collector<ReadonlySignal<unknown>>;
135
+ }
136
+
137
+ declare function internal_signal<T>(value: T, equals?: Equals<T>): Signal<T>;
138
+ declare namespace internal_signal {
139
+ const batcher: Factory<batcher.Factory>;
140
+ namespace batcher {
141
+ type Factory = () => Collector<Callback>;
142
+ }
143
+ const collector: Factory<collector.Factory>;
144
+ namespace collector {
145
+ type Factory = () => Collector<ReadonlySignal<unknown>>;
146
+ }
147
+ class Constructor<T> implements Signal<T> {
148
+ #private;
149
+ constructor(value: T, equals: Maybe<Equals<T>>, listeners: Set<Callback>, batcher: Collector<Callback>, collector: Collector<ReadonlySignal<unknown>>);
150
+ read(): T;
151
+ peek(): T;
152
+ write(value: T): void;
153
+ equals(other: T): boolean;
154
+ subscribe(callback: Callback): Callback;
155
+ unsubscribe(callback: Callback): void;
156
+ }
144
157
  }
145
158
 
146
- type index_BatchCollectorFactory = BatchCollectorFactory;
147
- type index_Collector<T> = Collector<T>;
148
- declare const index_Collector: typeof Collector;
149
- type index_Composed<T> = Composed<T>;
150
- declare const index_Composed: typeof Composed;
151
- type index_ComposedBatcherFactory = ComposedBatcherFactory;
152
- type index_ComposedCollectorFactory = ComposedCollectorFactory;
153
- type index_Computed<T> = Computed<T>;
154
- declare const index_Computed: typeof Computed;
155
- type index_ComputedCollectorFactory = ComputedCollectorFactory;
156
- type index_EffectCollectorFactory = EffectCollectorFactory;
157
- type index_IgnoreCollectorFactory = IgnoreCollectorFactory;
158
- type index_Signal<T> = Signal<T>;
159
- declare const index_Signal: typeof Signal;
160
- type index_SignalBatcherFactory = SignalBatcherFactory;
161
- type index_SignalCollectorFactory = SignalCollectorFactory;
162
- declare const index_collector: typeof collector;
163
- declare const index_effect: typeof effect;
164
- declare const index_shared: typeof shared;
165
- declare const index_signal: typeof signal;
166
159
  declare namespace index {
167
- export { type index_BatchCollectorFactory as BatchCollectorFactory, index_Collector as Collector, index_Composed as Composed, type index_ComposedBatcherFactory as ComposedBatcherFactory, type index_ComposedCollectorFactory as ComposedCollectorFactory, index_Computed as Computed, type index_ComputedCollectorFactory as ComputedCollectorFactory, type index_EffectCollectorFactory as EffectCollectorFactory, type Ignore$1 as Ignore, type index_IgnoreCollectorFactory as IgnoreCollectorFactory, index_Signal as Signal, type index_SignalBatcherFactory as SignalBatcherFactory, type index_SignalCollectorFactory as SignalCollectorFactory, batch$1 as batch, index_collector as collector, composed$1 as composed, computed$1 as computed, index_effect as effect, ignore$1 as ignore, index_shared as shared, index_signal as signal };
160
+ export { internal_batch as batch, internal_collector as collector, internal_composed as composed, internal_computed as computed, internal_effect as effect, internal_ignore as ignore, internal_shared as shared, internal_signal as signal };
168
161
  }
169
162
 
170
163
  interface Batch {
171
164
  (callback: Callback): void;
172
- (callback: Callback, collector: Collector$1<Callback>): void;
173
- (callback: Callback, collector?: Collector$1<Callback>): void;
165
+ (callback: Callback, collector: Collector<Callback>): void;
166
+ (callback: Callback, collector?: Collector<Callback>): void;
174
167
  }
175
168
  declare const batch: Factory<Batch>;
176
169
 
177
- type ComposedFactory = <T>(read: () => T, write: (value: T) => void, equals?: Equals<T>) => Signal$1<T>;
170
+ type ComposedFactory = <T>(read: () => T, write: (value: T) => void, equals?: Equals<T>) => Signal<T>;
178
171
  declare const composed: Factory<ComposedFactory>;
179
172
 
180
173
  type ComputedFactory = <T>(read: () => T, equals?: Equals<T>) => ReadonlySignal<T>;
@@ -194,8 +187,8 @@ interface Config {
194
187
  composed?: Maybe<ComposedFactory>;
195
188
  effect?: Maybe<Effect>;
196
189
  batch?: Maybe<Batch>;
197
- ignore?: Maybe<Ignore$1>;
190
+ ignore?: Maybe<Ignore>;
198
191
  }
199
192
  declare function config(config?: Config): void;
200
193
 
201
- export { type Batch, type Callback, type Collector$1 as Collector, type CollectorFactory, type Comparable, type ComposedFactory, type ComputedFactory, type Config, type Effect, type EffectCallback, type EffectCleanup, type Equals, type Factory, type Function, type Ignore, type Maybe, type Peekable, type Readable, type ReadonlySignal, type Signal$1 as Signal, type SignalFactory, type Subscribable, type Writable, batch, collector$1 as collector, composed, computed, config, effect$1 as effect, factory, ignore, index as internal, signal$1 as signal };
194
+ export { type Batch, type Callable, type Callback, type Collector, type CollectorFactory, type Comparable, type ComposedFactory, type ComputedFactory, type Config, type Effect, type EffectCallback, type EffectCleanup, type Equals, type Factory, type Ignore, type Maybe, type Peekable, type Readable, type ReadonlySignal, type Signal, type SignalFactory, type Subscribable, type Writable, batch, collector, composed, computed, config, effect, factory, ignore, index as internal, signal };