@valentin30/signal 0.1.0 → 1.0.0

package/dist/index.d.mts

@@ -1,194 +0,0 @@
-type Callable = (...args: any[]) => any;
-
-type Maybe<T> = T | null | undefined;
-
-type Factory<Fn extends Callable> = Fn & {
-    factory(factory: Maybe<Fn>): void;
-    default(factory: Maybe<Fn>): void;
-    configured(): boolean;
-};
-declare function factory<Fn extends Callable>(name: string): Factory<Fn>;
-
-type Callback = () => void;
-
-interface Collector<T> {
-    add(value: T): void;
-    collecting(): boolean;
-    collect(callback: Callback): Readonly<Set<T>>;
-    ignore(callback: Callback): void;
-}
-type CollectorFactory = <T>() => Collector<T>;
-declare const collector: Factory<CollectorFactory>;
-
-declare function internal_batch(callback: Callback): void;
-declare function internal_batch(callback: Callback, collector: Collector<Callback>): void;
-declare function internal_batch(callback: Callback, collector?: Collector<Callback>): void;
-declare namespace internal_batch {
-    const collector: Factory<collector.Factory>;
-    namespace collector {
-        type Factory = () => Collector<Callback>;
-    }
-}
-
-declare function internal_collector<T>(): Collector<T>;
-declare namespace internal_collector {
-    class Constructor<T> implements Collector<T> {
-        #private;
-        constructor(values: Set<T> | null);
-        collecting(): boolean;
-        add(value: T): void;
-        collect(callback: Callback): Set<T>;
-        ignore(callback: Callback): void;
-    }
-}
-
-interface Comparable<T> {
-    equals(other: T): boolean;
-}
-
-interface Readable<T> {
-    read(): T;
-}
-
-interface Subscribable {
-    subscribe(callback: Callback): Callback;
-    unsubscribe(callback: Callback): void;
-}
-
-interface Writable<T> {
-    write(value: T): void;
-}
-
-type Equals<T> = (value: T, other: T) => boolean;
-
-interface Peekable<T> {
-    peek(): T;
-}
-
-interface Signal<T> extends Readable<T>, Writable<T>, Peekable<T>, Comparable<T>, Subscribable {
-}
-interface ReadonlySignal<T> extends Readable<T>, Peekable<T>, Comparable<T>, Subscribable {
-}
-type SignalFactory = <T>(value: T, equals?: Equals<T>) => Signal<T>;
-declare const signal: Factory<SignalFactory>;
-
-declare function internal_computed<T>(compute: () => T, equals?: Equals<T>): internal_computed.Constructor<T>;
-declare namespace internal_computed {
-    const collector: Factory<collector.Factory>;
-    namespace collector {
-        type Factory = () => Collector<ReadonlySignal<unknown>>;
-    }
-    class Constructor<T> implements ReadonlySignal<T> {
-        #private;
-        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>>);
-        read(): T;
-        peek(): T;
-        equals(other: T): boolean;
-        subscribe(callback: Callback): Callback;
-        unsubscribe(callback: Callback): void;
-    }
-}
-
-declare function internal_composed<T>(compute: () => T, write: (value: T) => void, equals?: Equals<T>): internal_composed.Constructor<T>;
-declare namespace internal_composed {
-    const batcher: Factory<batcher.Factory>;
-    namespace batcher {
-        type Factory = () => Collector<Callback>;
-    }
-    const collector: Factory<collector.Factory>;
-    namespace collector {
-        type Factory = () => Collector<ReadonlySignal<unknown>>;
-    }
-    class Constructor<T> extends internal_computed.Constructor<T> implements Signal<T> {
-        #private;
-        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>>);
-        write(value: T): void;
-    }
-}
-
-type Effect = (callback: EffectCallback) => Callback;
-type EffectCallback = (init: boolean) => EffectCleanup | void;
-type EffectCleanup = (destroy: boolean) => void;
-declare const effect: Factory<Effect>;
-
-declare function internal_effect(cb: EffectCallback): Callback;
-declare namespace internal_effect {
-    const collector: Factory<collector.Factory>;
-    namespace collector {
-        type Factory = () => Collector<ReadonlySignal<unknown>>;
-    }
-}
-
-declare function internal_ignore<Value>(value: ReadonlySignal<Value>): Value;
-declare function internal_ignore<Value>(callback: () => Value): Value;
-declare function internal_ignore<Value, Args extends any[]>(callback: (...args: Args) => Value, ...args: Args): Value;
-declare namespace internal_ignore {
-    const collector: Factory<collector.Factory>;
-    namespace collector {
-        type Factory = () => Collector<ReadonlySignal<unknown>>;
-    }
-}
-
-declare namespace internal_shared {
-    function batcher(): Collector<Callback>;
-    function collector(): Collector<ReadonlySignal<unknown>>;
-}
-
-declare function internal_signal<T>(value: T, equals?: Equals<T>): Signal<T>;
-declare namespace internal_signal {
-    const batcher: Factory<batcher.Factory>;
-    namespace batcher {
-        type Factory = () => Collector<Callback>;
-    }
-    const collector: Factory<collector.Factory>;
-    namespace collector {
-        type Factory = () => Collector<ReadonlySignal<unknown>>;
-    }
-    class Constructor<T> implements Signal<T> {
-        #private;
-        constructor(value: T, equals: Maybe<Equals<T>>, listeners: Set<Callback>, batcher: Collector<Callback>, collector: Collector<ReadonlySignal<unknown>>);
-        read(): T;
-        peek(): T;
-        write(value: T): void;
-        equals(other: T): boolean;
-        subscribe(callback: Callback): Callback;
-        unsubscribe(callback: Callback): void;
-    }
-}
-
-declare namespace index {
-  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 };
-}
-
-interface Batch {
-    (callback: Callback): void;
-    (callback: Callback, collector: Collector<Callback>): void;
-    (callback: Callback, collector?: Collector<Callback>): void;
-}
-declare const batch: Factory<Batch>;
-
-type ComposedFactory = <T>(read: () => T, write: (value: T) => void, equals?: Equals<T>) => Signal<T>;
-declare const composed: Factory<ComposedFactory>;
-
-type ComputedFactory = <T>(read: () => T, equals?: Equals<T>) => ReadonlySignal<T>;
-declare const computed: Factory<ComputedFactory>;
-
-interface Ignore {
-    <Value>(value: ReadonlySignal<Value>): Value;
-    <Value>(callback: () => Value): Value;
-    <Value, Args extends any[]>(callback: (...args: Args) => Value, ...args: Args): Value;
-}
-declare const ignore: Factory<Ignore>;
-
-interface Config {
-    collector?: Maybe<CollectorFactory>;
-    signal?: Maybe<SignalFactory>;
-    computed?: Maybe<ComputedFactory>;
-    composed?: Maybe<ComposedFactory>;
-    effect?: Maybe<Effect>;
-    batch?: Maybe<Batch>;
-    ignore?: Maybe<Ignore>;
-}
-declare function config(config?: Config): void;
-
-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

@@ -1,194 +0,0 @@
-type Callable = (...args: any[]) => any;
-
-type Maybe<T> = T | null | undefined;
-
-type Factory<Fn extends Callable> = Fn & {
-    factory(factory: Maybe<Fn>): void;
-    default(factory: Maybe<Fn>): void;
-    configured(): boolean;
-};
-declare function factory<Fn extends Callable>(name: string): Factory<Fn>;
-
-type Callback = () => void;
-
-interface Collector<T> {
-    add(value: T): void;
-    collecting(): boolean;
-    collect(callback: Callback): Readonly<Set<T>>;
-    ignore(callback: Callback): void;
-}
-type CollectorFactory = <T>() => Collector<T>;
-declare const collector: Factory<CollectorFactory>;
-
-declare function internal_batch(callback: Callback): void;
-declare function internal_batch(callback: Callback, collector: Collector<Callback>): void;
-declare function internal_batch(callback: Callback, collector?: Collector<Callback>): void;
-declare namespace internal_batch {
-    const collector: Factory<collector.Factory>;
-    namespace collector {
-        type Factory = () => Collector<Callback>;
-    }
-}
-
-declare function internal_collector<T>(): Collector<T>;
-declare namespace internal_collector {
-    class Constructor<T> implements Collector<T> {
-        #private;
-        constructor(values: Set<T> | null);
-        collecting(): boolean;
-        add(value: T): void;
-        collect(callback: Callback): Set<T>;
-        ignore(callback: Callback): void;
-    }
-}
-
-interface Comparable<T> {
-    equals(other: T): boolean;
-}
-
-interface Readable<T> {
-    read(): T;
-}
-
-interface Subscribable {
-    subscribe(callback: Callback): Callback;
-    unsubscribe(callback: Callback): void;
-}
-
-interface Writable<T> {
-    write(value: T): void;
-}
-
-type Equals<T> = (value: T, other: T) => boolean;
-
-interface Peekable<T> {
-    peek(): T;
-}
-
-interface Signal<T> extends Readable<T>, Writable<T>, Peekable<T>, Comparable<T>, Subscribable {
-}
-interface ReadonlySignal<T> extends Readable<T>, Peekable<T>, Comparable<T>, Subscribable {
-}
-type SignalFactory = <T>(value: T, equals?: Equals<T>) => Signal<T>;
-declare const signal: Factory<SignalFactory>;
-
-declare function internal_computed<T>(compute: () => T, equals?: Equals<T>): internal_computed.Constructor<T>;
-declare namespace internal_computed {
-    const collector: Factory<collector.Factory>;
-    namespace collector {
-        type Factory = () => Collector<ReadonlySignal<unknown>>;
-    }
-    class Constructor<T> implements ReadonlySignal<T> {
-        #private;
-        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>>);
-        read(): T;
-        peek(): T;
-        equals(other: T): boolean;
-        subscribe(callback: Callback): Callback;
-        unsubscribe(callback: Callback): void;
-    }
-}
-
-declare function internal_composed<T>(compute: () => T, write: (value: T) => void, equals?: Equals<T>): internal_composed.Constructor<T>;
-declare namespace internal_composed {
-    const batcher: Factory<batcher.Factory>;
-    namespace batcher {
-        type Factory = () => Collector<Callback>;
-    }
-    const collector: Factory<collector.Factory>;
-    namespace collector {
-        type Factory = () => Collector<ReadonlySignal<unknown>>;
-    }
-    class Constructor<T> extends internal_computed.Constructor<T> implements Signal<T> {
-        #private;
-        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>>);
-        write(value: T): void;
-    }
-}
-
-type Effect = (callback: EffectCallback) => Callback;
-type EffectCallback = (init: boolean) => EffectCleanup | void;
-type EffectCleanup = (destroy: boolean) => void;
-declare const effect: Factory<Effect>;
-
-declare function internal_effect(cb: EffectCallback): Callback;
-declare namespace internal_effect {
-    const collector: Factory<collector.Factory>;
-    namespace collector {
-        type Factory = () => Collector<ReadonlySignal<unknown>>;
-    }
-}
-
-declare function internal_ignore<Value>(value: ReadonlySignal<Value>): Value;
-declare function internal_ignore<Value>(callback: () => Value): Value;
-declare function internal_ignore<Value, Args extends any[]>(callback: (...args: Args) => Value, ...args: Args): Value;
-declare namespace internal_ignore {
-    const collector: Factory<collector.Factory>;
-    namespace collector {
-        type Factory = () => Collector<ReadonlySignal<unknown>>;
-    }
-}
-
-declare namespace internal_shared {
-    function batcher(): Collector<Callback>;
-    function collector(): Collector<ReadonlySignal<unknown>>;
-}
-
-declare function internal_signal<T>(value: T, equals?: Equals<T>): Signal<T>;
-declare namespace internal_signal {
-    const batcher: Factory<batcher.Factory>;
-    namespace batcher {
-        type Factory = () => Collector<Callback>;
-    }
-    const collector: Factory<collector.Factory>;
-    namespace collector {
-        type Factory = () => Collector<ReadonlySignal<unknown>>;
-    }
-    class Constructor<T> implements Signal<T> {
-        #private;
-        constructor(value: T, equals: Maybe<Equals<T>>, listeners: Set<Callback>, batcher: Collector<Callback>, collector: Collector<ReadonlySignal<unknown>>);
-        read(): T;
-        peek(): T;
-        write(value: T): void;
-        equals(other: T): boolean;
-        subscribe(callback: Callback): Callback;
-        unsubscribe(callback: Callback): void;
-    }
-}
-
-declare namespace index {
-  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 };
-}
-
-interface Batch {
-    (callback: Callback): void;
-    (callback: Callback, collector: Collector<Callback>): void;
-    (callback: Callback, collector?: Collector<Callback>): void;
-}
-declare const batch: Factory<Batch>;
-
-type ComposedFactory = <T>(read: () => T, write: (value: T) => void, equals?: Equals<T>) => Signal<T>;
-declare const composed: Factory<ComposedFactory>;
-
-type ComputedFactory = <T>(read: () => T, equals?: Equals<T>) => ReadonlySignal<T>;
-declare const computed: Factory<ComputedFactory>;
-
-interface Ignore {
-    <Value>(value: ReadonlySignal<Value>): Value;
-    <Value>(callback: () => Value): Value;
-    <Value, Args extends any[]>(callback: (...args: Args) => Value, ...args: Args): Value;
-}
-declare const ignore: Factory<Ignore>;
-
-interface Config {
-    collector?: Maybe<CollectorFactory>;
-    signal?: Maybe<SignalFactory>;
-    computed?: Maybe<ComputedFactory>;
-    composed?: Maybe<ComposedFactory>;
-    effect?: Maybe<Effect>;
-    batch?: Maybe<Batch>;
-    ignore?: Maybe<Ignore>;
-}
-declare function config(config?: Config): void;
-
-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 };