@valentin30/signal 0.2.0 → 1.0.0

package/dist/index.d.mts

@@ -1,287 +0,0 @@
-type Callable<Args extends any[] = any[], ReturnType = any> = (...args: Args) => ReturnType;
-
-interface Batcher {
-    batch<Value>(callback: () => Value): Value;
-    batch<Value, Args extends any[]>(callback: Callable<Args, Value>, ...args: Args): Value;
-}
-declare function batch<Value>(callback: () => Value): Value;
-declare function batch<Value, Args extends any[]>(callback: Callable<Args, Value>, ...args: Args): Value;
-
-type Write<T> = (value: T) => void | undefined | boolean;
-interface Writable<T> {
-    write(value: T): boolean;
-}
-declare function writer<T>(write: Write<T>): Writable<T>;
-
-interface Comparator<T> {
-    equals(value: T, other: T): boolean;
-}
-interface Comparable<T> extends Comparator<T> {
-    equals(other: T): boolean;
-    equals(value: T, other: T): boolean;
-}
-type Equals<T> = (value: T, other: T) => boolean;
-declare namespace Equals {
-    function strict<T>(value: T, other: T): boolean;
-}
-declare function comparator<T>(equals?: Equals<T>): Comparator<T>;
-
-interface Peekable<T> {
-    peek(): T;
-}
-
-interface Readable<T> {
-    read(): T;
-}
-declare function reader<T>(read: () => T): Readable<T>;
-
-type Callback = () => void;
-
-interface Subscribable {
-    subscribe(callback: Callback): Callback;
-    unsubscribe(callback: Callback): void;
-}
-
-interface Signal<T> extends Readable<T>, Writable<T>, Comparable<T>, Peekable<T>, Subscribable {
-}
-interface ReadonlySignal<T> extends Readable<T>, Comparable<T>, Peekable<T>, Subscribable {
-}
-interface SignalFactory {
-    <T>(value: T, equals?: Equals<T>): Signal<T>;
-}
-declare function signal<T>(value: T, equals?: Equals<T>): Signal<T>;
-
-interface ComposedFactory {
-    <T>(value: ReadonlySignal<T>, write: Write<T>): Signal<T>;
-}
-declare function composed<T>(value: ReadonlySignal<T>, write: Write<T>): Signal<T>;
-
-interface ComputedFactory {
-    <T>(compute: () => T, equals?: Equals<T>): ReadonlySignal<T>;
-}
-declare function computed<T>(compute: () => T, equals?: Equals<T>): ReadonlySignal<T>;
-
-interface Ignore {
-    ignore<Value>(callback: () => Value): Value;
-    ignore<Value, Args extends any[]>(callback: Callable<Args, Value>, ...args: Args): Value;
-}
-declare function ignore<Value>(callback: () => Value): Value;
-declare function ignore<Value, Args extends any[]>(callback: Callable<Args, Value>, ...args: Args): Value;
-
-interface CollectorState {
-    collecting(): boolean;
-}
-interface CollectorTarget<T> extends CollectorState {
-    add(value: T): void;
-}
-interface Collector<T> extends CollectorState {
-    collect<Value>(callback: () => Value): [Value, Readonly<Set<T>>];
-    collect<Value, Args extends any[]>(callback: Callable<Args, Value>, ...args: Args): [Value, Readonly<Set<T>>];
-}
-
-interface Tracker<T> {
-    track(value: T): void;
-}
-
-interface DependencyState {
-    changed(): boolean;
-}
-interface DependencyObserver extends DependencyState, Tracker<Callback> {
-}
-interface DependencyTracker extends DependencyObserver, Subscribable {
-}
-
-interface Scheduler<T> {
-    schedule(...value: T[]): void;
-}
-
-declare class CollectorBasedBatcher implements Batcher {
-    private readonly collector;
-    constructor(collector: Collector<Callback>);
-    batch<Value>(callback: () => Value): Value;
-    batch<Value, Args extends any[]>(callback: Callable<Args, Value>, ...args: Args): Value;
-}
-
-type Maybe<T> = T | null | undefined;
-
-declare class CollectorController<T> implements Collector<T>, CollectorTarget<T>, CollectorState, Ignore, Tracker<T> {
-    private values;
-    constructor(values?: Maybe<Set<T>>);
-    collecting(): boolean;
-    add(value: T): void;
-    track(value: T): void;
-    collect<Value>(callback: () => Value): [Value, Readonly<Set<T>>];
-    collect<Value, Args extends any[]>(callback: Callable<Args, Value>, ...args: Args): [Value, Readonly<Set<T>>];
-    ignore<Value>(callback: () => Value): Value;
-    ignore<Value, Args extends any[]>(callback: Callable<Args, Value>, ...args: Args): Value;
-}
-
-declare class Composed<T> implements Signal<T> {
-    private readonly value;
-    private readonly writer;
-    constructor(value: ReadonlySignal<T>, writer: Writable<T>);
-    read(): T;
-    peek(): T;
-    write(value: T): boolean;
-    equals(other: T): boolean;
-    equals(value: T, other: T): boolean;
-    subscribe(callback: Callback): Callback;
-    unsubscribe(callback: Callback): void;
-}
-
-type Snapshot = [ReadonlySignal<unknown>, unknown];
-declare namespace Snapshot {
-    function changed([value, snapshot]: Snapshot): boolean;
-    function from(values: Set<ReadonlySignal<unknown>>): Snapshot[];
-}
-declare class DependencyManager implements DependencyTracker {
-    private snapshot;
-    private dependencies;
-    private readonly collector;
-    private readonly listeners;
-    constructor(collector: Collector<ReadonlySignal<unknown>>, listeners?: Set<Callback>, dependencies?: Set<ReadonlySignal<unknown>>, snapshot?: Maybe<Snapshot[]>);
-    changed(): boolean;
-    track(callback: Callback): void;
-    subscribe(callback: Callback): Callback;
-    unsubscribe(callback: Callback): void;
-    private equals;
-}
-
-interface Emitter {
-    emit(): void;
-}
-
-declare class ScheduledEmitter implements Emitter, Subscribable {
-    private readonly listeners;
-    private readonly scheduler;
-    constructor(scheduler: Scheduler<Callback>, listeners?: Set<Callback>);
-    emit(): void;
-    subscribe(callback: Callback): Callback;
-    unsubscribe(callback: Callback): void;
-}
-
-interface Value<T> extends Readable<T>, Writable<T>, Comparable<T> {
-}
-
-declare class Reactive<T> implements Signal<T> {
-    private readonly value;
-    private readonly tracker;
-    private readonly subscription;
-    constructor(value: Value<T>, tracker: Tracker<ReadonlySignal<unknown>>, subscription: Subscribable);
-    read(): T;
-    peek(): T;
-    write(value: T): boolean;
-    equals(other: T): boolean;
-    equals(value: T, other: T): boolean;
-    subscribe(callback: Callback): Callback;
-    unsubscribe(callback: Callback): void;
-}
-
-declare class CallbackScheduler implements Scheduler<Callback> {
-    private readonly collector;
-    private readonly add;
-    constructor(collector: CollectorTarget<Callback>);
-    schedule(...args: Callback[]): void;
-}
-
-declare class BasicValue<T> implements Value<T> {
-    private value;
-    private readonly comparator;
-    constructor(value: T, comparator: Comparator<T>);
-    read(): T;
-    write(value: T): boolean;
-    equals(other: T): boolean;
-    equals(value: T, other: T): boolean;
-}
-declare class EmittingValue<T> {
-    private readonly value;
-    private readonly emitter;
-    constructor(value: Value<T>, emitter: Emitter);
-    read(): T;
-    write(value: T): boolean;
-    equals(other: T): boolean;
-    equals(value: T, other: T): boolean;
-}
-declare class ComputedValue<T> implements Value<T> {
-    private readonly cache;
-    private readonly computation;
-    private readonly dependencies;
-    constructor(cache: Value<T>, computation: Readable<T>, dependencies: DependencyObserver);
-    read(): T;
-    private recompute;
-    write(_: T): boolean;
-    equals(other: T): boolean;
-    equals(value: T, other: T): boolean;
-}
-
-declare class BatchWriter<T> implements Writable<T> {
-    private readonly writer;
-    private readonly batcher;
-    constructor(writer: Writable<T>, batcher: Batcher);
-    write(value: T): boolean;
-}
-
-type internal_BasicValue<T> = BasicValue<T>;
-declare const internal_BasicValue: typeof BasicValue;
-type internal_BatchWriter<T> = BatchWriter<T>;
-declare const internal_BatchWriter: typeof BatchWriter;
-type internal_CallbackScheduler = CallbackScheduler;
-declare const internal_CallbackScheduler: typeof CallbackScheduler;
-type internal_CollectorBasedBatcher = CollectorBasedBatcher;
-declare const internal_CollectorBasedBatcher: typeof CollectorBasedBatcher;
-type internal_CollectorController<T> = CollectorController<T>;
-declare const internal_CollectorController: typeof CollectorController;
-type internal_Composed<T> = Composed<T>;
-declare const internal_Composed: typeof Composed;
-type internal_ComputedValue<T> = ComputedValue<T>;
-declare const internal_ComputedValue: typeof ComputedValue;
-type internal_DependencyManager = DependencyManager;
-declare const internal_DependencyManager: typeof DependencyManager;
-type internal_EmittingValue<T> = EmittingValue<T>;
-declare const internal_EmittingValue: typeof EmittingValue;
-type internal_Reactive<T> = Reactive<T>;
-declare const internal_Reactive: typeof Reactive;
-type internal_ScheduledEmitter = ScheduledEmitter;
-declare const internal_ScheduledEmitter: typeof ScheduledEmitter;
-declare const internal_Snapshot: typeof Snapshot;
-declare namespace internal {
-  export { internal_BasicValue as BasicValue, internal_BatchWriter as BatchWriter, internal_CallbackScheduler as CallbackScheduler, internal_CollectorBasedBatcher as CollectorBasedBatcher, internal_CollectorController as CollectorController, internal_Composed as Composed, internal_ComputedValue as ComputedValue, internal_DependencyManager as DependencyManager, internal_EmittingValue as EmittingValue, internal_Reactive as Reactive, internal_ScheduledEmitter as ScheduledEmitter, internal_Snapshot as Snapshot };
-}
-
-declare function call(callback: Callback): void;
-
-type Factory<FactoryFunction extends Callable> = FactoryFunction & {
-    factory(factory: Maybe<FactoryFunction>): void;
-    default(factory: Maybe<FactoryFunction>): void;
-    configured(): boolean;
-};
-declare function factory<FactoryFunction extends Callable>(name: string): Factory<FactoryFunction>;
-
-declare function singleton<T>(factory: () => T): {
-    (): T;
-    instance: T | undefined;
-};
-
-type utils_Factory<FactoryFunction extends Callable> = Factory<FactoryFunction>;
-declare const utils_call: typeof call;
-declare const utils_factory: typeof factory;
-declare const utils_singleton: typeof singleton;
-declare namespace utils {
-  export { type utils_Factory as Factory, utils_call as call, utils_factory as factory, utils_singleton as singleton };
-}
-
-declare function configuration(): {
-    signal: Factory<SignalFactory>;
-    computed: Factory<ComputedFactory>;
-    composed: Factory<ComposedFactory>;
-    batcher: Factory<() => Batcher>;
-    ignorer: Factory<() => Ignore>;
-    scheduler: Factory<() => Scheduler<Callback>>;
-    tracker: Factory<() => Tracker<ReadonlySignal<unknown>>>;
-    collector: Factory<() => Collector<ReadonlySignal<unknown>>>;
-    dependency_tracker: Factory<() => DependencyTracker>;
-    dependency_collector: Factory<() => CollectorController<ReadonlySignal<unknown>>>;
-    callback_collector: Factory<() => CollectorController<Callback>>;
-};
-
-export { type Batcher, type Callable, type Callback, type Collector, type CollectorState, type CollectorTarget, type Comparable, type Comparator, type ComposedFactory, type ComputedFactory, type DependencyObserver, type DependencyState, type DependencyTracker, type Emitter, Equals, type Ignore, internal as Internal, type Maybe, type Peekable, type Readable, type ReadonlySignal, type Scheduler, type Signal, type SignalFactory, type Subscribable, type Tracker, type Value, type Writable, type Write, batch, comparator, composed, computed, configuration, ignore, reader, signal, utils, writer };

package/dist/index.d.ts

@@ -1,287 +0,0 @@
-type Callable<Args extends any[] = any[], ReturnType = any> = (...args: Args) => ReturnType;
-
-interface Batcher {
-    batch<Value>(callback: () => Value): Value;
-    batch<Value, Args extends any[]>(callback: Callable<Args, Value>, ...args: Args): Value;
-}
-declare function batch<Value>(callback: () => Value): Value;
-declare function batch<Value, Args extends any[]>(callback: Callable<Args, Value>, ...args: Args): Value;
-
-type Write<T> = (value: T) => void | undefined | boolean;
-interface Writable<T> {
-    write(value: T): boolean;
-}
-declare function writer<T>(write: Write<T>): Writable<T>;
-
-interface Comparator<T> {
-    equals(value: T, other: T): boolean;
-}
-interface Comparable<T> extends Comparator<T> {
-    equals(other: T): boolean;
-    equals(value: T, other: T): boolean;
-}
-type Equals<T> = (value: T, other: T) => boolean;
-declare namespace Equals {
-    function strict<T>(value: T, other: T): boolean;
-}
-declare function comparator<T>(equals?: Equals<T>): Comparator<T>;
-
-interface Peekable<T> {
-    peek(): T;
-}
-
-interface Readable<T> {
-    read(): T;
-}
-declare function reader<T>(read: () => T): Readable<T>;
-
-type Callback = () => void;
-
-interface Subscribable {
-    subscribe(callback: Callback): Callback;
-    unsubscribe(callback: Callback): void;
-}
-
-interface Signal<T> extends Readable<T>, Writable<T>, Comparable<T>, Peekable<T>, Subscribable {
-}
-interface ReadonlySignal<T> extends Readable<T>, Comparable<T>, Peekable<T>, Subscribable {
-}
-interface SignalFactory {
-    <T>(value: T, equals?: Equals<T>): Signal<T>;
-}
-declare function signal<T>(value: T, equals?: Equals<T>): Signal<T>;
-
-interface ComposedFactory {
-    <T>(value: ReadonlySignal<T>, write: Write<T>): Signal<T>;
-}
-declare function composed<T>(value: ReadonlySignal<T>, write: Write<T>): Signal<T>;
-
-interface ComputedFactory {
-    <T>(compute: () => T, equals?: Equals<T>): ReadonlySignal<T>;
-}
-declare function computed<T>(compute: () => T, equals?: Equals<T>): ReadonlySignal<T>;
-
-interface Ignore {
-    ignore<Value>(callback: () => Value): Value;
-    ignore<Value, Args extends any[]>(callback: Callable<Args, Value>, ...args: Args): Value;
-}
-declare function ignore<Value>(callback: () => Value): Value;
-declare function ignore<Value, Args extends any[]>(callback: Callable<Args, Value>, ...args: Args): Value;
-
-interface CollectorState {
-    collecting(): boolean;
-}
-interface CollectorTarget<T> extends CollectorState {
-    add(value: T): void;
-}
-interface Collector<T> extends CollectorState {
-    collect<Value>(callback: () => Value): [Value, Readonly<Set<T>>];
-    collect<Value, Args extends any[]>(callback: Callable<Args, Value>, ...args: Args): [Value, Readonly<Set<T>>];
-}
-
-interface Tracker<T> {
-    track(value: T): void;
-}
-
-interface DependencyState {
-    changed(): boolean;
-}
-interface DependencyObserver extends DependencyState, Tracker<Callback> {
-}
-interface DependencyTracker extends DependencyObserver, Subscribable {
-}
-
-interface Scheduler<T> {
-    schedule(...value: T[]): void;
-}
-
-declare class CollectorBasedBatcher implements Batcher {
-    private readonly collector;
-    constructor(collector: Collector<Callback>);
-    batch<Value>(callback: () => Value): Value;
-    batch<Value, Args extends any[]>(callback: Callable<Args, Value>, ...args: Args): Value;
-}
-
-type Maybe<T> = T | null | undefined;
-
-declare class CollectorController<T> implements Collector<T>, CollectorTarget<T>, CollectorState, Ignore, Tracker<T> {
-    private values;
-    constructor(values?: Maybe<Set<T>>);
-    collecting(): boolean;
-    add(value: T): void;
-    track(value: T): void;
-    collect<Value>(callback: () => Value): [Value, Readonly<Set<T>>];
-    collect<Value, Args extends any[]>(callback: Callable<Args, Value>, ...args: Args): [Value, Readonly<Set<T>>];
-    ignore<Value>(callback: () => Value): Value;
-    ignore<Value, Args extends any[]>(callback: Callable<Args, Value>, ...args: Args): Value;
-}
-
-declare class Composed<T> implements Signal<T> {
-    private readonly value;
-    private readonly writer;
-    constructor(value: ReadonlySignal<T>, writer: Writable<T>);
-    read(): T;
-    peek(): T;
-    write(value: T): boolean;
-    equals(other: T): boolean;
-    equals(value: T, other: T): boolean;
-    subscribe(callback: Callback): Callback;
-    unsubscribe(callback: Callback): void;
-}
-
-type Snapshot = [ReadonlySignal<unknown>, unknown];
-declare namespace Snapshot {
-    function changed([value, snapshot]: Snapshot): boolean;
-    function from(values: Set<ReadonlySignal<unknown>>): Snapshot[];
-}
-declare class DependencyManager implements DependencyTracker {
-    private snapshot;
-    private dependencies;
-    private readonly collector;
-    private readonly listeners;
-    constructor(collector: Collector<ReadonlySignal<unknown>>, listeners?: Set<Callback>, dependencies?: Set<ReadonlySignal<unknown>>, snapshot?: Maybe<Snapshot[]>);
-    changed(): boolean;
-    track(callback: Callback): void;
-    subscribe(callback: Callback): Callback;
-    unsubscribe(callback: Callback): void;
-    private equals;
-}
-
-interface Emitter {
-    emit(): void;
-}
-
-declare class ScheduledEmitter implements Emitter, Subscribable {
-    private readonly listeners;
-    private readonly scheduler;
-    constructor(scheduler: Scheduler<Callback>, listeners?: Set<Callback>);
-    emit(): void;
-    subscribe(callback: Callback): Callback;
-    unsubscribe(callback: Callback): void;
-}
-
-interface Value<T> extends Readable<T>, Writable<T>, Comparable<T> {
-}
-
-declare class Reactive<T> implements Signal<T> {
-    private readonly value;
-    private readonly tracker;
-    private readonly subscription;
-    constructor(value: Value<T>, tracker: Tracker<ReadonlySignal<unknown>>, subscription: Subscribable);
-    read(): T;
-    peek(): T;
-    write(value: T): boolean;
-    equals(other: T): boolean;
-    equals(value: T, other: T): boolean;
-    subscribe(callback: Callback): Callback;
-    unsubscribe(callback: Callback): void;
-}
-
-declare class CallbackScheduler implements Scheduler<Callback> {
-    private readonly collector;
-    private readonly add;
-    constructor(collector: CollectorTarget<Callback>);
-    schedule(...args: Callback[]): void;
-}
-
-declare class BasicValue<T> implements Value<T> {
-    private value;
-    private readonly comparator;
-    constructor(value: T, comparator: Comparator<T>);
-    read(): T;
-    write(value: T): boolean;
-    equals(other: T): boolean;
-    equals(value: T, other: T): boolean;
-}
-declare class EmittingValue<T> {
-    private readonly value;
-    private readonly emitter;
-    constructor(value: Value<T>, emitter: Emitter);
-    read(): T;
-    write(value: T): boolean;
-    equals(other: T): boolean;
-    equals(value: T, other: T): boolean;
-}
-declare class ComputedValue<T> implements Value<T> {
-    private readonly cache;
-    private readonly computation;
-    private readonly dependencies;
-    constructor(cache: Value<T>, computation: Readable<T>, dependencies: DependencyObserver);
-    read(): T;
-    private recompute;
-    write(_: T): boolean;
-    equals(other: T): boolean;
-    equals(value: T, other: T): boolean;
-}
-
-declare class BatchWriter<T> implements Writable<T> {
-    private readonly writer;
-    private readonly batcher;
-    constructor(writer: Writable<T>, batcher: Batcher);
-    write(value: T): boolean;
-}
-
-type internal_BasicValue<T> = BasicValue<T>;
-declare const internal_BasicValue: typeof BasicValue;
-type internal_BatchWriter<T> = BatchWriter<T>;
-declare const internal_BatchWriter: typeof BatchWriter;
-type internal_CallbackScheduler = CallbackScheduler;
-declare const internal_CallbackScheduler: typeof CallbackScheduler;
-type internal_CollectorBasedBatcher = CollectorBasedBatcher;
-declare const internal_CollectorBasedBatcher: typeof CollectorBasedBatcher;
-type internal_CollectorController<T> = CollectorController<T>;
-declare const internal_CollectorController: typeof CollectorController;
-type internal_Composed<T> = Composed<T>;
-declare const internal_Composed: typeof Composed;
-type internal_ComputedValue<T> = ComputedValue<T>;
-declare const internal_ComputedValue: typeof ComputedValue;
-type internal_DependencyManager = DependencyManager;
-declare const internal_DependencyManager: typeof DependencyManager;
-type internal_EmittingValue<T> = EmittingValue<T>;
-declare const internal_EmittingValue: typeof EmittingValue;
-type internal_Reactive<T> = Reactive<T>;
-declare const internal_Reactive: typeof Reactive;
-type internal_ScheduledEmitter = ScheduledEmitter;
-declare const internal_ScheduledEmitter: typeof ScheduledEmitter;
-declare const internal_Snapshot: typeof Snapshot;
-declare namespace internal {
-  export { internal_BasicValue as BasicValue, internal_BatchWriter as BatchWriter, internal_CallbackScheduler as CallbackScheduler, internal_CollectorBasedBatcher as CollectorBasedBatcher, internal_CollectorController as CollectorController, internal_Composed as Composed, internal_ComputedValue as ComputedValue, internal_DependencyManager as DependencyManager, internal_EmittingValue as EmittingValue, internal_Reactive as Reactive, internal_ScheduledEmitter as ScheduledEmitter, internal_Snapshot as Snapshot };
-}
-
-declare function call(callback: Callback): void;
-
-type Factory<FactoryFunction extends Callable> = FactoryFunction & {
-    factory(factory: Maybe<FactoryFunction>): void;
-    default(factory: Maybe<FactoryFunction>): void;
-    configured(): boolean;
-};
-declare function factory<FactoryFunction extends Callable>(name: string): Factory<FactoryFunction>;
-
-declare function singleton<T>(factory: () => T): {
-    (): T;
-    instance: T | undefined;
-};
-
-type utils_Factory<FactoryFunction extends Callable> = Factory<FactoryFunction>;
-declare const utils_call: typeof call;
-declare const utils_factory: typeof factory;
-declare const utils_singleton: typeof singleton;
-declare namespace utils {
-  export { type utils_Factory as Factory, utils_call as call, utils_factory as factory, utils_singleton as singleton };
-}
-
-declare function configuration(): {
-    signal: Factory<SignalFactory>;
-    computed: Factory<ComputedFactory>;
-    composed: Factory<ComposedFactory>;
-    batcher: Factory<() => Batcher>;
-    ignorer: Factory<() => Ignore>;
-    scheduler: Factory<() => Scheduler<Callback>>;
-    tracker: Factory<() => Tracker<ReadonlySignal<unknown>>>;
-    collector: Factory<() => Collector<ReadonlySignal<unknown>>>;
-    dependency_tracker: Factory<() => DependencyTracker>;
-    dependency_collector: Factory<() => CollectorController<ReadonlySignal<unknown>>>;
-    callback_collector: Factory<() => CollectorController<Callback>>;
-};
-
-export { type Batcher, type Callable, type Callback, type Collector, type CollectorState, type CollectorTarget, type Comparable, type Comparator, type ComposedFactory, type ComputedFactory, type DependencyObserver, type DependencyState, type DependencyTracker, type Emitter, Equals, type Ignore, internal as Internal, type Maybe, type Peekable, type Readable, type ReadonlySignal, type Scheduler, type Signal, type SignalFactory, type Subscribable, type Tracker, type Value, type Writable, type Write, batch, comparator, composed, computed, configuration, ignore, reader, signal, utils, writer };