@valentin30/signal 0.0.4 → 0.0.6

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 +10 -18
  2. package/dist/index.d.ts +10 -18
  3. package/dist/index.js +99 -93
  4. package/dist/index.mjs +98 -93
  5. package/package.json +1 -1
package/dist/index.d.mts CHANGED
@@ -30,7 +30,7 @@ type BatchCollectorFactory = () => Collector$1<Callback>;
30
30
 
31
31
  declare function collector<T>(): Collector$1<T>;
32
32
  declare class Collector<T> implements Collector$1<T> {
33
- private values;
33
+ #private;
34
34
  constructor(values: Set<T> | null);
35
35
  collecting(): boolean;
36
36
  add(value: T): void;
@@ -69,16 +69,8 @@ declare namespace computed$1 {
69
69
  }
70
70
  type ComputedCollectorFactory = () => Collector$1<ReadonlySignal<unknown>>;
71
71
  declare class Computed<T> implements ReadonlySignal<T> {
72
- private empty;
73
- private value;
74
- private values;
75
- private dependencies;
76
- private readonly compute;
77
- private readonly equalsFn;
78
- private readonly listeners;
79
- private readonly collector;
72
+ #private;
80
73
  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>>);
81
- private dirty;
82
74
  read(): T;
83
75
  equals(other: T): boolean;
84
76
  subscribe(callback: Callback): Callback;
@@ -93,8 +85,7 @@ declare namespace composed$1 {
93
85
  var collector: Factory<ComposedCollectorFactory>;
94
86
  }
95
87
  declare class Composed<T> extends Computed<T> implements Signal$1<T> {
96
- private readonly batcher;
97
- private readonly writeFn;
88
+ #private;
98
89
  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>>);
99
90
  write(value: T): void;
100
91
  }
@@ -131,11 +122,7 @@ declare namespace signal {
131
122
  var collector: Factory<SignalCollectorFactory>;
132
123
  }
133
124
  declare class Signal<T> implements Signal$1<T> {
134
- private value;
135
- private readonly equalsFn;
136
- private readonly listeners;
137
- private readonly batcher;
138
- private readonly collector;
125
+ #private;
139
126
  constructor(value: T, equals: Maybe<Equals<T>>, listeners: Set<Callback>, batcher: Collector$1<Callback>, collector: Collector$1<ReadonlySignal<unknown>>);
140
127
  read(): T;
141
128
  write(value: T): void;
@@ -200,4 +187,9 @@ interface Config {
200
187
  }
201
188
  declare function config(config?: Config): void;
202
189
 
203
- export { type Arguments, 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 Reader, type ReadonlySignal, type Signal$1 as Signal, type SignalFactory, type Subscription, type Writer, batch, collector$1 as collector, composed, computed, config, effect$1 as effect, factory, ignore, index as internal, signal$1 as signal };
190
+ declare const shared: {
191
+ batcher(): Collector$1<Callback>;
192
+ collector(): Collector$1<ReadonlySignal<unknown>>;
193
+ };
194
+
195
+ export { type Arguments, 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 Reader, type ReadonlySignal, type Signal$1 as Signal, type SignalFactory, type Subscription, type Writer, batch, collector$1 as collector, composed, computed, config, effect$1 as effect, factory, ignore, index as internal, shared, signal$1 as signal };
package/dist/index.d.ts CHANGED
@@ -30,7 +30,7 @@ type BatchCollectorFactory = () => Collector$1<Callback>;
30
30
 
31
31
  declare function collector<T>(): Collector$1<T>;
32
32
  declare class Collector<T> implements Collector$1<T> {
33
- private values;
33
+ #private;
34
34
  constructor(values: Set<T> | null);
35
35
  collecting(): boolean;
36
36
  add(value: T): void;
@@ -69,16 +69,8 @@ declare namespace computed$1 {
69
69
  }
70
70
  type ComputedCollectorFactory = () => Collector$1<ReadonlySignal<unknown>>;
71
71
  declare class Computed<T> implements ReadonlySignal<T> {
72
- private empty;
73
- private value;
74
- private values;
75
- private dependencies;
76
- private readonly compute;
77
- private readonly equalsFn;
78
- private readonly listeners;
79
- private readonly collector;
72
+ #private;
80
73
  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>>);
81
- private dirty;
82
74
  read(): T;
83
75
  equals(other: T): boolean;
84
76
  subscribe(callback: Callback): Callback;
@@ -93,8 +85,7 @@ declare namespace composed$1 {
93
85
  var collector: Factory<ComposedCollectorFactory>;
94
86
  }
95
87
  declare class Composed<T> extends Computed<T> implements Signal$1<T> {
96
- private readonly batcher;
97
- private readonly writeFn;
88
+ #private;
98
89
  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>>);
99
90
  write(value: T): void;
100
91
  }
@@ -131,11 +122,7 @@ declare namespace signal {
131
122
  var collector: Factory<SignalCollectorFactory>;
132
123
  }
133
124
  declare class Signal<T> implements Signal$1<T> {
134
- private value;
135
- private readonly equalsFn;
136
- private readonly listeners;
137
- private readonly batcher;
138
- private readonly collector;
125
+ #private;
139
126
  constructor(value: T, equals: Maybe<Equals<T>>, listeners: Set<Callback>, batcher: Collector$1<Callback>, collector: Collector$1<ReadonlySignal<unknown>>);
140
127
  read(): T;
141
128
  write(value: T): void;
@@ -200,4 +187,9 @@ interface Config {
200
187
  }
201
188
  declare function config(config?: Config): void;
202
189
 
203
- export { type Arguments, 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 Reader, type ReadonlySignal, type Signal$1 as Signal, type SignalFactory, type Subscription, type Writer, batch, collector$1 as collector, composed, computed, config, effect$1 as effect, factory, ignore, index as internal, signal$1 as signal };
190
+ declare const shared: {
191
+ batcher(): Collector$1<Callback>;
192
+ collector(): Collector$1<ReadonlySignal<unknown>>;
193
+ };
194
+
195
+ export { type Arguments, 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 Reader, type ReadonlySignal, type Signal$1 as Signal, type SignalFactory, type Subscription, type Writer, batch, collector$1 as collector, composed, computed, config, effect$1 as effect, factory, ignore, index as internal, shared, signal$1 as signal };
package/dist/index.js CHANGED
@@ -29,6 +29,7 @@ __export(index_exports, {
29
29
  factory: () => factory,
30
30
  ignore: () => ignore,
31
31
  internal: () => internal_exports,
32
+ shared: () => shared,
32
33
  signal: () => signal
33
34
  });
34
35
  module.exports = __toCommonJS(index_exports);
@@ -66,13 +67,27 @@ var effect = factory("effect");
66
67
  // src/core/ignore.ts
67
68
  var ignore = factory("ignore");
68
69
 
70
+ // src/core/shared.ts
71
+ var __batcher__ = null;
72
+ var __collector__ = null;
73
+ var shared = {
74
+ batcher() {
75
+ if (!__batcher__) __batcher__ = collector();
76
+ return __batcher__;
77
+ },
78
+ collector() {
79
+ if (!__collector__) __collector__ = collector();
80
+ return __collector__;
81
+ }
82
+ };
83
+
69
84
  // src/core/signal.ts
70
85
  var signal = factory("signal");
71
86
 
72
87
  // src/internal/index.ts
73
88
  var internal_exports = {};
74
89
  __export(internal_exports, {
75
- Collector: () => Collector,
90
+ Collector: () => Collector2,
76
91
  Composed: () => Composed,
77
92
  Computed: () => Computed,
78
93
  Signal: () => Signal,
@@ -94,33 +109,33 @@ batch2.collector = factory("batch.collector");
94
109
 
95
110
  // src/internal/collector.ts
96
111
  function collector2() {
97
- return new Collector(null);
112
+ return new Collector2(null);
98
113
  }
99
- var Collector = class {
100
- values;
114
+ var Collector2 = class {
115
+ #values;
101
116
  constructor(values) {
102
- this.values = values;
117
+ this.#values = values;
103
118
  }
104
119
  collecting() {
105
- return this.values !== null;
120
+ return this.#values !== null;
106
121
  }
107
122
  add(value) {
108
- if (!this.values) return;
109
- this.values.add(value);
123
+ if (!this.collecting() || !this.#values) return;
124
+ this.#values.add(value);
110
125
  }
111
126
  collect(callback) {
112
- const current = this.values;
113
- this.values = /* @__PURE__ */ new Set();
127
+ const current = this.#values;
128
+ this.#values = /* @__PURE__ */ new Set();
114
129
  callback();
115
- const collected = this.values;
116
- this.values = current;
130
+ const collected = this.#values;
131
+ this.#values = current;
117
132
  return collected;
118
133
  }
119
134
  ignore(callback) {
120
- const current = this.values;
121
- this.values = null;
135
+ const current = this.#values;
136
+ this.#values = null;
122
137
  callback();
123
- this.values = current;
138
+ this.#values = current;
124
139
  }
125
140
  };
126
141
 
@@ -139,54 +154,54 @@ function computed2(compute, equals) {
139
154
  }
140
155
  computed2.collector = factory("computed.collector");
141
156
  var Computed = class {
142
- empty;
143
- value;
144
- values;
145
- dependencies;
146
- compute;
147
- equalsFn;
148
- listeners;
149
- collector;
157
+ #empty;
158
+ #value;
159
+ #values;
160
+ #dependencies;
161
+ #compute;
162
+ #equals;
163
+ #listeners;
164
+ #collector;
150
165
  constructor(empty, value, values, dependencies, listeners, collector3, compute, equals) {
151
- this.empty = empty;
152
- this.value = value;
153
- this.values = values;
154
- this.dependencies = dependencies;
155
- this.listeners = listeners;
156
- this.collector = collector3;
157
- this.compute = compute;
158
- this.equalsFn = equals;
166
+ this.#empty = empty;
167
+ this.#value = value;
168
+ this.#values = values;
169
+ this.#dependencies = dependencies;
170
+ this.#listeners = listeners;
171
+ this.#collector = collector3;
172
+ this.#compute = compute;
173
+ this.#equals = equals;
159
174
  }
160
- dirty() {
161
- if (this.empty) return true;
162
- return this.values.some(([dep, value]) => !dep.equals(value));
175
+ #dirty() {
176
+ if (this.#empty) return true;
177
+ return this.#values.some(([dep, value]) => !dep.equals(value));
163
178
  }
164
179
  read() {
165
- this.collector.add(this);
166
- if (!this.dirty()) return this.value;
167
- const current = this.dependencies;
168
- const next = this.collector.collect(() => this.value = this.compute());
169
- this.dependencies = next;
170
- this.values = Array.from(next).map((dep) => [dep, dep.read()]);
171
- this.empty = false;
172
- if (!current.size && !next.size) return this.value;
173
- if (!this.listeners.size) return this.value;
174
- current.forEach((dep) => !next.has(dep) && this.listeners.forEach((listener) => dep.unsubscribe(listener)));
175
- next.forEach((dep) => !current.has(dep) && this.listeners.forEach((listener) => dep.subscribe(listener)));
176
- return this.value;
180
+ this.#collector.add(this);
181
+ if (!this.#dirty()) return this.#value;
182
+ const current = this.#dependencies;
183
+ const next = this.#collector.collect(() => this.#value = this.#compute());
184
+ this.#dependencies = next;
185
+ this.#values = Array.from(next).map((dep) => [dep, dep.read()]);
186
+ this.#empty = false;
187
+ if (!current.size && !next.size) return this.#value;
188
+ if (!this.#listeners.size) return this.#value;
189
+ current.forEach((dep) => !next.has(dep) && this.#listeners.forEach((listener) => dep.unsubscribe(listener)));
190
+ next.forEach((dep) => !current.has(dep) && this.#listeners.forEach((listener) => dep.subscribe(listener)));
191
+ return this.#value;
177
192
  }
178
193
  equals(other) {
179
- if (this.equalsFn) return this.equalsFn(this.read(), other);
194
+ if (this.#equals) return this.#equals(this.read(), other);
180
195
  return this.read() === other;
181
196
  }
182
197
  subscribe(callback) {
183
- this.listeners.add(callback);
184
- this.dependencies.forEach((dep) => dep.subscribe(callback));
198
+ this.#listeners.add(callback);
199
+ this.#dependencies.forEach((dep) => dep.subscribe(callback));
185
200
  return this.unsubscribe.bind(this, callback);
186
201
  }
187
202
  unsubscribe(callback) {
188
- this.listeners.delete(callback);
189
- this.dependencies.forEach((dep) => dep.unsubscribe(callback));
203
+ this.#listeners.delete(callback);
204
+ this.#dependencies.forEach((dep) => dep.unsubscribe(callback));
190
205
  }
191
206
  };
192
207
 
@@ -208,16 +223,16 @@ function composed2(compute, write, equals) {
208
223
  composed2.batcher = factory("composed.batcher");
209
224
  composed2.collector = factory("composed.collector");
210
225
  var Composed = class extends Computed {
211
- batcher;
212
- writeFn;
226
+ #batcher;
227
+ #write;
213
228
  constructor(empty, value, values, dependencies, listeners, batcher, collector3, compute, write, equals) {
214
229
  super(empty, value, values, dependencies, listeners, collector3, compute, equals);
215
- this.batcher = batcher;
216
- this.writeFn = write;
230
+ this.#batcher = batcher;
231
+ this.#write = write;
217
232
  }
218
233
  write(value) {
219
234
  if (this.equals(value)) return;
220
- batch(() => this.writeFn(value), this.batcher);
235
+ batch(() => this.#write(value), this.#batcher);
221
236
  }
222
237
  };
223
238
 
@@ -257,38 +272,38 @@ function signal2(value, equals) {
257
272
  signal2.batcher = factory("signal.batcher");
258
273
  signal2.collector = factory("signal.collector");
259
274
  var Signal = class {
260
- value;
261
- equalsFn;
262
- listeners;
263
- batcher;
264
- collector;
275
+ #value;
276
+ #equals;
277
+ #listeners;
278
+ #batcher;
279
+ #collector;
265
280
  constructor(value, equals, listeners, batcher, collector3) {
266
- this.value = value;
267
- this.equalsFn = equals;
268
- this.listeners = listeners;
269
- this.batcher = batcher;
270
- this.collector = collector3;
281
+ this.#value = value;
282
+ this.#equals = equals;
283
+ this.#listeners = listeners;
284
+ this.#batcher = batcher;
285
+ this.#collector = collector3;
271
286
  }
272
287
  read() {
273
- this.collector.add(this);
274
- return this.value;
288
+ this.#collector.add(this);
289
+ return this.#value;
275
290
  }
276
291
  write(value) {
277
292
  if (this.equals(value)) return;
278
- this.value = value;
279
- if (this.batcher.collecting()) this.listeners.forEach((listener) => this.batcher.add(listener));
280
- else this.listeners.forEach((listener) => listener());
293
+ this.#value = value;
294
+ if (this.#batcher.collecting()) this.#listeners.forEach((listener) => this.#batcher.add(listener));
295
+ else this.#listeners.forEach((listener) => listener());
281
296
  }
282
297
  equals(other) {
283
- if (this.equalsFn) return this.equalsFn(this.value, other);
284
- return this.value === other;
298
+ if (this.#equals) return this.#equals(this.#value, other);
299
+ return this.#value === other;
285
300
  }
286
301
  subscribe(callback) {
287
- this.listeners.add(callback);
302
+ this.#listeners.add(callback);
288
303
  return this.unsubscribe.bind(this, callback);
289
304
  }
290
305
  unsubscribe(callback) {
291
- this.listeners.delete(callback);
306
+ this.#listeners.delete(callback);
292
307
  }
293
308
  };
294
309
 
@@ -304,24 +319,14 @@ function config(config2 = {}) {
304
319
  }
305
320
 
306
321
  // src/index.ts
307
- var __collector__ = null;
308
- function shared_collector() {
309
- if (!__collector__) __collector__ = collector();
310
- return __collector__;
311
- }
312
- signal2.collector.default(shared_collector);
313
- computed2.collector.default(shared_collector);
314
- composed2.collector.default(shared_collector);
315
- effect2.collector.default(shared_collector);
316
- ignore2.collector.default(shared_collector);
317
- var __batcher__ = null;
318
- function shared_batcher() {
319
- if (!__batcher__) __batcher__ = collector();
320
- return __batcher__;
321
- }
322
- signal2.batcher.default(shared_batcher);
323
- composed2.batcher.default(shared_batcher);
324
- batch2.collector.default(shared_batcher);
322
+ signal2.collector.default(shared.collector);
323
+ computed2.collector.default(shared.collector);
324
+ composed2.collector.default(shared.collector);
325
+ effect2.collector.default(shared.collector);
326
+ ignore2.collector.default(shared.collector);
327
+ signal2.batcher.default(shared.batcher);
328
+ composed2.batcher.default(shared.batcher);
329
+ batch2.collector.default(shared.batcher);
325
330
  collector.default(collector2);
326
331
  signal.default(signal2);
327
332
  computed.default(computed2);
@@ -340,5 +345,6 @@ ignore.default(ignore2);
340
345
  factory,
341
346
  ignore,
342
347
  internal,
348
+ shared,
343
349
  signal
344
350
  });
package/dist/index.mjs CHANGED
@@ -37,13 +37,27 @@ var effect = factory("effect");
37
37
  // src/core/ignore.ts
38
38
  var ignore = factory("ignore");
39
39
 
40
+ // src/core/shared.ts
41
+ var __batcher__ = null;
42
+ var __collector__ = null;
43
+ var shared = {
44
+ batcher() {
45
+ if (!__batcher__) __batcher__ = collector();
46
+ return __batcher__;
47
+ },
48
+ collector() {
49
+ if (!__collector__) __collector__ = collector();
50
+ return __collector__;
51
+ }
52
+ };
53
+
40
54
  // src/core/signal.ts
41
55
  var signal = factory("signal");
42
56
 
43
57
  // src/internal/index.ts
44
58
  var internal_exports = {};
45
59
  __export(internal_exports, {
46
- Collector: () => Collector,
60
+ Collector: () => Collector2,
47
61
  Composed: () => Composed,
48
62
  Computed: () => Computed,
49
63
  Signal: () => Signal,
@@ -65,33 +79,33 @@ batch2.collector = factory("batch.collector");
65
79
 
66
80
  // src/internal/collector.ts
67
81
  function collector2() {
68
- return new Collector(null);
82
+ return new Collector2(null);
69
83
  }
70
- var Collector = class {
71
- values;
84
+ var Collector2 = class {
85
+ #values;
72
86
  constructor(values) {
73
- this.values = values;
87
+ this.#values = values;
74
88
  }
75
89
  collecting() {
76
- return this.values !== null;
90
+ return this.#values !== null;
77
91
  }
78
92
  add(value) {
79
- if (!this.values) return;
80
- this.values.add(value);
93
+ if (!this.collecting() || !this.#values) return;
94
+ this.#values.add(value);
81
95
  }
82
96
  collect(callback) {
83
- const current = this.values;
84
- this.values = /* @__PURE__ */ new Set();
97
+ const current = this.#values;
98
+ this.#values = /* @__PURE__ */ new Set();
85
99
  callback();
86
- const collected = this.values;
87
- this.values = current;
100
+ const collected = this.#values;
101
+ this.#values = current;
88
102
  return collected;
89
103
  }
90
104
  ignore(callback) {
91
- const current = this.values;
92
- this.values = null;
105
+ const current = this.#values;
106
+ this.#values = null;
93
107
  callback();
94
- this.values = current;
108
+ this.#values = current;
95
109
  }
96
110
  };
97
111
 
@@ -110,54 +124,54 @@ function computed2(compute, equals) {
110
124
  }
111
125
  computed2.collector = factory("computed.collector");
112
126
  var Computed = class {
113
- empty;
114
- value;
115
- values;
116
- dependencies;
117
- compute;
118
- equalsFn;
119
- listeners;
120
- collector;
127
+ #empty;
128
+ #value;
129
+ #values;
130
+ #dependencies;
131
+ #compute;
132
+ #equals;
133
+ #listeners;
134
+ #collector;
121
135
  constructor(empty, value, values, dependencies, listeners, collector3, compute, equals) {
122
- this.empty = empty;
123
- this.value = value;
124
- this.values = values;
125
- this.dependencies = dependencies;
126
- this.listeners = listeners;
127
- this.collector = collector3;
128
- this.compute = compute;
129
- this.equalsFn = equals;
136
+ this.#empty = empty;
137
+ this.#value = value;
138
+ this.#values = values;
139
+ this.#dependencies = dependencies;
140
+ this.#listeners = listeners;
141
+ this.#collector = collector3;
142
+ this.#compute = compute;
143
+ this.#equals = equals;
130
144
  }
131
- dirty() {
132
- if (this.empty) return true;
133
- return this.values.some(([dep, value]) => !dep.equals(value));
145
+ #dirty() {
146
+ if (this.#empty) return true;
147
+ return this.#values.some(([dep, value]) => !dep.equals(value));
134
148
  }
135
149
  read() {
136
- this.collector.add(this);
137
- if (!this.dirty()) return this.value;
138
- const current = this.dependencies;
139
- const next = this.collector.collect(() => this.value = this.compute());
140
- this.dependencies = next;
141
- this.values = Array.from(next).map((dep) => [dep, dep.read()]);
142
- this.empty = false;
143
- if (!current.size && !next.size) return this.value;
144
- if (!this.listeners.size) return this.value;
145
- current.forEach((dep) => !next.has(dep) && this.listeners.forEach((listener) => dep.unsubscribe(listener)));
146
- next.forEach((dep) => !current.has(dep) && this.listeners.forEach((listener) => dep.subscribe(listener)));
147
- return this.value;
150
+ this.#collector.add(this);
151
+ if (!this.#dirty()) return this.#value;
152
+ const current = this.#dependencies;
153
+ const next = this.#collector.collect(() => this.#value = this.#compute());
154
+ this.#dependencies = next;
155
+ this.#values = Array.from(next).map((dep) => [dep, dep.read()]);
156
+ this.#empty = false;
157
+ if (!current.size && !next.size) return this.#value;
158
+ if (!this.#listeners.size) return this.#value;
159
+ current.forEach((dep) => !next.has(dep) && this.#listeners.forEach((listener) => dep.unsubscribe(listener)));
160
+ next.forEach((dep) => !current.has(dep) && this.#listeners.forEach((listener) => dep.subscribe(listener)));
161
+ return this.#value;
148
162
  }
149
163
  equals(other) {
150
- if (this.equalsFn) return this.equalsFn(this.read(), other);
164
+ if (this.#equals) return this.#equals(this.read(), other);
151
165
  return this.read() === other;
152
166
  }
153
167
  subscribe(callback) {
154
- this.listeners.add(callback);
155
- this.dependencies.forEach((dep) => dep.subscribe(callback));
168
+ this.#listeners.add(callback);
169
+ this.#dependencies.forEach((dep) => dep.subscribe(callback));
156
170
  return this.unsubscribe.bind(this, callback);
157
171
  }
158
172
  unsubscribe(callback) {
159
- this.listeners.delete(callback);
160
- this.dependencies.forEach((dep) => dep.unsubscribe(callback));
173
+ this.#listeners.delete(callback);
174
+ this.#dependencies.forEach((dep) => dep.unsubscribe(callback));
161
175
  }
162
176
  };
163
177
 
@@ -179,16 +193,16 @@ function composed2(compute, write, equals) {
179
193
  composed2.batcher = factory("composed.batcher");
180
194
  composed2.collector = factory("composed.collector");
181
195
  var Composed = class extends Computed {
182
- batcher;
183
- writeFn;
196
+ #batcher;
197
+ #write;
184
198
  constructor(empty, value, values, dependencies, listeners, batcher, collector3, compute, write, equals) {
185
199
  super(empty, value, values, dependencies, listeners, collector3, compute, equals);
186
- this.batcher = batcher;
187
- this.writeFn = write;
200
+ this.#batcher = batcher;
201
+ this.#write = write;
188
202
  }
189
203
  write(value) {
190
204
  if (this.equals(value)) return;
191
- batch(() => this.writeFn(value), this.batcher);
205
+ batch(() => this.#write(value), this.#batcher);
192
206
  }
193
207
  };
194
208
 
@@ -228,38 +242,38 @@ function signal2(value, equals) {
228
242
  signal2.batcher = factory("signal.batcher");
229
243
  signal2.collector = factory("signal.collector");
230
244
  var Signal = class {
231
- value;
232
- equalsFn;
233
- listeners;
234
- batcher;
235
- collector;
245
+ #value;
246
+ #equals;
247
+ #listeners;
248
+ #batcher;
249
+ #collector;
236
250
  constructor(value, equals, listeners, batcher, collector3) {
237
- this.value = value;
238
- this.equalsFn = equals;
239
- this.listeners = listeners;
240
- this.batcher = batcher;
241
- this.collector = collector3;
251
+ this.#value = value;
252
+ this.#equals = equals;
253
+ this.#listeners = listeners;
254
+ this.#batcher = batcher;
255
+ this.#collector = collector3;
242
256
  }
243
257
  read() {
244
- this.collector.add(this);
245
- return this.value;
258
+ this.#collector.add(this);
259
+ return this.#value;
246
260
  }
247
261
  write(value) {
248
262
  if (this.equals(value)) return;
249
- this.value = value;
250
- if (this.batcher.collecting()) this.listeners.forEach((listener) => this.batcher.add(listener));
251
- else this.listeners.forEach((listener) => listener());
263
+ this.#value = value;
264
+ if (this.#batcher.collecting()) this.#listeners.forEach((listener) => this.#batcher.add(listener));
265
+ else this.#listeners.forEach((listener) => listener());
252
266
  }
253
267
  equals(other) {
254
- if (this.equalsFn) return this.equalsFn(this.value, other);
255
- return this.value === other;
268
+ if (this.#equals) return this.#equals(this.#value, other);
269
+ return this.#value === other;
256
270
  }
257
271
  subscribe(callback) {
258
- this.listeners.add(callback);
272
+ this.#listeners.add(callback);
259
273
  return this.unsubscribe.bind(this, callback);
260
274
  }
261
275
  unsubscribe(callback) {
262
- this.listeners.delete(callback);
276
+ this.#listeners.delete(callback);
263
277
  }
264
278
  };
265
279
 
@@ -275,24 +289,14 @@ function config(config2 = {}) {
275
289
  }
276
290
 
277
291
  // src/index.ts
278
- var __collector__ = null;
279
- function shared_collector() {
280
- if (!__collector__) __collector__ = collector();
281
- return __collector__;
282
- }
283
- signal2.collector.default(shared_collector);
284
- computed2.collector.default(shared_collector);
285
- composed2.collector.default(shared_collector);
286
- effect2.collector.default(shared_collector);
287
- ignore2.collector.default(shared_collector);
288
- var __batcher__ = null;
289
- function shared_batcher() {
290
- if (!__batcher__) __batcher__ = collector();
291
- return __batcher__;
292
- }
293
- signal2.batcher.default(shared_batcher);
294
- composed2.batcher.default(shared_batcher);
295
- batch2.collector.default(shared_batcher);
292
+ signal2.collector.default(shared.collector);
293
+ computed2.collector.default(shared.collector);
294
+ composed2.collector.default(shared.collector);
295
+ effect2.collector.default(shared.collector);
296
+ ignore2.collector.default(shared.collector);
297
+ signal2.batcher.default(shared.batcher);
298
+ composed2.batcher.default(shared.batcher);
299
+ batch2.collector.default(shared.batcher);
296
300
  collector.default(collector2);
297
301
  signal.default(signal2);
298
302
  computed.default(computed2);
@@ -310,5 +314,6 @@ export {
310
314
  factory,
311
315
  ignore,
312
316
  internal_exports as internal,
317
+ shared,
313
318
  signal
314
319
  };
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@valentin30/signal",
3
- "version": "0.0.4",
3
+ "version": "0.0.6",
4
4
  "description": "My take on signals - lightweight reactive primitives inspired by Preact Signals, written in TypeScript.",
5
5
  "main": "dist/index.js",
6
6
  "module": "dist/index.mjs",