@valentin30/signal 0.1.0 → 1.0.0

package/src/modules/sources/dynamic.ts

@@ -0,0 +1,73 @@
+import { Consumer } from '@valentin30/signal/core/contracts/consumer'
+import { Source } from '@valentin30/signal/core/contracts/source'
+import { Sources } from '@valentin30/signal/core/interfaces/sources'
+import { Addable } from '@valentin30/signal/modules/common/contracts/addable'
+import { Callable } from '@valentin30/signal/modules/common/types/callable'
+import { unsafe_swap } from '@valentin30/signal/modules/common/utils/swap'
+
+type Track = <Target extends Addable<Source>, Args extends any[], ReturnType>(
+    target: Target,
+    callback: Callable<Args, ReturnType>,
+    ...args: Args
+) => ReturnType
+
+export function DynamicSourcesFactory(track: Track) {
+    class DynamicSources<T> implements Sources<T>, Addable<Source> {
+        private current: Map<Source, number>
+
+        private previous: Map<Source, number>
+
+        private consumer: Consumer | null
+
+        private readonly computation: () => T
+
+        constructor(computation: () => T) {
+            this.consumer = null
+            this.current = new Map<Source, number>()
+            this.previous = new Map<Source, number>()
+            this.computation = computation
+        }
+
+        public link(consumer: Consumer): void {
+            if (this.consumer !== null) return
+            this.consumer = consumer
+            for (const source of this.current.keys()) source.link(consumer)
+        }
+
+        public unlink(consumer: Consumer): void {
+            if (this.consumer === null || this.consumer !== consumer) return
+            this.consumer = null
+            for (const source of this.current.keys()) source.unlink(consumer)
+        }
+
+        public changed(): boolean {
+            for (const [source, version] of this.current) {
+                if (source.version() !== version) return true
+            }
+            return false
+        }
+
+        public compute(): T {
+            try {
+                unsafe_swap(this, 'previous', this, 'current')
+                const result = track(this, this.computation)
+                if (this.consumer !== null) {
+                    for (const source of this.previous.keys()) source.unlink(this.consumer)
+                }
+                return result
+            } finally {
+                this.previous.clear()
+            }
+        }
+
+        public add(source: Source): void {
+            this.current.set(source, source.version())
+            this.previous.delete(source)
+            if (this.consumer !== null) source.link(this.consumer)
+        }
+    }
+
+    return function dynamic_sources<T>(computation: () => T): Sources<T> {
+        return new DynamicSources(computation)
+    }
+}

package/src/modules/sources/static.ts

@@ -0,0 +1,49 @@
+import { Consumer } from '@valentin30/signal/core/contracts/consumer'
+import { Source } from '@valentin30/signal/core/contracts/source'
+import { Sources } from '@valentin30/signal/core/interfaces/sources'
+
+function version(source: Source): number {
+    return source.version()
+}
+
+export function StaticSourcesFactory() {
+    class StaticSources<T> implements Sources<T> {
+        private readonly sources: Source[]
+
+        private readonly versioning: number[]
+
+        private readonly computation: () => T
+
+        constructor(computation: () => T, sources: Source[]) {
+            this.sources = sources
+            this.versioning = sources.map(version)
+            this.computation = computation
+        }
+
+        public link(consumer: Consumer): void {
+            for (const source of this.sources) source.link(consumer)
+        }
+
+        public unlink(consumer: Consumer): void {
+            for (const source of this.sources) source.unlink(consumer)
+        }
+
+        public changed(): boolean {
+            for (let i = 0; i < this.sources.length; i++) {
+                if (this.versioning[i] !== this.sources[i].version()) return true
+            }
+            return false
+        }
+
+        public compute(): T {
+            for (let i = 0; i < this.sources.length; i++) {
+                this.versioning[i] = this.sources[i].version()
+            }
+            return this.computation()
+        }
+    }
+
+    return function static_sources<T>(computation: () => T, sources: Source[]): Sources<T> {
+        return new StaticSources(computation, sources)
+    }
+}

package/src/modules/value/factory.ts

@@ -0,0 +1,29 @@
+import { Value } from '@valentin30/signal/core/interfaces/value'
+
+export function ValueFactory(compare: <T>(a: T, b: T) => boolean) {
+    class V<T> implements Value<T> {
+        private value: T
+
+        constructor(value: T) {
+            this.value = value
+        }
+
+        public read(): T {
+            return this.value
+        }
+
+        public write(value: T): boolean {
+            if (this.compare(this.read(), value)) return false
+            this.value = value
+            return true
+        }
+
+        public compare(a: T, b: T): boolean {
+            return compare(a, b)
+        }
+    }
+
+    return function v<T>(value: T): Value<T> {
+        return new V(value)
+    }
+}

package/src/packages/builder/consumers.ts

@@ -0,0 +1,11 @@
+import { Consumers } from '@valentin30/signal/core/interfaces/consumers'
+import { ConsumersFactory } from '@valentin30/signal/modules/consumers/factory'
+
+const factory = ConsumersFactory()
+
+export type { Consumer } from '@valentin30/signal/core/contracts/consumer'
+export type { Consumers } from '@valentin30/signal/core/interfaces/consumers'
+
+export function consumers(): Consumers {
+    return factory()
+}

package/src/packages/builder/node.ts

@@ -0,0 +1,16 @@
+import { Node } from '@valentin30/signal/modules/node'
+import { NodeFactory } from '@valentin30/signal/modules/node/factory'
+import { NodeSource } from '@valentin30/signal/modules/node/source'
+import { register } from '@valentin30/signal/runtime/context'
+
+const factory = NodeFactory(register)
+
+export type { Consumer } from '@valentin30/signal/core/contracts/consumer'
+export type { Source } from '@valentin30/signal/core/contracts/source'
+export type { Value } from '@valentin30/signal/core/interfaces/value'
+export type { Node } from '@valentin30/signal/modules/node'
+export type { NodeSource } from '@valentin30/signal/modules/node/source'
+
+export function node<T>(source: NodeSource<T>): Node<T> {
+    return factory(source)
+}

package/src/packages/builder/sources.ts

@@ -0,0 +1,18 @@
+import { Source } from '@valentin30/signal/core/contracts/source'
+import { Sources } from '@valentin30/signal/core/interfaces/sources'
+
+import { DynamicSourcesFactory } from '@valentin30/signal/modules/sources/dynamic'
+import { StaticSourcesFactory } from '@valentin30/signal/modules/sources/static'
+import { track } from '@valentin30/signal/runtime/context'
+
+const static_sources = StaticSourcesFactory()
+const dynamic_sources = DynamicSourcesFactory(track)
+
+export type { Consumer } from '@valentin30/signal/core/contracts/consumer'
+export type { Source } from '@valentin30/signal/core/contracts/source'
+export type { Sources } from '@valentin30/signal/core/interfaces/sources'
+
+export function sources<T>(compute: () => T, dependencies?: Source[]): Sources<T> {
+    if (dependencies) return static_sources(compute, dependencies)
+    return dynamic_sources(compute)
+}

package/src/packages/builder/value.ts

@@ -0,0 +1,11 @@
+import { Value } from '@valentin30/signal/core/interfaces/value'
+import { strict_compare } from '@valentin30/signal/modules/common/utils/compare'
+import { ValueFactory } from '@valentin30/signal/modules/value/factory'
+
+const factory = ValueFactory(strict_compare)
+
+export type { Value } from '@valentin30/signal/core/interfaces/value'
+
+export function value<T>(value: T): Value<T> {
+    return factory(value)
+}

package/src/packages/builder.ts

@@ -0,0 +1,4 @@
+export * from '@valentin30/signal/packages/builder/value'
+export * from '@valentin30/signal/packages/builder/node'
+export * from '@valentin30/signal/packages/builder/sources'
+export * from '@valentin30/signal/packages/builder/consumers'

package/src/packages/core/computed.ts

@@ -0,0 +1,15 @@
+import { Computed } from '@valentin30/signal/core/computed'
+import { Source } from '@valentin30/signal/core/contracts/source'
+import { Node } from '@valentin30/signal/modules/node'
+import { consumers } from '@valentin30/signal/packages/builder/consumers'
+import { node } from '@valentin30/signal/packages/builder/node'
+import { sources } from '@valentin30/signal/packages/builder/sources'
+import { value } from '@valentin30/signal/packages/builder/value'
+
+export type { Consumer } from '@valentin30/signal/core/contracts/consumer'
+export type { Source } from '@valentin30/signal/core/contracts/source'
+export type { Node } from '@valentin30/signal/modules/node'
+
+export function computed<T>(compute: () => T, deps?: Source[]): Node<T> {
+    return node(new Computed(value(<T>undefined), sources(compute, deps), consumers()))
+}

package/src/packages/core/context.ts

@@ -0,0 +1,5 @@
+export type { Consumer } from '@valentin30/signal/core/contracts/consumer'
+export type { Source } from '@valentin30/signal/core/contracts/source'
+export type { Addable } from '@valentin30/signal/modules/common/contracts/addable'
+export type { Callable } from '@valentin30/signal/modules/common/types/callable'
+export { register, scope, track, untrack } from '@valentin30/signal/runtime/context'

package/src/packages/core/scheduler.ts

@@ -0,0 +1,5 @@
+export type { Callable } from '@valentin30/signal/modules/common/types/callable'
+export type { Callback } from '@valentin30/signal/modules/common/types/callback'
+export type { Dispatch } from '@valentin30/signal/modules/scheduler/dispatch'
+export type { Runner } from '@valentin30/signal/modules/scheduler/runner'
+export { batch, dequeue, enqueue, flush, schedule } from '@valentin30/signal/runtime/scheduler'

package/src/packages/core/signal.ts

@@ -0,0 +1,12 @@
+import { Signal } from '@valentin30/signal/core/signal'
+import { consumers } from '@valentin30/signal/packages/builder/consumers'
+import { Node, node } from '@valentin30/signal/packages/builder/node'
+import { value } from '@valentin30/signal/packages/builder/value'
+
+export type { Consumer } from '@valentin30/signal/core/contracts/consumer'
+export type { Source } from '@valentin30/signal/core/contracts/source'
+export type { Node } from '@valentin30/signal/modules/node'
+
+export function signal<T>(initial: T): Node<T> {
+    return node(new Signal(value(initial), consumers()))
+}

package/src/packages/core.ts

@@ -0,0 +1,2 @@
+export * from '@valentin30/signal/packages/core/computed'
+export * from '@valentin30/signal/packages/core/signal'

package/src/packages/event/channel.ts

@@ -0,0 +1,17 @@
+import { Source } from '@valentin30/signal/core/contracts/source'
+import { Channel } from '@valentin30/signal/modules/event/channel'
+import { ChannelFactory } from '@valentin30/signal/modules/event/channel'
+import { dequeue, enqueue } from '@valentin30/signal/runtime/scheduler'
+
+const factory = ChannelFactory(enqueue, dequeue)
+
+export type { Consumer } from '@valentin30/signal/core/contracts/consumer'
+export type { Source } from '@valentin30/signal/core/contracts/source'
+export type { Channel } from '@valentin30/signal/modules/event/channel'
+export type { Disposable } from '@valentin30/signal/modules/common/contracts/disposable'
+export type { Subscriber } from '@valentin30/signal/modules/common/contracts/subscriber'
+export type { Callback } from '@valentin30/signal/modules/common/types/callback'
+
+export function channel(...sources: Source[]): Channel {
+    return factory(...sources)
+}

package/src/packages/event/effect.ts

@@ -0,0 +1,15 @@
+import { Source } from '@valentin30/signal/core/contracts/source'
+import { Callback } from '@valentin30/signal/modules/common/types/callback'
+import { EffectFactory } from '@valentin30/signal/modules/event/effect'
+import { sources } from '@valentin30/signal/packages/builder/sources'
+import { dequeue, enqueue } from '@valentin30/signal/runtime/scheduler'
+
+const factory = EffectFactory(enqueue, dequeue)
+
+export type { Consumer } from '@valentin30/signal/core/contracts/consumer'
+export type { Source } from '@valentin30/signal/core/contracts/source'
+export type { Callback } from '@valentin30/signal/modules/common/types/callback'
+
+export function effect(callback: () => Callback | void, dependencies?: Source[]): Callback {
+    return factory(sources(callback, dependencies))
+}

package/src/packages/event/notifier.ts

@@ -0,0 +1,14 @@
+import { Source } from '@valentin30/signal/core/contracts/source'
+import { Callback } from '@valentin30/signal/modules/common/types/callback'
+import { NotifierFactory } from '@valentin30/signal/modules/event/notifier'
+import { dequeue, enqueue } from '@valentin30/signal/runtime/scheduler'
+
+const factory = NotifierFactory(enqueue, dequeue)
+
+export type { Consumer } from '@valentin30/signal/core/contracts/consumer'
+export type { Source } from '@valentin30/signal/core/contracts/source'
+export type { Callback } from '@valentin30/signal/modules/common/types/callback'
+
+export function notifier(source: Source, callback: Callback): Callback {
+    return factory(source, callback)
+}

package/src/packages/event.ts

@@ -0,0 +1,3 @@
+export * from '@valentin30/signal/packages/event/channel'
+export * from '@valentin30/signal/packages/event/effect'
+export * from '@valentin30/signal/packages/event/notifier'

package/src/packages/react/use-computed.ts

@@ -0,0 +1,9 @@
+import { computed, Node, Source } from '@valentin30/signal/packages/core/computed'
+import { useState } from 'react'
+
+export type { Consumer, Node, Source } from '@valentin30/signal/packages/core/computed'
+
+export function useComputed<T>(compute: () => T, deps?: Source[]): Node<T> {
+    const [result] = useState<Node<T>>(() => computed(compute, deps))
+    return result
+}

package/src/packages/react/use-read.ts

@@ -0,0 +1,23 @@
+import { Node } from '@valentin30/signal/modules/node'
+import { notifier } from '@valentin30/signal/packages/event/notifier'
+import { useEffect, useState } from 'react'
+
+export type { Consumer } from '@valentin30/signal/core/contracts/consumer'
+export type { Source } from '@valentin30/signal/core/contracts/source'
+export type { Node } from '@valentin30/signal/modules/node'
+
+export function useRead<T>(source: Node<T>): T
+export function useRead<T>(source: Node<T> | null | undefined): T | null
+export function useRead<T>(source: Node<T> | null | undefined): T | null {
+    const [value, setValue] = useState<T>(() => {
+        if (!source) return null as T
+        return source.read()
+    })
+
+    useEffect(() => {
+        if (!source) return
+        return notifier(source, () => setValue(source.read()))
+    }, [source])
+
+    return value
+}

package/src/packages/react/use-signal.ts

@@ -0,0 +1,9 @@
+import { Node, signal } from '@valentin30/signal/packages/core/signal'
+import { useState } from 'react'
+
+export type { Consumer, Node, Source } from '@valentin30/signal/packages/core/signal'
+
+export function useSignal<T>(initial: T): Node<T> {
+    const [result] = useState<Node<T>>(() => signal(initial))
+    return result
+}

package/src/packages/react.ts

@@ -0,0 +1,3 @@
+export * from '@valentin30/signal/packages/react/use-computed'
+export * from '@valentin30/signal/packages/react/use-signal'
+export * from '@valentin30/signal/packages/react/use-read'

package/src/runtime/context.ts

@@ -0,0 +1,36 @@
+import { Source } from '@valentin30/signal/core/contracts/source'
+import { Callable } from '@valentin30/signal/modules/common/types/callable'
+import { Addable } from '@valentin30/signal/modules/common/contracts/addable'
+
+let context: Addable<Source> | null = null
+
+export function register(source: Source): void {
+    if (context === null) return
+    context.add(source)
+}
+
+export function scope<Target extends Addable<Source>, Args extends any[], ReturnType>(
+    target: Target | null,
+    callback: Callable<Args, ReturnType>,
+    ...args: Args
+): ReturnType {
+    const current = context
+    context = target
+    try {
+        return callback(...args)
+    } finally {
+        context = current
+    }
+}
+
+export function track<Target extends Addable<Source>, Args extends any[], ReturnType>(
+    target: Target,
+    callback: Callable<Args, ReturnType>,
+    ...args: Args
+): ReturnType {
+    return scope(target, callback, ...args)
+}
+
+export function untrack<ReturnType, Args extends any[]>(callback: Callable<Args, ReturnType>, ...args: Args): ReturnType {
+    return scope(null, callback, ...args)
+}

package/src/runtime/scheduler.ts

@@ -0,0 +1,75 @@
+import { Callable } from '@valentin30/signal/modules/common/types/callable'
+import { Callback } from '@valentin30/signal/modules/common/types/callback'
+import { swap } from '@valentin30/signal/modules/common/utils/swap'
+import { Runner } from '@valentin30/signal/modules/scheduler/runner'
+
+let depth = 0
+let is_running = false
+const lookup = new Set<Callback>()
+const runners = {
+    current: new Set<Runner>(),
+    pending: new Set<Runner>(),
+}
+
+let qmt: (callback: Callback) => void
+if (typeof queueMicrotask === 'function') qmt = queueMicrotask
+else qmt = (callback: Callback) => Promise.resolve().then(callback)
+
+export function schedule(): void {
+    if (is_running || depth !== 0) return
+    is_running = true
+    qmt(flush)
+}
+
+export function flush(): void {
+    is_running = false
+
+    if (runners.pending.size === 0) return
+    swap(runners, 'current', runners, 'pending')
+    runners.pending.clear()
+
+    for (const runner of runners.current) runner.run(dispatch)
+
+    lookup.clear()
+    runners.current.clear()
+
+    if (runners.pending.size === 0) return
+    schedule()
+}
+
+export function enqueue(runner: Runner): void {
+    if (!runners.pending.has(runner) && !runners.current.has(runner)) {
+        runners.pending.add(runner)
+    }
+    schedule()
+}
+
+export function dequeue(runner: Runner): void {
+    runners.pending.delete(runner)
+    runners.current.delete(runner)
+}
+
+function dispatch(callback: Callback): void {
+    if (lookup.has(callback)) return
+    lookup.add(callback)
+    try {
+        callback()
+    } catch (error) {
+        console.error(error)
+    }
+}
+
+export async function batch<Args extends any[], ReturnType>(
+    callback: Callable<Args, Promise<ReturnType>>,
+    ...args: Args
+): Promise<ReturnType> {
+    try {
+        depth++
+        return await callback(...args)
+    } catch (error) {
+        throw error
+    } finally {
+        if (depth > 0) depth--
+        schedule()
+    }
+}

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["src/tests", "src/test", "src/**/*.test.ts", "src/**/*.spec.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "module": "esnext",
+    "target": "es2020",
+    "strict": true,
+    "declaration": true,
+    "stripInternal": true,
+    "moduleResolution": "bundler",
+    "outDir": "dist",
+    "baseUrl": "src",
+    "paths": {
+      "@valentin30/signal/*": ["*"]
+    }
+  },
+  "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,53 @@
+import { defineConfig, Options } from 'tsup'
+
+const options: Options = {
+    format: ['esm'],
+    target: 'es2020',
+    outDir: 'dist',
+    clean: false,
+    splitting: true,
+    treeshake: true,
+    skipNodeModulesBundle: true,
+    external: ['react', 'react-dom'],
+    tsconfig: 'tsconfig.build.json',
+}
+
+function config(...names: string[]) {
+    return defineConfig([js(...names), ...names.map(n => dts(n))])
+}
+
+function js(...names: string[]): Options {
+    const entry = names.reduce((acc, name) => ({ ...acc, [name]: 'src/packages/' + name + '.ts' }), {})
+    return { entry, dts: false, ...options }
+}
+
+function dts(...names: string[]): Options {
+    const entry = names.reduce((acc, name) => ({ ...acc, [name]: 'src/packages/' + name + '.ts' }), {})
+    return { entry, dts: { only: true, entry }, ...options }
+}
+
+export default config(
+    //
+    'core',
+    'core/signal',
+    'core/computed',
+    'core/context',
+    'core/scheduler',
+    //
+    'react',
+    'react/use-signal',
+    'react/use-computed',
+    'react/use-read',
+    //
+    'event',
+    'event/channel',
+    'event/effect',
+    'event/notifier',
+    //
+    'builder',
+    'builder/value',
+    'builder/node',
+    'builder/sources',
+    'builder/consumers',
+    //
+)

package/vitest.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'vitest/config'
+import path from 'node:path'
+
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: 'node',
+    },
+    resolve: {
+        alias: {
+            '@valentin30/signal': path.resolve(__dirname, 'src'),
+        },
+    },
+})